diff --git a/.clang-tidy b/.clang-tidy
new file mode 100644
index 0000000000..7cb3c16679
--- /dev/null
+++ b/.clang-tidy
@@ -0,0 +1,13 @@
+---
+Checks: >
+  -clang-analyzer-security.insecureAPI.strcat,
+  -clang-analyzer-security.insecureAPI.strcpy,
+  modernize-shrink-to-fit,
+  modernize-use-default-member-init,
+  modernize-use-equals-default,
+  modernize-use-equals-delete,
+  modernize-use-override,
+  performance-*
+HeaderFilterRegex: .*
+WarningsAsErrors: '*'
+...
diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
new file mode 100644
index 0000000000..f12d8c89e7
--- /dev/null
+++ b/.github/FUNDING.yml
@@ -0,0 +1,13 @@
+# These are supported funding model platforms
+
+github: [farindk]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
+custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 91766ca8b8..17aa200b00 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -12,22 +12,19 @@ jobs:
       matrix:
         env:
           - { NAME: "nothing" }
-          - { NAME: "cmake", WITH_GRAPHICS: 1, WITH_X265: 1, WITH_AOM: 1, WITH_DAV1D: 1, WITH_RAV1E: 1, WITH_LIBDE265: 1, CMAKE: 1 }
-          - { NAME: "tarball", WITH_GRAPHICS: 1, WITH_X265: 1, WITH_AOM: 1, WITH_DAV1D: 1, WITH_RAV1E: 1, WITH_LIBDE265: 1, TARBALL: 1 }
+          - { NAME: "tarball", WITH_GRAPHICS: 1, WITH_X265: 1, WITH_AOM: 1, WITH_LIBDE265: 1, TARBALL: 1 }
           - { NAME: "graphics", WITH_GRAPHICS: 1 }
           - { NAME: "x265", WITH_X265: 1 }
           - { NAME: "x265 / graphics", WITH_GRAPHICS: 1, WITH_X265: 1 }
           - { NAME: "libde265 (1) / graphics", WITH_GRAPHICS: 1, WITH_LIBDE265: 1 }
-          - { NAME: "libde265 (2) / graphics", WITH_GRAPHICS: 1, WITH_LIBDE265: 2 }
           - { NAME: "libde265 (1) / x265 / graphics", WITH_GRAPHICS: 1, WITH_X265: 1, WITH_LIBDE265: 1 }
-          - { NAME: "libde265 (2) / x265 / graphics", WITH_GRAPHICS: 1, WITH_X265: 1, WITH_LIBDE265: 2 }
           - { NAME: "libde265 (1) / x265 / aom / graphics", WITH_GRAPHICS: 1, WITH_X265: 1, WITH_AOM: 1, WITH_LIBDE265: 1 }
           - { NAME: "libde265 (1) / x265 / dav1d / graphics", WITH_GRAPHICS: 1, WITH_X265: 1, WITH_DAV1D: 1, WITH_LIBDE265: 1 }
           - { NAME: "libde265 (1) / x265 / aom / rav1e / graphics", WITH_GRAPHICS: 1, WITH_X265: 1, WITH_AOM: 1, WITH_RAV1E: 1, WITH_LIBDE265: 1 }
     env: ${{ matrix.env }}
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v6
 
     - name: Install dependencies
       run: |
diff --git a/.github/workflows/cifuzz.yml b/.github/workflows/cifuzz.yml
new file mode 100644
index 0000000000..e7e11ce010
--- /dev/null
+++ b/.github/workflows/cifuzz.yml
@@ -0,0 +1,24 @@
+name: CIFuzz
+on: [pull_request]
+jobs:
+  Fuzzing:
+    runs-on: ubuntu-22.04
+    steps:
+    - name: Build Fuzzers
+      id: build
+      uses: google/oss-fuzz/infra/cifuzz/actions/build_fuzzers@master
+      with:
+        oss-fuzz-project-name: 'libheif'
+        dry-run: false
+    - name: Run Fuzzers
+      uses: google/oss-fuzz/infra/cifuzz/actions/run_fuzzers@master
+      with:
+        oss-fuzz-project-name: 'libheif'
+        fuzz-seconds: 600
+        dry-run: false
+    - name: Upload Crash
+      uses: actions/upload-artifact@v7
+      if: failure() && steps.build.outcome == 'success'
+      with:
+        name: artifacts
+        path: ./out/artifacts
diff --git a/.github/workflows/clang.yml b/.github/workflows/clang.yml
index 8781a26a72..06f036e496 100644
--- a/.github/workflows/clang.yml
+++ b/.github/workflows/clang.yml
@@ -13,11 +13,10 @@ jobs:
         env:
           - { NAME: "nothing" }
           - { NAME: "libde265 (1) / x265 / aom / graphics", WITH_GRAPHICS: 1, WITH_X265: 1, WITH_AOM: 1, WITH_LIBDE265: 1 }
-          - { NAME: "libde265 (2) / x265 / aom / graphics", WITH_GRAPHICS: 1, WITH_X265: 1, WITH_AOM: 1, WITH_LIBDE265: 2 }
     env: ${{ matrix.env }}
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v6
 
     - name: Install dependencies
       run: |
@@ -37,3 +36,32 @@ jobs:
         CXX: clang++
       run: |
         ./scripts/run-ci.sh
+
+  tidy:
+    env:
+      WITH_GRAPHICS: 1
+      WITH_X265: 1
+      WITH_AOM: 1
+      WITH_DAV1D: 1
+      WITH_LIBDE265: 1
+      CLANG_TIDY: 1
+    runs-on: ubuntu-22.04
+    steps:
+    - uses: actions/checkout@v6
+
+    - name: Install dependencies
+      run: |
+        ./scripts/install-ci-linux.sh
+        sudo apt install clang-tidy-12
+
+    - name: Prepare CI
+      run: |
+        ./scripts/prepare-ci.sh
+
+    - name: Run tests
+      run: |
+        ./scripts/run-ci.sh
+
+    - name: Run clang-tidy
+      run: |
+        run-clang-tidy-12 -checks=-clang-diagnostic-tautological-compare,-clang-diagnostic-tautological-constant-out-of-range-compare -j$(nproc)
diff --git a/.github/workflows/coverity.yml b/.github/workflows/coverity.yml
index 78a449cc94..13005a4ce3 100644
--- a/.github/workflows/coverity.yml
+++ b/.github/workflows/coverity.yml
@@ -2,26 +2,28 @@ name: coverity
 
 on:
   push:
-    branches: [ coverity ]
+    branches: [ master, coverity ]
 
 jobs:
   scan:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     env:
       TOKEN: ${{ secrets.COVERITY_SCAN_TOKEN }}
       WITH_AOM: 1
+      WITH_DAV1D: 1
       WITH_GRAPHICS: 1
       WITH_LIBDE265: 1
+      WITH_RAV1E: 0
       WITH_X265: 1
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v6
 
     - name: Cache Coverity build tool
-      uses: actions/cache@v2
+      uses: actions/cache@v5
       with:
         path: |
           coverity_tool.tar.gz
-        key: ${{ runner.os }}
+        key: coverity_tool-${{ runner.os }}
 
     - name: Download Coverity build tool
       run: |
@@ -39,10 +41,13 @@ jobs:
 
     - name: Build with Coverity build tool
       run: |
-        export PATH=`pwd`/coverity_tool/bin:$PATH
-        cov-build --dir cov-int make
+        export PATH=$(pwd)/coverity_tool/bin:$PATH
+        export PKG_CONFIG_PATH="$(pwd)/libde265/dist/lib/pkgconfig/:$(pwd)/third-party/rav1e/dist/lib/pkgconfig/:$(pwd)/third-party/dav1d/dist/lib/x86_64-linux-gnu/pkgconfig/"
+        cmake --preset=develop .
+        cov-build --dir cov-int make -j$(nproc)
 
     - name: Submit build result to Coverity Scan
+      if: github.ref == 'refs/heads/coverity'
       run: |
         tar czvf libheif.tar.gz cov-int
         curl --form token=$TOKEN \
diff --git a/.github/workflows/diagram.yml b/.github/workflows/diagram.yml
index 5ef516231f..934729c1ea 100644
--- a/.github/workflows/diagram.yml
+++ b/.github/workflows/diagram.yml
@@ -6,10 +6,10 @@ on:
       - main
 jobs:
   get_data:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     steps:
       - name: Checkout code
-        uses: actions/checkout@master
+        uses: actions/checkout@v6
       - name: Update diagram
         uses: githubocto/repo-visualizer@main
         with:
diff --git a/.github/workflows/emscripten.yml b/.github/workflows/emscripten.yml
index ac6b73bbce..88eb1f1a33 100644
--- a/.github/workflows/emscripten.yml
+++ b/.github/workflows/emscripten.yml
@@ -9,10 +9,10 @@ on:
 jobs:
   emscripten:
     env:
-      EMSCRIPTEN_VERSION: 1.37.26
-    runs-on: ubuntu-latest
+      EMSCRIPTEN_VERSION: 3.1.61
+    runs-on: ubuntu-22.04
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v6
 
     - name: Install emscripten
       run: |
diff --git a/.github/workflows/fuzzer.yml b/.github/workflows/fuzzer.yml
index 184b1e4189..d711e68489 100644
--- a/.github/workflows/fuzzer.yml
+++ b/.github/workflows/fuzzer.yml
@@ -11,12 +11,12 @@ jobs:
     env:
       WITH_AOM: 1
       WITH_GRAPHICS: 1
-      WITH_LIBDE265: 1
+      WITH_LIBDE265: 2
       WITH_X265: 1
       FUZZER: 1
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-22.04
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v6
 
     - name: Install dependencies
       run: |
diff --git a/.github/workflows/gcc-versions.yml b/.github/workflows/gcc-versions.yml
new file mode 100644
index 0000000000..ecede0b873
--- /dev/null
+++ b/.github/workflows/gcc-versions.yml
@@ -0,0 +1,39 @@
+name: gcc-versions
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        env:
+          - { NAME: "gcc-10", WITH_GRAPHICS: 1, WITH_X265: 1, WITH_AOM: 1, WITH_LIBDE265: 3, GCC: 10 }
+          - { NAME: "gcc-11", WITH_GRAPHICS: 1, WITH_X265: 1, WITH_AOM: 1, WITH_LIBDE265: 3, GCC: 11 }
+          - { NAME: "gcc-12", WITH_GRAPHICS: 1, WITH_X265: 1, WITH_AOM: 1, WITH_LIBDE265: 3, GCC: 12 }
+          - { NAME: "gcc-13", WITH_GRAPHICS: 1, WITH_X265: 1, WITH_AOM: 1, WITH_LIBDE265: 3, GCC: 13 }
+          - { NAME: "gcc-14", WITH_GRAPHICS: 1, WITH_X265: 1, WITH_AOM: 1, WITH_LIBDE265: 3, GCC: 14 }
+    env: ${{ matrix.env }}
+    runs-on: ubuntu-24.04
+    steps:
+    - uses: actions/checkout@v6
+
+    - name: Install dependencies
+      run: |
+        ./scripts/install-ci-linux.sh
+        sudo apt install gcc-${GCC} g++-${GCC}
+
+    - name: Prepare CI
+      env:
+        CC: gcc-${{matrix.env.GCC}}
+        CXX: g++-${{matrix.env.GCC}}
+      run: |
+        ./scripts/prepare-ci.sh
+
+    - name: Run tests
+      env:
+        CC: gcc-${{matrix.env.GCC}}
+        CXX: g++-${{matrix.env.GCC}}
+      run: |
+        ./scripts/run-ci.sh
diff --git a/.github/workflows/go.yml b/.github/workflows/go.yml
index 31ae266bb4..b5090e626d 100644
--- a/.github/workflows/go.yml
+++ b/.github/workflows/go.yml
@@ -12,17 +12,16 @@ jobs:
       matrix:
         libde265-version:
           - "1"
-          - "2"
     env:
       WITH_LIBDE265: ${{ matrix.libde265-version }}
       WITH_X265: 1
       WITH_GRAPHICS: 1
       GO: 1
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v6
 
-    - uses: actions/setup-go@v2
+    - uses: actions/setup-go@v6
       with:
         go-version: "1.10"
 
diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml
index 7861b74499..b47626ac26 100644
--- a/.github/workflows/lint.yml
+++ b/.github/workflows/lint.yml
@@ -10,9 +10,9 @@ jobs:
   cpplint:
     env:
       CPPLINT: 1
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v6
 
     - name: Install dependencies
       run: |
@@ -29,9 +29,9 @@ jobs:
   licenses:
     env:
       CHECK_LICENSES: 1
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v6
 
     - name: Install dependencies
       run: |
diff --git a/.github/workflows/mingw.yml b/.github/workflows/mingw.yml
index 967d32722d..740382d708 100644
--- a/.github/workflows/mingw.yml
+++ b/.github/workflows/mingw.yml
@@ -14,9 +14,9 @@ jobs:
           - { MINGW: 32 }
           - { MINGW: 64 }
     env: ${{ matrix.env }}
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-24.04
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v6
 
     - name: Install dependencies
       run: |
diff --git a/.github/workflows/osx.yml b/.github/workflows/osx.yml
index 7520e65091..6b7d7cb274 100644
--- a/.github/workflows/osx.yml
+++ b/.github/workflows/osx.yml
@@ -10,15 +10,15 @@ jobs:
   build:
     strategy:
       matrix:
+        runner: [ macos-15, macos-15-intel ]
         env:
           - { NAME: "nothing" }
-          - { NAME: "cmake", WITH_GRAPHICS: 1, WITH_X265: 1, WITH_AOM: 1, WITH_LIBDE265: 1, CMAKE: 1 }
+          - { NAME: "cmake", WITH_GRAPHICS: 1, WITH_X265: 1, WITH_AOM: 1, WITH_LIBDE265: 1 }
           - { NAME: "libde265 (1) / x265 / graphics", WITH_GRAPHICS: 1, WITH_X265: 1, WITH_LIBDE265: 1 }
-          - { NAME: "libde265 (2) / x265 / graphics", WITH_GRAPHICS: 1, WITH_X265: 1, WITH_LIBDE265: 2 }
     env: ${{ matrix.env }}
-    runs-on: macos-10.15
+    runs-on: ${{ matrix.runner }}
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v6
 
     - name: Install dependencies
       run: |
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 0b871dbe50..e1072d7456 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -10,9 +10,12 @@ jobs:
   test:
     env:
       TESTS: 1
-    runs-on: ubuntu-latest
+      WITH_AOM: 1
+      WITH_LIBDE265: 1
+      WITH_X265: 1
+    runs-on: ubuntu-22.04
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v6
 
     - name: Install dependencies
       run: |
diff --git a/.gitignore b/.gitignore
index 79e9646b3c..2dd265018c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,40 +1,11 @@
-*.la
-*.lo
-*.o
-*.pc
-m4/lt*.m4
-libheif/*.a
+# Please put your IDE or OS specific ignores into a global .gitignore file.
+# see here: https://stackoverflow.com/questions/7335420/global-git-ignore
 
-.deps
-.libs
-aclocal.m4
-autom4te.cache/
-compile
-config.*
-configure
-depcomp
-examples/heif-convert
-examples/heif-enc
-examples/heif-info
-examples/heif-test
-examples/heif-test-go
-examples/heif-thumbnailer
-examples/src
-examples/test-c-api
-go/go
-go/src
-install-sh
-libtool
-libheif.js
-libheif.js.map
-libheif.min.js
-ltmain.sh
-Makefile
-Makefile.in
-m4/libtool.m4
-missing
-out.bin
-libheif/*-fuzzer
-libheif/heif_version.h
-stamp-h1
-tests/test-race
+build
+_build
+buildjs
+CMakeUserPresets.json
+third-party/SVT-AV1/
+third-party/dav1d/
+third-party/libwebp/
+third-party/rav1e/
\ No newline at end of file
diff --git a/CMakeLists.txt b/CMakeLists.txt
index aa07dd647f..0f89ea4dbb 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,41 +1,60 @@
-cmake_minimum_required (VERSION 3.13)
+cmake_minimum_required (VERSION 3.16.3) # Oldest Ubuntu LTS (20.04 currently)
 
-project(libheif LANGUAGES C CXX VERSION 1.12.0.0)
+project(libheif LANGUAGES C CXX VERSION 1.21.2)
+
+# compatibility_version is never allowed to be decreased for any specific SONAME.
+# Libtool in the libheif-1.15.1 release had set it to 17.0.0, so we have to use this for the v1.x.y versions.
+# With v2.0.0, we can reset this to more closely follow the real version name, i.e. "2.0.0".
+# CMake 3.17.0 added "MACHO_COMPATIBILITY_VERSION", but we are currently stuck at cmake 3.16.3.
+set(MACOS_COMPATIBLE_VERSION "17.0.0")
 
 # https://cmake.org/cmake/help/v3.1/policy/CMP0054.html
-cmake_policy(SET CMP0054 NEW)
+cmake_policy(VERSION 3.0...3.22)
 include(GNUInstallDirs)
 
 # The version number.
 set (PACKAGE_VERSION ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH})
 
-# Check for unistd.h
-
-include (${CMAKE_ROOT}/Modules/CheckIncludeFile.cmake)
+# Check for header files.
+include (${CMAKE_ROOT}/Modules/CheckIncludeFileCXX.cmake)
 
-CHECK_INCLUDE_FILE(unistd.h HAVE_UNISTD_H)
+CHECK_INCLUDE_FILE_CXX(bit HAVE_BIT)
+if (HAVE_BIT)
+  add_definitions(-DHAVE_BIT)
+endif()
 
+CHECK_INCLUDE_FILE_CXX(unistd.h HAVE_UNISTD_H)
 if (HAVE_UNISTD_H)
   add_definitions(-DHAVE_UNISTD_H)
 endif()
 
+if (APPLE)
+  option(BUILD_FRAMEWORK "Build as Apple Frameworks" OFF)
+endif()
 
 if(NOT MSVC)
-  add_definitions(-Wall)
-  add_definitions(-Werror)
-  add_definitions(-Wsign-compare)
-  add_definitions(-Wconversion)
-  add_definitions(-Wno-sign-conversion)
-  add_definitions(-Wno-error=conversion)
-  add_definitions(-Wno-error=unused-parameter)
-  add_definitions(-Wno-error=deprecated-declarations)
+  # cmake 3.24 introduces this variable, but for backward compatibility, we set it explicitly
+  if (CMAKE_COMPILE_WARNING_AS_ERROR)
+      add_compile_options(-Werror)
+  endif ()
+
+  add_compile_options(-Wall)
+  add_compile_options(-Wsign-compare)
+  add_compile_options(-Wconversion)
+  add_compile_options(-Wno-sign-conversion)
+  add_compile_options(-Wno-error=conversion)
+  add_compile_options(-Wno-error=unused-parameter)
+  add_compile_options(-Wno-error=deprecated-declarations)
+  if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+      add_compile_options(-Wno-error=tautological-compare)
+      add_compile_options(-Wno-error=tautological-constant-out-of-range-compare)
+  endif ()
 endif()
 
-set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 
-set(CMAKE_CXX_VISIBILITY_PRESET hidden)
 set(CMAKE_VISIBILITY_INLINES_HIDDEN 1)
 
 set(CMAKE_POSITION_INDEPENDENT_CODE ON)
@@ -48,122 +67,621 @@ option(BUILD_SHARED_LIBS "Build shared libraries" ON)
 include(CheckCXXCompilerFlag)
 CHECK_CXX_COMPILER_FLAG(-Wno-error=potentially-evaluated-expression has_potentially_evaluated_expression)
 if (has_potentially_evaluated_expression)
-  add_definitions(-Wno-error=potentially-evaluated-expression)
+  add_compile_options(-Wno-error=potentially-evaluated-expression)
 endif()
 
 LIST (APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake/modules")
 
-option(WITH_LIBDE265 "Build libde265 decoder" ON)
+# TODO: when our minimum CMake reaches 3.20, replace this with "CMAKE_<LANG>_BYTE_ORDER"
+include (TestBigEndian)
+TEST_BIG_ENDIAN(IS_BIG_ENDIAN)
+add_compile_definitions(IS_BIG_ENDIAN=${IS_BIG_ENDIAN})
+
+option(HEIF_WITH_OMAF "Enable omnidirectional media format (OMAF) support." ON)
+
+# --- codec plugins
+
+option(ENABLE_PLUGIN_LOADING "Support loading of plugins" ON)
+set(PLUGIN_DIRECTORY "${CMAKE_INSTALL_FULL_LIBDIR}/libheif" CACHE STRING "Plugin directory")
+set(PLUGIN_INSTALL_DIRECTORY "" CACHE STRING "Plugin install directory (leaving it empty will use PLUGIN_DIRECTORY)")
+
+if (ENABLE_PLUGIN_LOADING)
+    set(PLUGIN_LOADING_SUPPORTED_AND_ENABLED TRUE)
+
+    if (PLUGIN_INSTALL_DIRECTORY STREQUAL "")
+        set(COMPUTED_PLUGIN_INSTALL_DIRECTORY ${PLUGIN_DIRECTORY})
+    else ()
+        set(COMPUTED_PLUGIN_INSTALL_DIRECTORY ${PLUGIN_INSTALL_DIRECTORY})
+    endif ()
+
+    install(DIRECTORY DESTINATION ${COMPUTED_PLUGIN_INSTALL_DIRECTORY} DIRECTORY_PERMISSIONS
+        OWNER_WRITE OWNER_READ OWNER_EXECUTE
+        GROUP_READ GROUP_EXECUTE
+        WORLD_READ WORLD_EXECUTE)
+endif()
+
+macro(plugin_option optionVariableName displayName defaultEnabled defaultPlugin)
+    option(WITH_${optionVariableName} "Build ${displayName}" ${defaultEnabled})
+    option(WITH_${optionVariableName}_PLUGIN "Build ${displayName} as a plugin" ${defaultPlugin})
+endmacro()
+
+macro(plugin_compilation_info optionVariableName detectionVariable displayName)
+    if (${detectionVariable}_FOUND AND WITH_${optionVariableName}_PLUGIN AND PLUGIN_LOADING_SUPPORTED_AND_ENABLED)
+        set(msg "+ separate plugin")
+    elseif (${detectionVariable}_FOUND)
+        set(msg "+ built-in")
+    elseif (WITH_${optionVariableName})
+        set(msg "- not found")
+    else()
+        set(msg "- disabled")
+    endif ()
+
+    string(LENGTH "${displayName}" len)
+    math(EXPR fill "38 - ${len}")
+    string(SUBSTRING "                                                   " 0 ${fill} filler)
+    message("${displayName}${filler}: ${msg}")
+    unset(msg)
+endmacro()
+
+# libde265
+
+plugin_option(LIBDE265 "libde265 HEVC decoder" ON OFF)
 if (WITH_LIBDE265)
-    find_package(Libde265)
-endif ()
+    find_package(LIBDE265)
+endif()
 
-option(WITH_X265 "Build x265 encoder" ON)
+# x265
+
+plugin_option(X265 "x265 HEVC encoder" ON OFF)
 if (WITH_X265)
     find_package(X265)
-endif ()
-
-option(WITH_AOM "Build aom encoder/decoder" ON)
-if (WITH_AOM)
-    find_package(LibAOM)
 endif()
 
-option(WITH_RAV1E "Build rav1e encoder" ON)
-if (WITH_RAV1E)
-    find_package(Rav1e)
+# kvazaar
+
+plugin_option(KVAZAAR "kvazaar HEVC encoder" OFF OFF)
+if (WITH_KVAZAAR)
+    find_package(kvazaar)
+    if ("${HAVE_KVAZAAR_ENABLE_LOGGING}")
+        add_definitions(-DHAVE_KVAZAAR_ENABLE_LOGGING=1)
+    else ()
+        add_definitions(-DHAVE_KVAZAAR_ENABLE_LOGGING=0)
+    endif ()
+    if (HAVE_KVAZAAR_VERSION_STRING)
+        add_definitions(-DHAVE_KVAZAAR_VERSION_STRING=1)
+    else ()
+        add_definitions(-DHAVE_KVAZAAR_VERSION_STRING=0)
+    endif ()
 endif ()
 
-option(WITH_DAV1D "Build dav1d decoder" ON)
-if (WITH_DAV1D)
-    find_package(Dav1d)
-endif ()
+# uvg266
 
-if (LIBDE265_FOUND)
-    message("HEIF decoder, libde265: found")
-else ()
-    message("HEIF decoder, libde265: not found")
+plugin_option(UVG266 "uvg266 VVC encoder" OFF OFF)
+if (WITH_UVG266)
+    find_package(UVG266)
+    if ("${HAVE_UVG266_ENABLE_LOGGING}")
+        add_definitions(-DHAVE_UVG266_ENABLE_LOGGING=1)
+    else ()
+        add_definitions(-DHAVE_UVG266_ENABLE_LOGGING=0)
+    endif ()
 endif ()
 
-if (X265_FOUND)
-    message("HEIF encoder, x265: found")
-else ()
-    message("HEIF encoder, x265: not found")
+# vvdec
+
+plugin_option(VVDEC "vvdec VVC decoder" OFF OFF)
+if (WITH_VVDEC)
+    # TODO: how to do configure vvdec cleanly?
+    find_package(Threads REQUIRED)
+    find_package(vvdec 3.0.0)
+    if (vvdec_FOUND)
+        set(vvdec_LIBRARIES vvdec::vvdec)
+    endif()
 endif ()
 
-if (AOM_ENCODER_FOUND)
-    message("AVIF encoder, aom: found")
-else ()
-    message("AVIF encoder, aom: not found")
+# vvenc
+
+plugin_option(VVENC "vvenc VVC encoder" OFF OFF)
+if (WITH_VVENC)
+    # TODO: how to do configure vvenc cleanly?
+    find_package(Threads REQUIRED)
+    find_package(vvenc 1.12.0)
+    if (vvenc_FOUND)
+        set(vvenc_LIBRARIES vvenc::vvenc)
+    endif()
 endif ()
 
-if (AOM_DECODER_FOUND)
-    message("AVIF decoder, aom: found")
-else ()
-    message("AVIF decoder, aom: not found")
+# x264
+
+plugin_option(X264 "x264 AVC encoder" ON OFF)
+if (WITH_X264)
+    find_package(X264)
+endif()
+
+# openh264 decoder
+
+plugin_option(OpenH264_DECODER "OpenH264 decoder" ON OFF)
+# plugin_option(OpenH264_ENCODER "OpenH264 encoder" ON OFF)
+if (WITH_OpenH264_ENCODER OR WITH_OpenH264_DECODER)
+    find_package(OpenH264)
+
+    # When decoding/encoding is disabled, overwrite the *_FOUND variables, because they are used to ultimately decide what to build.
+    # TODO
+    if (OpenH264_FOUND AND WITH_OpenH264_DECODER)
+        set(OpenH264_DECODER_FOUND TRUE)
+    endif()
+#    if (OpenH264_FOUND AND WITH_OpenH264_ENCODER)
+#        set(OpenH264_ENCODER_FOUND TRUE)
+#    endif()
+endif()
+
+
+
+# dav1d
+
+plugin_option(DAV1D "Dav1d AV1 decoder" OFF ON)
+if (WITH_DAV1D)
+    find_package(DAV1D)
+endif()
+
+# aom
+
+plugin_option(AOM_DECODER "AOM AV1 decoder" ON OFF)
+plugin_option(AOM_ENCODER "AOM AV1 encoder" ON OFF)
+if (WITH_AOM_ENCODER OR WITH_AOM_DECODER)
+    find_package(AOM)
+
+    # When decoding/encoding is disabled, overwrite the *_FOUND variables, because they are used to ultimately decide what to build.
+    if (NOT WITH_AOM_DECODER)
+        set(AOM_DECODER_FOUND FALSE)
+    endif()
+    if (NOT WITH_AOM_ENCODER)
+        set(AOM_ENCODER_FOUND FALSE)
+    endif()
+endif()
+
+# svt
+
+plugin_option(SvtEnc "SVT AV1 encoder" OFF ON)
+if (WITH_SvtEnc)
+    find_package(SvtEnc)
+endif()
+
+# rav1e
+
+plugin_option(RAV1E "Rav1e AV1 encoder" OFF ON)
+if (WITH_RAV1E)
+    find_package(RAV1E)
+endif()
+
+# jpeg
+
+plugin_option(JPEG_DECODER "JPEG decoder" OFF OFF)
+plugin_option(JPEG_ENCODER "JPEG encoder" OFF OFF)
+if (WITH_JPEG_ENCODER OR WITH_JPEG_DECODER)
+    find_package(JPEG)
+endif()
+
+# openjpeg
+
+plugin_option(OpenJPEG_ENCODER "OpenJPEG J2K encoder" OFF ON)
+plugin_option(OpenJPEG_DECODER "OpenJPEG J2K decoder" OFF ON)
+if (WITH_OpenJPEG_ENCODER OR WITH_OpenJPEG_DECODER)
+    find_package(OpenJPEG 2)
+
+    # Since the above does not work with Ubuntu 22.04 and Ubuntu 24.04, check again without version number
+    if (NOT OpenJPEG_FOUND)
+      find_package(OpenJPEG)
+
+      if (OpenJPEG_FOUND AND NOT OPENJPEG_MAJOR_VERSION STREQUAL "2")
+          message("OpenJPEG found, but we need version 2.x.x")
+          set(OpenJPEG_FOUND FALSE)
+      endif()
+    endif()
+endif()
+
+# ffmpeg
+
+plugin_option(FFMPEG_DECODER "FFMPEG HEVC decoder (HW accelerated)" OFF OFF)
+if (WITH_FFMPEG_DECODER)
+    find_package(FFMPEG COMPONENTS avcodec avutil)
 endif ()
 
-if (RAV1E_FOUND)
-    message("AVIF encoder, rav1e: found")
-else ()
-    message("AVIF encoder, rav1e: not found")
+# openjph
+
+plugin_option(OPENJPH_ENCODER "OpenJPH HT-J2K encoder" OFF ON)
+# plugin_option(OPENJPH_DECODER "OpenJPH HT-J2K decoder" OFF ON)
+if (WITH_OPENJPH_ENCODER OR WITH_OPENJPH_DECODER)
+    find_package(OPENJPH)
+endif()
+
+# uncompressed
+
+option(WITH_UNCOMPRESSED_CODEC " Support internal ISO/IEC 23001-17 uncompressed codec (experimental) " OFF)
+
+# Web codecs
+
+option(WITH_WEBCODECS "Support HEVC decoding through browser web codecs API (experimental)" OFF)
+
+if (WITH_WEBCODECS)
+   set(WEBCODECS_FOUND TRUE) # There is no library for web-codecs. Always mark as found.
+endif()
+
+# --- show codec compilation summary
+
+message("\n=== Summary of compiled codecs ===")
+plugin_compilation_info(LIBDE265 LIBDE265 "libde265 HEVC decoder")
+plugin_compilation_info(FFMPEG_DECODER FFMPEG_avcodec "FFMPEG HEVC decoder (HW acc)")
+plugin_compilation_info(WEBCODECS WEBCODECS "WebCodecs HEVC decoder (experimental)")
+plugin_compilation_info(X265 X265 "x265 HEVC encoder")
+plugin_compilation_info(KVAZAAR KVAZAAR "Kvazaar HEVC encoder")
+plugin_compilation_info(AOM_DECODER AOM_DECODER "AOM AV1 decoder")
+plugin_compilation_info(AOM_ENCODER AOM_ENCODER "AOM AV1 encoder")
+plugin_compilation_info(DAV1D DAV1D "Dav1d AV1 decoder")
+plugin_compilation_info(SvtEnc SvtEnc "SVT AV1 encoder")
+plugin_compilation_info(RAV1E RAV1E "Rav1e AV1 encoder")
+plugin_compilation_info(JPEG_DECODER JPEG "JPEG decoder")
+plugin_compilation_info(JPEG_ENCODER JPEG "JPEG encoder")
+plugin_compilation_info(X264 X264 "x264 AVC encoder")
+plugin_compilation_info(OpenH264_DECODER OpenH264_DECODER "OpenH264 decoder")
+# plugin_compilation_info(OpenH264_ENCODER OpenH264_ENCODER "OpenH264 encoder")
+plugin_compilation_info(OpenJPEG_DECODER OpenJPEG "OpenJPEG J2K decoder")
+plugin_compilation_info(OpenJPEG_ENCODER OpenJPEG "OpenJPEG J2K encoder")
+# plugin_compilation_info(OPENJPH_DECODER OPENJPH "OpenJPH HT-J2K decoder")
+plugin_compilation_info(OPENJPH_ENCODER OPENJPH "OpenJPH HT-J2K encoder")
+plugin_compilation_info(UVG266_ENCODER UVG266 "uvg266 VVC encoder")
+plugin_compilation_info(VVENC vvenc "vvenc VVC encoder")
+plugin_compilation_info(VVDEC vvdec "vvdec VVC decoder")
+
+# --- show summary which formats are supported
+
+macro(format_compilation_info formatName decoding_supported encoding_supported)
+    if (${decoding_supported})
+        set(decoding "YES")
+    else()
+        set(decoding "NO ")
+    endif()
+
+    if (${encoding_supported})
+        set(encoding "YES")
+    else()
+        set(encoding "NO ")
+    endif()
+
+    string(LENGTH "${formatName}" len)
+    math(EXPR fill "12 - ${len}")
+    string(SUBSTRING "                                        " 0 ${fill} filler)
+    message("${formatName}${filler}    ${decoding}        ${encoding}")
+    unset(msg)
+endmacro()
+
+
+if (LIBDE265_FOUND OR FFMPEG_avcodec_FOUND OR WITH_WEBCODECS)
+    set(SUPPORTS_HEIC_DECODING TRUE)
+endif()
+if (X265_FOUND OR KVAZAAR_FOUND)
+    set(SUPPORTS_HEIC_ENCODING TRUE)
+endif()
+if (AOM_DECODER_FOUND OR DAV1D_FOUND)
+    set(SUPPORTS_AVIF_DECODING TRUE)
+endif()
+if (AOM_ENCODER_FOUND OR RAV1E_FOUND OR SvtEnc_FOUND)
+    set(SUPPORTS_AVIF_ENCODING TRUE)
 endif ()
+if (JPEG_FOUND AND WITH_JPEG_DECODER)
+    set(SUPPORTS_JPEG_DECODING TRUE)
+endif()
+if (JPEG_FOUND AND WITH_JPEG_ENCODER)
+    set(SUPPORTS_JPEG_ENCODING TRUE)
+endif()
+if (OpenJPEG_FOUND AND WITH_OpenJPEG_DECODER)
+    set(SUPPORTS_J2K_DECODING TRUE)
+    set(SUPPORTS_J2K_HT_DECODING TRUE)
+endif()
+if (OpenJPEG_FOUND AND WITH_OpenJPEG_ENCODER)
+    set(SUPPORTS_J2K_ENCODING TRUE)
+endif()
+if (OPENJPH_FOUND AND WITH_OPENJPH_ENCODER)
+    set(SUPPORTS_J2K_HT_ENCODING TRUE)
+endif()
+if (OPENJPH_FOUND AND WITH_OPENJPH_DECODER)
+    set(SUPPORTS_J2K_HT_ENCODING TRUE)
+endif()
+if (UVG266_FOUND OR vvenc_FOUND)
+    set(SUPPORTS_VVC_ENCODING TRUE)
+endif()
+if (vvdec_FOUND AND WITH_VVDEC)
+    set(SUPPORTS_VVC_DECODING TRUE)
+endif()
+if (OpenH264_DECODER_FOUND)
+    set(SUPPORTS_AVC_DECODING TRUE)
+endif()
+if (X264_FOUND)
+    set(SUPPORTS_AVC_ENCODING TRUE)
+endif()
 
-if (DAV1D_FOUND)
-    message("AVIF decoder, dav1d: found")
-else ()
-    message("AVIF decoder, dav1d: not found")
+if (WITH_UNCOMPRESSED_CODEC)
+    set(SUPPORTS_UNCOMPRESSED_DECODING TRUE)
+    set(SUPPORTS_UNCOMPRESSED_ENCODING TRUE)
+endif()
+
+message("\n=== Supported formats ===")
+message("format        decoding   encoding")
+format_compilation_info("AVC"  SUPPORTS_AVC_DECODING SUPPORTS_AVC_ENCODING)
+format_compilation_info("AVIF" SUPPORTS_AVIF_DECODING SUPPORTS_AVIF_ENCODING)
+format_compilation_info("HEIC" SUPPORTS_HEIC_DECODING SUPPORTS_HEIC_ENCODING)
+format_compilation_info("JPEG" SUPPORTS_JPEG_DECODING SUPPORTS_JPEG_ENCODING)
+format_compilation_info("JPEG2000" SUPPORTS_J2K_DECODING SUPPORTS_J2K_ENCODING)
+format_compilation_info("JPEG2000-HT" SUPPORTS_J2K_HT_DECODING SUPPORTS_J2K_HT_ENCODING)
+format_compilation_info("Uncompressed" SUPPORTS_UNCOMPRESSED_DECODING SUPPORTS_UNCOMPRESSED_ENCODING)
+format_compilation_info("VVC"  SUPPORTS_VVC_DECODING SUPPORTS_VVC_ENCODING)
+
+message("")
+
+# --- Libsharpyuv color space transforms
+
+option(WITH_LIBSHARPYUV "Build libsharpyuv" ON)
+option(WITH_LIBSHARPYUV_INTERNAL "Use the libsharpyuv build in the 'third-party' directory" OFF)
+if (WITH_LIBSHARPYUV)
+   if (WITH_LIBSHARPYUV_INTERNAL)
+       set(LIBSHARPYUV_INCLUDE_DIRS ${PROJECT_SOURCE_DIR}/third-party/libwebp)
+       set(LIBSHARPYUV_LIBRARIES ${PROJECT_SOURCE_DIR}/third-party/libwebp/build/libsharpyuv.a)
+       set(LIBSHARPYUV_FOUND YES)
+   else()
+       find_package(libsharpyuv)
+   endif()
+endif ()
+if (LIBSHARPYUV_FOUND)
+    message("libsharpyuv: found")
+elseif (WITH_${variableName})
+    message("libsharpyuv: not found")
+else()
+    message("libsharpyuv: disabled")
 endif ()
 
+# --- Create libheif pkgconfig file
 
-# Create libheif pkgconfig file
 set(prefix ${CMAKE_INSTALL_PREFIX})
-set(exec_prefix ${CMAKE_INSTALL_PREFIX})
-set(libdir ${CMAKE_INSTALL_FULL_LIBDIR})
-set(includedir ${CMAKE_INSTALL_FULL_INCLUDEDIR})
-if (LIBDE265_FOUND)
-    list(APPEND REQUIRES_PRIVATE "libde265")
-    set(have_libde265 yes)
+set(exec_prefix "\${prefix}")
+if(IS_ABSOLUTE "${CMAKE_INSTALL_LIBDIR}")
+    set(libdir "${CMAKE_INSTALL_LIBDIR}")
 else()
-    set(have_libde265 no)
+    set(libdir "\${exec_prefix}/${CMAKE_INSTALL_LIBDIR}")
 endif()
-if (X265_FOUND)
-    list(APPEND REQUIRES_PRIVATE "x265")
-    set(have_x265 yes)
+if(IS_ABSOLUTE "${CMAKE_INSTALL_INCLUDEDIR}")
+    set(includedir "${CMAKE_INSTALL_INCLUDEDIR}")
 else()
-    set(have_x265 no)
+    set(includedir "\${prefix}/${CMAKE_INSTALL_INCLUDEDIR}")
 endif()
-if (AOM_DECODER_FOUND OR AOM_ENCODER_FOUND)
+if (LIBDE265_FOUND AND NOT (PLUGIN_LOADING_SUPPORTED_AND_ENABLED AND WITH_LIBDE265_PLUGIN))
+    list(APPEND REQUIRES_PRIVATE "libde265")
+endif()
+if (X265_FOUND AND NOT (PLUGIN_LOADING_SUPPORTED_AND_ENABLED AND WITH_X265_PLUGIN))
+    list(APPEND REQUIRES_PRIVATE "x265")
+endif()
+if (KVAZAAR_FOUND AND NOT (PLUGIN_LOADING_SUPPORTED_AND_ENABLED AND WITH_KVAZAAR_PLUGIN))
+    list(APPEND REQUIRES_PRIVATE "kvazaar")
+endif()
+if (OpenH264_FOUND AND (WITH_OpenH264_DECODER AND NOT (PLUGIN_LOADING_SUPPORTED_AND_ENABLED AND WITH_OpenH264_DECODER_PLUGIN)))
+    list(APPEND REQUIRES_PRIVATE "openh264")
+endif()
+if (X264_FOUND AND (WITH_X264 AND NOT (PLUGIN_LOADING_SUPPORTED_AND_ENABLED AND WITH_X264_PLUGIN)))
+    list(APPEND REQUIRES_PRIVATE "x264")
+endif()
+if ((AOM_DECODER_FOUND AND NOT (PLUGIN_LOADING_SUPPORTED_AND_ENABLED AND WITH_AOM_DECODER_PLUGIN))
+        OR (AOM_ENCODER_FOUND AND NOT (PLUGIN_LOADING_SUPPORTED_AND_ENABLED AND WITH_AOM_ENCODER_PLUGIN)))
     list(APPEND REQUIRES_PRIVATE "aom")
 endif()
-if (DAV1D_FOUND)
+if (FFMPEG_DECODER_FOUND AND NOT (PLUGIN_LOADING_SUPPORTED_AND_ENABLED AND WITH_FFMPEG_DECODER_PLUGIN))
+    list(APPEND REQUIRES_PRIVATE "ffmpeg")
+endif()
+if (DAV1D_FOUND AND NOT (PLUGIN_LOADING_SUPPORTED_AND_ENABLED AND WITH_DAV1D_PLUGIN))
     list(APPEND REQUIRES_PRIVATE "dav1d")
 endif()
-if (RAV1E_FOUND)
+if (RAV1E_FOUND AND NOT (PLUGIN_LOADING_SUPPORTED_AND_ENABLED AND WITH_RAV1E_PLUGIN))
     list(APPEND REQUIRES_PRIVATE "rav1e")
 endif()
-if (AOM_DECODER_FOUND OR DAV1D_FOUND)
-    set(have_avif_decoder yes)
-else()
-    set(have_avif_decoder no)
+if (SvtEnc_FOUND AND NOT (PLUGIN_LOADING_SUPPORTED_AND_ENABLED AND WITH_SvtEnc_PLUGIN))
+    list(APPEND REQUIRES_PRIVATE "SvtAv1Enc")
 endif()
-if (AOM_ENCODER_FOUND OR RAV1E_FOUND)
-    set(have_avif_encoder yes)
-else()
-    set(have_avif_encoder no)
+if (JPEG_FOUND AND ((WITH_JPEG_DECODER AND NOT (PLUGIN_LOADING_SUPPORTED_AND_ENABLED AND WITH_JPEG_DECODER_PLUGIN)) OR (WITH_JPEG_ENCODER AND NOT (PLUGIN_LOADING_SUPPORTED_AND_ENABLED AND WITH_JPEG_ENCODER_PLUGIN))))
+    list(APPEND REQUIRES_PRIVATE "libjpeg")
+endif()
+if (OpenJPEG_FOUND AND ((WITH_OpenJPEG_DECODER AND NOT (PLUGIN_LOADING_SUPPORTED_AND_ENABLED AND WITH_OpenJPEG_DECODER_PLUGIN)) OR (WITH_OpenJPEG_ENCODER AND NOT (PLUGIN_LOADING_SUPPORTED_AND_ENABLED AND WITH_OpenJPEG_ENCODER_PLUGIN))))
+    list(APPEND REQUIRES_PRIVATE "libopenjp2")
+endif()
+if (OPENJPH_FOUND AND (WITH_OPENJPH_ENCODER AND NOT (PLUGIN_LOADING_SUPPORTED_AND_ENABLED AND WITH_OPENJPH_ENCODER_PLUGIN)))
+    list(APPEND REQUIRES_PRIVATE "openjph")
+endif()
+if (LIBSHARPYUV_FOUND)
+    list(APPEND REQUIRES_PRIVATE "libsharpyuv")
+endif()
+if (WITH_HEADER_COMPRESSION OR WITH_UNCOMPRESSED_CODEC)
+    find_package(ZLIB)
+    if (ZLIB_FOUND)
+        message("zlib found")
+        list(APPEND REQUIRES_PRIVATE "zlib")
+    else()
+        message("zlib not found")
+    endif()
+
+    find_package(Brotli)
+    if (Brotli_FOUND)
+        message("Brotli found")
+        list(APPEND REQUIRES_PRIVATE "libbrotlidec")
+    else()
+        message("Brotli not found")
+    endif()
+endif()
+if (UVG266_FOUND AND (WITH_UVG266 AND NOT (PLUGIN_LOADING_SUPPORTED_AND_ENABLED AND WITH_UVG266_PLUGIN)))
+    list(APPEND REQUIRES_PRIVATE "uvg266")
+endif()
+if (VVDEC_FOUND AND (WITH_VVDEC AND NOT (PLUGIN_LOADING_SUPPORTED_AND_ENABLED AND WITH_VVDEC_PLUGIN)))
+    list(APPEND REQUIRES_PRIVATE "libvvdec")
 endif()
+if (VVENC_FOUND AND (WITH_VVENC AND NOT (PLUGIN_LOADING_SUPPORTED_AND_ENABLED AND WITH_VVENC_PLUGIN)))
+    list(APPEND REQUIRES_PRIVATE "libvvenc")
+endif()
+
 list(JOIN REQUIRES_PRIVATE " " REQUIRES_PRIVATE)
-set(VERSION ${PROJECT_VERSION})
+
+include(CheckCXXSymbolExists)
+check_cxx_symbol_exists(_LIBCPP_VERSION cstdlib HAVE_LIBCPP)
+if(HAVE_LIBCPP)
+  set(LIBS_PRIVATE "-lc++")
+else()
+  set(LIBS_PRIVATE "-lstdc++")
+endif()
+
+if(HEIF_WITH_OMAF)
+  set(WITH_OMAF "1")
+else ()
+  set(WITH_OMAF "0")
+endif()
 
 configure_file(libheif.pc.in ${CMAKE_CURRENT_BINARY_DIR}/libheif.pc @ONLY)
 
 install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libheif.pc
         DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
 
+# ---
+
 option(WITH_EXAMPLES "Build examples" ON)
+option(WITH_EXAMPLE_HEIF_THUMB "Build heif-thumbnailer tool" ON)
+option(WITH_EXAMPLE_HEIF_VIEW "Build heif-view tool" ON)
+option(WITH_GDK_PIXBUF "Build gdk-pixbuf plugin" ON)
+
+option(BUILD_DEVELOPMENT_TOOLS "Build development tools (heif-gen-bayer, etc.)" OFF)
+
+option(WITH_REDUCED_VISIBILITY "Reduced symbol visibility in library" ON)
+
+option(WITH_HEADER_COMPRESSION OFF)
+option(ENABLE_MULTITHREADING_SUPPORT "Switch off for platforms without multithreading support" ON)
+option(ENABLE_PARALLEL_TILE_DECODING "Will launch multiple decoders to decode tiles in parallel (requires ENABLE_MULTITHREADING_SUPPORT)" ON)
+
+option(ENABLE_EXPERIMENTAL_MINI_FORMAT "Enable experimental (draft) low-overhead box format (likely reduced interoperability)." OFF)
+
+if (WITH_REDUCED_VISIBILITY)
+    set(CMAKE_CXX_VISIBILITY_PRESET hidden)
+else ()
+    set(CMAKE_CXX_VISIBILITY_PRESET default)
+endif ()
+
+add_subdirectory(heifio)
 
 if(WITH_EXAMPLES)
     add_subdirectory (examples)
 endif()
+
+# --- API documentation
+
+# check if Doxygen is installed
+option(BUILD_DOCUMENTATION "Build doxygen documentation" ON)
+if (BUILD_DOCUMENTATION)
+  find_package(Doxygen)
+  if (DOXYGEN_FOUND)
+    # set input and output files
+    set(DOXYGEN_IN ${CMAKE_CURRENT_SOURCE_DIR}/libheif/Doxyfile.in)
+    set(DOXYGEN_OUT ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile)
+
+    # request to configure the file
+    configure_file(${DOXYGEN_IN} ${DOXYGEN_OUT} @ONLY)
+    message("Doxygen build started")
+
+    # note the option ALL which allows to build the docs together with the application
+    add_custom_target( doc_doxygen ALL
+        COMMAND ${DOXYGEN_EXECUTABLE} ${DOXYGEN_OUT}
+        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+        COMMENT "Generating API documentation with Doxygen"
+        VERBATIM )
+  else (DOXYGEN_FOUND)
+    message("Doxygen tool needs to be installed to generate the API documentation")
+  endif (DOXYGEN_FOUND)
+endif(BUILD_DOCUMENTATION)
+
+# --- Testing
+
+option(ENABLE_COVERAGE "" OFF)
+if(ENABLE_COVERAGE)
+  # set compiler flags
+  set(CMAKE_CXX_FLAGS "-O0 -coverage")
+
+  # find required tools
+  find_program(LCOV lcov REQUIRED)
+  find_program(GENHTML genhtml REQUIRED)
+
+  # add coverage target
+  add_custom_target(coverage
+    # gather data
+    COMMAND ${LCOV} --directory . --capture --output-file coverage.info
+    # generate report
+    COMMAND ${GENHTML} --demangle-cpp -o coverage coverage.info
+    WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
+endif()
+
+option(BUILD_TESTING "" ON)
+set(CMAKE_CTEST_ARGUMENTS "--output-on-failure")
+include(CTest)
+if(BUILD_TESTING)
+    # TODO: fix tests on windows.
+    add_subdirectory (tests)
+endif()
+
+
+# --- Fuzzing
+
+option(WITH_FUZZERS "Build the fuzzers (and no other executables)" OFF)
+set(FUZZING_C_COMPILER "clang" CACHE STRING "C compiler to use for fuzzing")
+set(FUZZING_CXX_COMPILER "clang++" CACHE STRING "C++ compiler to use for fuzzing")
+set(FUZZING_COMPILE_OPTIONS "-fsanitize=fuzzer,address,shift,integer -fno-sanitize-recover=shift,integer" CACHE STRING "Compiler options for fuzzing")
+set(FUZZING_LINKER_OPTIONS "" CACHE STRING "Additional linking options for fuzzing")
+
+if (WITH_FUZZERS)
+    set(CMAKE_C_COMPILER ${FUZZING_C_COMPILER})
+    set(CMAKE_CXX_COMPILER ${FUZZING_CXX_COMPILER})
+    message("Using compiler: ${CMAKE_CXX_COMPILER}")
+    separate_arguments(FUZZING_COMPILE_OPTIONS UNIX_COMMAND "${FUZZING_COMPILE_OPTIONS}")
+    separate_arguments(FUZZING_LINKER UNIX_COMMAND "${FUZZING_LINKER_OPTIONS}")
+    add_compile_options(${FUZZING_COMPILE_OPTIONS})
+    add_definitions(-DAVOID_FUZZER_FALSE_POSITIVE=1)
+    add_link_options(${FUZZING_COMPILE_OPTIONS} ${FUZZING_LINKER_OPTIONS})
+
+    add_subdirectory(fuzzing)
+endif()
+
+if (CMAKE_CXX_COMPILER MATCHES "clang\\+\\+$")
+    add_compile_options(-Wno-tautological-constant-out-of-range-compare)
+endif()
+
 add_subdirectory (libheif)
-add_subdirectory (gdk-pixbuf)
+
+if (WITH_GDK_PIXBUF)
+  add_subdirectory (gdk-pixbuf)
+endif()
+
 add_subdirectory (gnome)
+
+
+# --- packaging (source code)
+
+set(CPACK_VERBATIM_VARIABLES YES)
+set(CPACK_SOURCE_GENERATOR TGZ)
+set(CPACK_SOURCE_PACKAGE_FILE_NAME libheif-${PACKAGE_VERSION})
+set(CPACK_SOURCE_IGNORE_FILES
+/.git/
+/.github/
+/.gitignore$
+/build/
+/cmake-build.*/
+/.deps/
+/.idea/
+/.clang-tidy
+~$
+/third-party/.*/ # only exclude the sub-directories, but keep the *.cmd files
+/Testing/
+/logos/
+/Makefile$
+/libtool$
+/libheif.pc$
+stamp-h1$
+)
+include(CPack)
diff --git a/CMakePresets.json b/CMakePresets.json
new file mode 100644
index 0000000000..a969c2833a
--- /dev/null
+++ b/CMakePresets.json
@@ -0,0 +1,200 @@
+{
+  "version": 3,
+  "cmakeMinimumRequired": {
+    "major": 3,
+    "minor": 0,
+    "patch": 0
+  },
+  "configurePresets": [
+    {
+      "name": "develop",
+      "displayName": "development",
+      "description": "Enable all experimental features. Do not use plugins, compile everything built-in.",
+      "cacheVariables": {
+        "CMAKE_BUILD_TYPE": "Debug",
+        "BUILD_SHARED_LIBS": "ON",
+        "BUILD_TESTING" : "ON",
+        "ENABLE_EXPERIMENTAL_FEATURES" : "ON",
+        "CMAKE_COMPILE_WARNING_AS_ERROR" : "OFF",
+
+        "ENABLE_PLUGIN_LOADING" : "OFF",
+        "WITH_AOM_DECODER" : "ON",
+        "WITH_AOM_DECODER_PLUGIN" : "OFF",
+        "WITH_AOM_ENCODER" : "ON",
+        "WITH_AOM_ENCODER_PLUGIN" : "OFF",
+        "WITH_DAV1D" : "ON",
+        "WITH_DAV1D_PLUGIN" : "OFF",
+        "ENABLE_EXPERIMENTAL_MINI_FORMAT" : "ON",
+        "HEIF_WITH_OMAF" : "ON",
+        "WITH_LIBDE265" : "ON",
+        "WITH_LIBDE265_PLUGIN" : "OFF",
+        "WITH_RAV1E" : "ON",
+        "WITH_RAV1E_PLUGIN" : "OFF",
+        "WITH_SvtEnc" : "ON",
+        "WITH_SvtEnc_PLUGIN" : "OFF",
+        "WITH_X265" : "ON",
+        "WITH_X265_PLUGIN" : "OFF",
+        "WITH_X264" : "ON",
+        "WITH_X264_PLUGIN" : "OFF",
+        "WITH_JPEG_DECODER" : "ON",
+        "WITH_JPEG_DECODER_PLUGIN" : "OFF",
+        "WITH_JPEG_ENCODER" : "ON",
+        "WITH_JPEG_ENCODER_PLUGIN" : "OFF",
+        "WITH_UNCOMPRESSED_CODEC" : "ON",
+        "WITH_KVAZAAR" : "ON",
+        "WITH_KVAZAAR_PLUGIN" : "OFF",
+        "WITH_OpenJPEG_DECODER" : "ON",
+        "WITH_OpenJPEG_DECODER_PLUGIN" : "OFF",
+        "WITH_OpenJPEG_ENCODER" : "ON",
+        "WITH_OpenJPEG_ENCODER_PLUGIN" : "OFF",
+        "WITH_OPENJPH_ENCODER" : "ON",
+        "WITH_OPENJPH_ENCODER_PLUGIN" : "OFF",
+        "WITH_FFMPEG_DECODER" : "ON",
+        "WITH_FFMPEG_DECODER_PLUGIN" : "OFF",
+        "WITH_OpenH264_DECODER" : "ON",
+        "WITH_OpenH264_DECODER_PLUGIN" : "OFF",
+        "WITH_UVG266" : "ON",
+        "WITH_UVG266_PLUGIN" : "OFF",
+        "WITH_VVDEC" : "ON",
+        "WITH_VVDEC_PLUGIN" : "OFF",
+        "WITH_VVENC" : "ON",
+        "WITH_VVENC_PLUGIN" : "OFF",
+
+        "WITH_REDUCED_VISIBILITY" : "OFF",
+        "WITH_HEADER_COMPRESSION" : "ON",
+        "WITH_LIBSHARPYUV" : "ON",
+        "WITH_GEOTIFF" : "ON",
+        "WITH_EXAMPLES": "ON",
+        "WITH_FUZZERS": "OFF",
+        "BUILD_DEVELOPMENT_TOOLS": "ON"
+      }
+    },
+    {
+      "name": "release",
+      "displayName": "Standard release build",
+      "description": "Recommended parameters for a release build.",
+      "cacheVariables": {
+        "CMAKE_BUILD_TYPE": "Release",
+        "BUILD_SHARED_LIBS": "ON",
+        "BUILD_TESTING" : "OFF",
+        "ENABLE_EXPERIMENTAL_FEATURES" : "OFF",
+        "HEIF_WITH_OMAF" : "ON",
+        "CMAKE_COMPILE_WARNING_AS_ERROR" : "OFF",
+
+        "ENABLE_PLUGIN_LOADING" : "ON",
+        "WITH_AOM_DECODER" : "ON",
+        "WITH_AOM_DECODER_PLUGIN" : "ON",
+        "WITH_AOM_ENCODER" : "ON",
+        "WITH_AOM_ENCODER_PLUGIN" : "ON",
+        "WITH_DAV1D" : "ON",
+        "WITH_DAV1D_PLUGIN" : "ON",
+        "WITH_LIBDE265" : "ON",
+        "WITH_LIBDE265_PLUGIN" : "ON",
+        "WITH_RAV1E" : "ON",
+        "WITH_RAV1E_PLUGIN" : "ON",
+        "WITH_SvtEnc" : "ON",
+        "WITH_SvtEnc_PLUGIN" : "ON",
+        "WITH_X265" : "ON",
+        "WITH_X265_PLUGIN" : "ON",
+        "WITH_JPEG_DECODER" : "ON",
+        "WITH_JPEG_DECODER_PLUGIN" : "ON",
+        "WITH_JPEG_ENCODER" : "ON",
+        "WITH_JPEG_ENCODER_PLUGIN" : "ON",
+        "WITH_UNCOMPRESSED_CODEC" : "ON",
+        "WITH_KVAZAAR" : "ON",
+        "WITH_KVAZAAR_PLUGIN" : "ON",
+        "WITH_OpenJPEG_DECODER" : "ON",
+        "WITH_OpenJPEG_DECODER_PLUGIN" : "ON",
+        "WITH_OpenJPEG_ENCODER" : "ON",
+        "WITH_OpenJPEG_ENCODER_PLUGIN" : "ON",
+        "WITH_OPENJPH_ENCODER" : "ON",
+        "WITH_FFMPEG_DECODER" : "ON",
+        "WITH_FFMPEG_DECODER_PLUGIN" : "ON",
+        "WITH_OpenH264_DECODER" : "ON",
+        "WITH_OpenH264_DECODER_PLUGIN" : "ON",
+        "WITH_UVG266" : "ON",
+        "WITH_UVG266_PLUGIN" : "ON",
+        "WITH_VVDEC" : "ON",
+        "WITH_VVDEC_PLUGIN" : "ON",
+        "WITH_VVENC" : "ON",
+        "WITH_VVENC_PLUGIN" : "ON",
+
+        "WITH_REDUCED_VISIBILITY" : "ON",
+        "WITH_HEADER_COMPRESSION" : "ON",
+        "WITH_LIBSHARPYUV" : "ON",
+        "WITH_EXAMPLES": "ON",
+        "WITH_FUZZERS": "OFF"
+      }
+    },
+    {
+      "name": "release-noplugins",
+      "displayName": "Release build without plugins",
+      "description": "Release without plugins with minimal configuration for HEIC and AVIF.",
+      "cacheVariables": {
+        "CMAKE_BUILD_TYPE": "Release",
+        "BUILD_SHARED_LIBS": "ON",
+        "BUILD_TESTING" : "OFF",
+        "ENABLE_EXPERIMENTAL_FEATURES" : "OFF",
+        "HEIF_WITH_OMAF" : "ON",
+        "CMAKE_COMPILE_WARNING_AS_ERROR" : "OFF",
+
+        "ENABLE_PLUGIN_LOADING" : "OFF",
+        "WITH_AOM_DECODER" : "ON",
+        "WITH_AOM_ENCODER" : "ON",
+        "WITH_DAV1D" : "OFF",
+        "WITH_LIBDE265" : "ON",
+        "WITH_RAV1E" : "OFF",
+        "WITH_SvtEnc" : "OFF",
+        "WITH_X265" : "ON",
+        "WITH_JPEG_DECODER" : "OFF",
+        "WITH_JPEG_ENCODER" : "OFF",
+        "WITH_UNCOMPRESSED_CODEC" : "OFF",
+        "WITH_KVAZAAR" : "OFF",
+        "WITH_OpenJPEG_DECODER" : "OFF",
+        "WITH_OpenJPEG_ENCODER" : "OFF",
+        "WITH_FFMPEG_DECODER" : "OFF",
+        "WITH_OpenH264_DECODER" : "OFF",
+        "WITH_UVG266" : "OFF",
+        "WITH_VVDEC" : "OFF",
+        "WITH_VVENC" : "OFF",
+
+        "WITH_REDUCED_VISIBILITY" : "ON",
+        "WITH_HEADER_COMPRESSION" : "OFF",
+        "WITH_LIBSHARPYUV" : "ON",
+        "WITH_EXAMPLES": "ON",
+        "WITH_FUZZERS": "OFF"
+      }
+    },
+    {
+      "name": "testing",
+      "displayName": "Tests",
+      "description": "For running the tests",
+      "cacheVariables": {
+        "CMAKE_BUILD_TYPE": "Debug",
+        "ENABLE_PLUGIN_LOADING" : "OFF",
+        "BUILD_TESTING" : "ON",
+        "ENABLE_EXPERIMENTAL_FEATURES" : "ON",
+        "CMAKE_COMPILE_WARNING_AS_ERROR" : "ON",
+        "WITH_REDUCED_VISIBILITY" : "OFF",
+        "WITH_UNCOMPRESSED_CODEC" : "ON"
+      }
+    },
+    {
+      "name": "fuzzing",
+      "inherits": "release",
+      "displayName": "Fuzzing",
+      "description": "For running the fuzzers",
+      "cacheVariables": {
+        "CMAKE_BUILD_TYPE": "Debug",
+        "BUILD_SHARED_LIBS": "OFF",
+        "BUILD_TESTING" : "OFF",
+        "ENABLE_EXPERIMENTAL_FEATURES" : "ON",
+        "CMAKE_COMPILE_WARNING_AS_ERROR" : "ON",
+        "WITH_FUZZERS" : "ON",
+        "WITH_EXAMPLES" : "OFF",
+        "ENABLE_PLUGIN_LOADING" : "OFF",
+        "WITH_REDUCED_VISIBILITY" : "OFF"
+      }
+    }
+  ]
+}
diff --git a/COPYING b/COPYING
index 5a83fd5b24..f80407e7d5 100644
--- a/COPYING
+++ b/COPYING
@@ -1,5 +1,5 @@
 * The library `libheif` is distributed under the terms of the GNU Lesser General Public License.
-* The sample applications are distributed under the terms of the MIT License.
+* The sample applications and the Go and C++ wrappers are distributed under the terms of the MIT License.
 
 License texts below and in the `COPYING` files of the corresponding subfolders.
 
diff --git a/Makefile.am b/Makefile.am
deleted file mode 100644
index b7b31a0158..0000000000
--- a/Makefile.am
+++ /dev/null
@@ -1,27 +0,0 @@
-ACLOCAL_AMFLAGS = -I m4
-
-SUBDIRS = \
-    libheif \
-    examples \
-    extra \
-    fuzzing \
-    gdk-pixbuf \
-    gnome \
-    go \
-    scripts \
-    tests
-
-pkgconfigdir = $(libdir)/pkgconfig
-pkgconfig_DATA = libheif.pc
-
-EXTRA_DIST = \
-    .github/workflows/*.yml \
-    appveyor.yml \
-    autogen.sh \
-    CMakeLists.txt \
-    CPPLINT.cfg \
-    README.md \
-    pre.js \
-    post.js \
-    build-emscripten.sh \
-    cmake/modules/*.cmake
diff --git a/README.md b/README.md
index b3e1933692..26607f2672 100644
--- a/README.md
+++ b/README.md
@@ -2,53 +2,56 @@
 
 [![Build Status](https://github.com/strukturag/libheif/workflows/build/badge.svg)](https://github.com/strukturag/libheif/actions) [![Build Status](https://ci.appveyor.com/api/projects/status/github/strukturag/libheif?svg=true)](https://ci.appveyor.com/project/strukturag/libheif) [![Coverity Scan Build Status](https://scan.coverity.com/projects/16641/badge.svg)](https://scan.coverity.com/projects/strukturag-libheif)
 
-
-libheif is an ISO/IEC 23008-12:2017 HEIF and AVIF (AV1 Image File Format) file format decoder and encoder.
-
-HEIF and AVIF are new image file formats employing HEVC (h.265) or AV1 image coding, respectively, for the
+libheif is an ISO/IEC 23008-12 HEIF and AVIF (AV1 Image File Format) file format decoder and encoder.
+HEIC and AVIF are new image file formats employing HEVC (H.265) or AV1 image coding, respectively, for the
 best compression ratios currently possible.
 
-libheif makes use of [libde265](https://github.com/strukturag/libde265) for HEIF image decoding and x265 for encoding.
-For AVIF, libaom, dav1d, or rav1e are used as codecs.
+On top of HEIC and AVIF, libheif also supports HEIF images coded with VVC, AVC, JPEG, JPEG-2000, and ISO/IEC 23001-17.
+The ISO/IEC 23001-17 codec is built-in to libheif and allows to store lossless images and video in many different formats.
 
+libheif makes use of various codec libraries for implementing each compression format.
+For HEIC, [libde265](https://github.com/strukturag/libde265) is used by default for decoding and x265 for encoding.
+For AVIF, libaom, dav1d, svt-av1, or rav1e are used as codecs.
+libheif can be built with a subset of the supported codecs to keep the size and the number of dependencies low.
+Alternatively, the libheif codecs can also be built as separate plugins that can be installed and loaded dynamically when used.
 
 ## Supported features
 
-libheif has support for decoding
-* tiled images
-* alpha channels
-* thumbnails
-* reading EXIF and XMP metadata
-* reading the depth channel
+libheif has support for:
+
+* HEIC, AVIF, VVC, AVC, JPEG-in-HEIF, JPEG2000, uncompressed (ISO/IEC 23001-17:2024) codecs
+* alpha channels, depth maps, thumbnails, auxiliary images
 * multiple images in a file
-* image transformations (crop, mirror, rotate)
-* overlay images
-* plugin interface to add alternative codecs for additional formats (AVC, JPEG)
-* decoding of files while downloading (e.g. extract image size before file has been completely downloaded)
-* reading color profiles
-* heix images (10 and 12 bit, chroma 4:2:2)
-
-The encoder supports:
-* lossy compression with adjustable quality
-* lossless compression
-* alpha channels
-* thumbnails
-* save multiple images to a file
-* save EXIF and XMP metadata
-* writing color profiles
-* 10 and 12 bit images
-* monochrome images
-
-## API
+* HEIF image sequences and MP4 video, including alpha channels
+* tiled images with decoding individual tiles and encoding tiled images by adding tiles one after another
+* HDR images, correct color transform according to embedded color profiles
+* image transformations (crop, mirror, rotate), overlay images
+* plugin interface to add alternative codecs
+* reading EXIF and XMP metadata
+* region annotations and mask images
+* streaming of images and video by requesting data from the network through a data-reader interface
+
+Supported codecs:
+| Format       |  Decoders           |  Encoders                    |
+|:-------------|:-------------------:|:----------------------------:|
+| HEIC         | libde265, ffmpeg    | x265, kvazaar                |
+| AVIF         | libaom, dav1d       | libaom, rav1e, svt-av1       |
+| VVC          | vvdec               | vvenc, uvg266                |
+| AVC          | openh264, ffmpeg    | x264                         |
+| JPEG         | libjpeg(-turbo)     | libjpeg(-turbo)              |
+| JPEG2000     | OpenJPEG            | OpenJPEG                     |
+| HTJ2K        | OpenJPEG            | OpenJPH                      |
+| uncompressed | built-in            | built-in                     |
+
+## Programming API
 
 The library has a C API for easy integration and wide language support.
-Note that the API is still work in progress and may still change.
 
-The decoder automatically supports both HEIF and AVIF through the same API. No changes are required to existing code to support AVIF.
+The decoder automatically supports both HEIF and AVIF (and the other compression formats) through the same API. The same decoding code can be used to decode any of them.
 The encoder can be switched between HEIF and AVIF simply by setting `heif_compression_HEVC` or `heif_compression_AV1`
-to `heif_context_get_encoder_for_format()`.
+to `heif_context_get_encoder_for_format()`, or using any of the other compression formats.
 
-Loading the primary image in an HEIF file is as easy as this:
+### Loading the primary image from a HEIF file
 
 ```C
 heif_context* ctx = heif_context_alloc();
@@ -64,9 +67,16 @@ heif_decode_image(handle, &img, heif_colorspace_RGB, heif_chroma_interleaved_RGB
 
 int stride;
 const uint8_t* data = heif_image_get_plane_readonly(img, heif_channel_interleaved, &stride);
+
+// ... process data as needed ...
+
+// clean up resources
+heif_image_release(img);
+heif_image_handle_release(handle);
+heif_context_free(ctx);
 ```
 
-Writing an HEIF file can be done like this:
+### Writing a HEIF file
 
 ```C
 heif_context* ctx = heif_context_alloc();
@@ -84,126 +94,285 @@ heif_context_encode_image(ctx, image, encoder, nullptr, nullptr);
 
 heif_encoder_release(encoder);
 
-heif_context_write_to_file(context, "output.heic");
+heif_context_write_to_file(ctx, "output.heic");
+
+heif_context_free(ctx);
 ```
 
-See the header file `heif.h` for the complete C API.
+### Get the EXIF data from a HEIF file
+
+```C
+heif_item_id exif_id;
+
+int n = heif_image_handle_get_list_of_metadata_block_IDs(image_handle, "Exif", &exif_id, 1);
+if (n==1) {
+  size_t exifSize = heif_image_handle_get_metadata_size(image_handle, exif_id);
+  uint8_t* exifData = malloc(exifSize);
+  struct heif_error error = heif_image_handle_get_metadata(image_handle, exif_id, exifData);
+}
+```
+
+### Image sequences, MP4 video
+
+See the [image sequences API documentation](https://github.com/strukturag/libheif/wiki/Reading-and-Writing-Sequences).
+
+Since HEIF image sequences are very similar to MP4 video, libheif can also read and write MP4 video (without audio)
+with all supported codecs.
+
+### High-resolution tiled images
+
+For very large resolution images, it is not always feasible to process the whole image.
+In this case, `libheif` can process the image tile by tile.
+See the [image tiling API documentation](https://github.com/strukturag/libheif/wiki/Reading-and-Writing-Tiled-Images).
+
+### More documenation
+
+See the header files for the complete C API.
 
 There is also a C++ API which is a header-only wrapper to the C API.
 Hence, you can use the C++ API and still be binary compatible.
 Code using the C++ API is much less verbose than using the C API directly.
 
-There is also an experimental Go API, but this is not stable yet.
-
 
 ## Compiling
 
-This library uses either a standard autoconf/automake build system or CMake.
+This library uses the CMake build system (the earlier autotools build files have been removed in v1.16.0).
 
-When using autoconf, run `./autogen.sh` to build the configuration scripts,
-then call `./configure` and `make`.
+For a minimal configuration, we recommend to use the codecs libde265 and x265 for HEIC and AOM for AVIF.
 Make sure that you compile and install [libde265](https://github.com/strukturag/libde265)
 first, so that the configuration script will find this.
-Preferably, download the `frame-parallel` branch of libde265, as this uses a
-more recent API than the version in the `master` branch.
-Also install x265 and its development files if you want to use HEIF encoding.
-
-For AVIF support, make sure that libaom is installed.
+Also install x265 and its development files if you want to use HEIF encoding, but note that x265 is GPL.
+An alternative to x265 is kvazaar (BSD).
+
+The basic build steps are as follows (--preset argument needs CMake >= 3.21):
+
+````sh
+mkdir build
+cd build
+cmake --preset=release ..
+make
+````
+
+There are CMake presets to cover the most frequent use cases.
+
+* `release`: the preferred preset which compiles all codecs as separate plugins.
+  If you do not want to distribute some of these plugins (e.g. HEIC), you can omit packaging these.
+* `release-noplugins`: this is a smaller, self-contained build of libheif without using the plugin system.
+  A single library is built with support for HEIC and AVIF.
+* `testing`: for building and executing the unit tests. Also the internal library symbols are exposed. Do not use for distribution.
+* `fuzzing`: all codecs like in release build, but configured into a self-contained library with enabled fuzzers. The library should not distributed.
+
+You can optionally adapt these standard configurations to your needs.
+This can be done, for example, by calling `ccmake .` from within the `build` directory.
+
+### CMake configuration variables
+
+Libheif supports many different codecs. In order to reduce the number of dependencies and the library size,
+you can choose which of these codecs to include. Each codec can be compiled either as built-in to the library
+with a hard dependency, or as a separate plugin file that is loaded dynamically.
+
+For each codec, there are two configuration variables:
+
+* `WITH_{codec}`: enables the codec
+* `WITH_{codec}_PLUGIN`: when enabled, the codec is compiled as a separate plugin.
+
+In order to use dynamic plugins, also make sure that `ENABLE_PLUGIN_LOADING` is enabled.
+The placeholder `{codec}` can have these values: `LIBDE265`, `X265`, `AOM_DECODER`, `AOM_ENCODER`, `SvtEnc`, `DAV1D`, `OpenH264`, `X264`, `FFMPEG_DECODER`, `JPEG_DECODER`, `JPEG_ENCODER`, `KVAZAAR`, `OpenJPEG_DECODER`, `OpenJPEG_ENCODER`, `OPENJPH_ENCODER`, `VVDEC`, `VVENC`, `UVG266`, `WEBCODECS`.
+
+Further options are:
+
+* `WITH_UNCOMPRESSED_CODEC`: enable support for uncompressed images according to ISO/IEC 23001-17:2024. This is *experimental*
+   and not available as a dynamic plugin. When enabled, it adds a dependency to `zlib`, and optionally will use `brotli`.
+* `WITH_HEADER_COMPRESSION`: enables support for compressed metadata. When enabled, it adds a dependency to `zlib`.
+   Note that header compression is not widely supported yet.
+* `WITH_LIBSHARPYUV`: enables high-quality YCbCr/RGB color space conversion algorithms (requires `libsharpyuv`,
+   e.g. from the `third-party` directory).
+* `ENABLE_EXPERIMENTAL_FEATURES`: enables functions that are currently in development and for which the API is not stable yet.
+   When this is enabled, a header `heif_experimental.h` will be installed that contains this unstable API.
+   Distributions that rely on a stable API should not enable this.
+* `ENABLE_MULTITHREADING_SUPPORT`: can be used to disable any multithreading support, e.g. for embedded platforms.
+* `ENABLE_PARALLEL_TILE_DECODING`: when enabled, libheif will decode tiled images in parallel to speed up compilation.
+* `PLUGIN_DIRECTORY`: the directory where libheif will search for dynamic plugins when the environment
+  variable `LIBHEIF_PLUGIN_PATH` is not set.
+* `WITH_REDUCED_VISIBILITY`: only export those symbols into the library that are public API.
+  Has to be turned off for running some tests.
 
 ### macOS
 
 1. Install dependencies with Homebrew
 
-    ```
-    brew install automake make pkg-config x265 libde265 libjpeg
+    ```sh
+    brew install cmake make pkg-config x265 libde265 libjpeg libtool
     ```
 
+2. Configure and build project (--preset argument needs CMake >= 3.21):
 
-1. Configure and build project
-
-    ```
-    ./autogen.sh
+    ```sh
+    mkdir build
+    cd build
+    cmake --preset=release ..
     ./configure
     make
     ```
 
 ### Windows
 
-Libheif is included in [Vcpkg](https://github.com/Microsoft/vcpkg/).
+You can build and install libheif using the [vcpkg](https://github.com/Microsoft/vcpkg/) dependency manager:
+
+```sh
+git clone https://github.com/Microsoft/vcpkg.git
+cd vcpkg
+./bootstrap-vcpkg.bat
+./vcpkg integrate install
+./vcpkg install libheif
+```
+
+The libheif port in vcpkg is kept up to date by Microsoft team members and community contributors. If the version is out of date, please [create an issue or pull request](https://github.com/Microsoft/vcpkg) on the vcpkg repository.
+
+### Adding libaom encoder/decoder for AVIF
 
+* Run the `aom.cmd` script in the `third-party` directory to download libaom and
+  compile it.
+
+When running `cmake` or `configure`, make sure that the environment variable
+`PKG_CONFIG_PATH` includes the absolute path to `third-party/aom/dist/lib/pkgconfig`.
 
 ### Adding rav1e encoder for AVIF
 
 * Install `cargo`.
 * Install `cargo-c` by executing
-```
+
+```sh
 cargo install --force cargo-c
 ```
-* Run the `rav1e.cmd` script in directory `third-party` to download rav1e and compile it.
 
-When running `cmake` or `configure`, make sure that the environment variable
-`PKG_CONFIG_PATH` includes the absolute path to `third-party/rav1e/dist/lib/pkgconfig`.
+* Run the `rav1e.cmd` script in the `third-party` directory to download rav1e
+  and compile it.
 
+When running `cmake`, make sure that the environment variable
+`PKG_CONFIG_PATH` includes the absolute path to `third-party/rav1e/dist/lib/pkgconfig`.
 
 ### Adding dav1d decoder for AVIF
 
 * Install [`meson`](https://mesonbuild.com/).
-* Run the `dav1d.cmd` script in directory `third-party` to download dav1d and compile it.
+* Run the `dav1d.cmd` script in the `third-party` directory to download dav1d
+  and compile it.
 
-When running `cmake` or `configure`, make sure that the environment variable
+When running `cmake`, make sure that the environment variable
 `PKG_CONFIG_PATH` includes the absolute path to `third-party/dav1d/dist/lib/x86_64-linux-gnu/pkgconfig`.
 
+### Adding SVT-AV1 encoder for AVIF
+
+You can either use the SVT-AV1 encoder libraries installed in the system or use a self-compiled current version.
+If you want to compile SVT-AV1 yourself,
+
+* Run the `svt.cmd` script in the `third-party` directory to download SVT-AV1
+  and compile it.
+
+You have to enable SVT-AV1 with CMake.
+
+When running `cmake`, make sure that the environment variable
+`PKG_CONFIG_PATH` includes the absolute path to `third-party/SVT-AV1/Build/linux/install/lib/pkgconfig`.
+You may have to replace `linux` in this path with your system's identifier.
+
+## Codec plugins
+
+Starting with v1.14.0, each codec backend can be compiled statically into libheif or as a dynamically loaded plugin.
+You can choose this individually for each codec backend in the CMake settings using `WITH_{codec}_PLUGIN` options.
+Compiling a codec backend as dynamic plugin will generate a shared library that is installed in the system together with libheif.
+The advantage is that only the required plugins have to be installed and libheif has fewer dependencies.
+
+The plugins are loaded from the colon-separated (semicolon-separated on Windows) list of directories stored in the environment variable `LIBHEIF_PLUGIN_PATH`.
+If this variable is empty, they are loaded from a directory specified in the CMake configuration.
+You can also add plugin directories programmatically.
+
+### Codec specific notes
+
+* The FFMPEG decoding plugin can make use of h265 hardware decoders. However, it currently (v1.17.0, ffmpeg v4.4.2) does not work
+  correctly with all streams. Thus, libheif still prefers the libde265 decoder if it is available.
+
+* The "webcodecs" HEVC decoder can only be used in emscripten builds since it uses the web-browser's API. For the same reason, it is not available as a plugin.
+
+## Usage
+
+libheif comes with a set of command line tools:
+* `heif-dec` for decoding HEIF images to JPEG or PNG. It can also decode image sequences or MP4 video.
+* `heif-enc` for encoding JPEG, PNG, TIFF, or Y4M images to HEIF images, image sequences or MP4 video.
+* `heif-info` for getting some overview information about the HEIF file or (using the `-d` option) to dump the full box structure of the file.
+* `heif-view` for displaying HEIF image sequences
+
+### `heif-enc` command line tool
+
+You can find more documentation for the `heif-enc` tool on the [wiki page](https://github.com/strukturag/libheif/wiki/heif%E2%80%90enc-Command-Line-Tool).
+
+### Security limits
+
+Libheif defines some security limits that prevent that very large images exceed the available memory or malicious input files can be used for a denial-of-service attack.
+When you are programming against the libheif API and you need to process very large images, you can set the `heif_security_limits` individually.
+When using `heif-dec`, there is the option to switch off security limits with `--disable-limits`.
+In case a third-party software is using libheif, but does not give you a way to switch off the limits, you can set an environment variable `LIBHEIF_SECURITY_LIMITS=off` to switch it off globally.
+Clearly, only do this if you know what you are doing and you are sure not to process malicious files.
+
+## Encoder benchmark
+
+A current benchmark of the AVIF encoders (as of 14 Oct 2022) can be found on the Wiki page
+[AVIF encoding benchmark](https://github.com/strukturag/libheif/wiki/AVIF-Encoder-Benchmark).
 
 ## Language bindings
 
 * .NET Platform (C#, F#, and other languages): [libheif-sharp](https://github.com/0xC0000054/libheif-sharp)
 * C++: part of libheif
-* Go: part of libheif
+* Go: [libheif-go](https://github.com/strukturag/libheif-go), the wrapper distributed with libheif is deprecated
 * JavaScript: by compilation with emscripten (see below)
 * NodeJS module: [libheif-js](https://www.npmjs.com/package/libheif-js)
-* Python: [pyheif](https://pypi.org/project/pyheif/)
+* Python: [pyheif](https://pypi.org/project/pyheif/), [pillow_heif](https://pypi.org/project/pillow-heif/)
 * Rust: [libheif-sys](https://github.com/Cykooz/libheif-sys)
 * Swift: [libheif-Xcode](https://swiftpackageregistry.com/SDWebImage/libheif-Xcode)
+* JavaFX: [LibHeifFx](https://github.com/lanthale/LibHeifFX)
 
 Languages that can directly interface with C libraries (e.g., Swift, C#) should work out of the box.
 
-
-## Compiling to JavaScript
+## Compiling to JavaScript / WASM
 
 libheif can also be compiled to JavaScript using
 [emscripten](http://kripken.github.io/emscripten-site/).
-See the `build-emscripten.sh` for further information.
-
+It can be built like this (in the libheif directory):
+````
+mkdir buildjs
+cd buildjs
+USE_WASM=0 ../build-emscripten.sh ..
+````
+Set `USE_WASM=1` to build with WASM output.
+See the `build-emscripten.sh` script for further options.
 
 ## Online demo
 
 Check out this [online demo](https://strukturag.github.io/libheif/).
 This is `libheif` running in JavaScript in your browser.
 
-
 ## Example programs
 
 Some example programs are provided in the `examples` directory.
-The program `heif-convert` converts all images stored in an HEIF/AVIF file to JPEG or PNG.
+The program `heif-dec` converts all images stored in an HEIF/AVIF file to JPEG or PNG.
 `heif-enc` lets you convert JPEG files to HEIF/AVIF.
 The program `heif-info` is a simple, minimal decoder that dumps the file structure to the console.
 
 For example convert `example.heic` to JPEGs and one of the JPEGs back to HEIF:
 
-```
+```sh
 cd examples/
-./heif-convert example.heic example.jpeg
+./heif-dec example.heic example.jpeg
 ./heif-enc example-1.jpeg -o example.heif
 ```
 
 In order to convert `example-1.jpeg` to AVIF use:
-```
+
+```sh
 ./heif-enc example-1.jpeg -A -o example.avif
 ```
 
 There is also a GIMP plugin using libheif [here](https://github.com/strukturag/heif-gimp-plugin).
 
-
 ## HEIF/AVIF thumbnails for the Gnome desktop
 
 The program `heif-thumbnailer` can be used as an HEIF/AVIF thumbnailer for the Gnome desktop.
@@ -211,31 +380,45 @@ The matching Gnome configuration files are in the `gnome` directory.
 Place the files `heif.xml` and `avif.xml` into `/usr/share/mime/packages` and `heif.thumbnailer` into `/usr/share/thumbnailers`.
 You may have to run `update-mime-database /usr/share/mime` to update the list of known MIME types.
 
-
 ## gdk-pixbuf loader
 
 libheif also includes a gdk-pixbuf loader for HEIF/AVIF images. 'make install' will copy the plugin
 into the system directories. However, you will still have to run `gdk-pixbuf-query-loaders --update-cache`
 to update the gdk-pixbuf loader database.
 
-
 ## Software using libheif
 
-* GIMP
-* Krita
-* ImageMagick
-* digiKam 7.0.0
-* libvips
+* [GIMP](https://www.gimp.org/)
+* [Krita](https://krita.org)
+* [ImageMagick](https://imagemagick.org/)
+* [GraphicsMagick](http://www.graphicsmagick.org/)
+* [darktable](https://www.darktable.org)
+* [digiKam 7.0.0](https://www.digikam.org/)
+* [libvips](https://github.com/libvips/libvips)
+* [kImageFormats](https://api.kde.org/frameworks/kimageformats/html/index.html)
+* [libGD](https://libgd.github.io/)
 * [Kodi HEIF image decoder plugin](https://kodi.wiki/view/Add-on:HEIF_image_decoder)
 * [bimg](https://github.com/h2non/bimg)
 * [GDAL](https://gdal.org/drivers/raster/heif.html)
 * [OpenImageIO](https://sites.google.com/site/openimageio/)
+* [XnView](https://www.xnview.com)
+
+## Packaging status
+
+[![libheif packaging status](https://repology.org/badge/vertical-allrepos/libheif.svg?exclude_unsupported=1&columns=3&exclude_sources=modules,site&header=libheif%20packaging%20status)](https://repology.org/project/libheif/versions)
+
+## Sponsors
 
-## Source code visualization
+Since I work as an independent developer, I need your support to be able to allocate time for libheif.
+You can [sponsor](https://github.com/sponsors/farindk) the development using the link in the right hand column.
 
-![Visualization of this repo](./diagram.svg)
+A big thank you goes to these major sponsors for supporting the development of libheif:
 
-[Explore source](https://octo-repo-visualization.vercel.app/?repo=strukturag%2Flibheif)
+* AOMedia
+* OGC (Open Geospatial Consortium)
+* Pinterest
+* Shopify <img src="logos/sponsors/shopify.svg" alt="shopify-logo" height="20"/>
+* StrukturAG
 
 ## License
 
@@ -244,5 +427,6 @@ The sample applications are distributed under the terms of the MIT License.
 
 See COPYING for more details.
 
-Copyright (c) 2017-2020 Struktur AG
+Copyright (c) 2017-2020 Struktur AG</br>
+Copyright (c) 2017-2026 Dirk Farin</br>
 Contact: Dirk Farin <dirk.farin@gmail.com>
diff --git a/appveyor.yml b/appveyor.yml
index 446c7bd544..a7d1581cee 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -1,22 +1,40 @@
 # stats available at
 # https://ci.appveyor.com/project/strukturag/libheif
-image: Visual Studio 2019
+image: Visual Studio 2022
 configuration: Release
 cache: c:\tools\vcpkg\installed\
 
-matrix:
-  allow_failures:
-    - arch: arm64 # libde265 currently doesn't support arm64 on vcpkg
-
 environment:
   matrix:
   - arch: x64
+    triplet: x64-windows
+  - arch: Win32
+    triplet: x86-windows
   - arch: arm64
+    triplet: arm64-windows
 
 install:
-  - vcpkg install libde265:%arch%-windows
-  - vcpkg install x265:%arch%-windows
-  - vcpkg install dav1d:%arch%-windows
+  # Build only Release vcpkg libraries (skip Debug) to halve install time
+  - ps: |
+      @('x64-windows', 'x86-windows', 'arm64-windows') | ForEach-Object {
+        $tripletDir = "C:\tools\vcpkg\triplets"
+        $content = (Get-Content "$tripletDir\$_.cmake" -Raw) + "`nset(VCPKG_BUILD_TYPE release)`n"
+        Set-Content "$tripletDir\$_.cmake" $content
+      }
+  # --- Phase 1: remove ffmpeg, upgrade everything else ---
+  #- vcpkg remove ffmpeg:%triplet% --recurse 2>NUL & ver>NUL
+  #- vcpkg upgrade --no-dry-run
+  # --- Phase 2: uncomment the two lines below to compile ffmpeg ---
+  - vcpkg upgrade --no-dry-run
+  - vcpkg install ffmpeg[avcodec]:%triplet%
+  - vcpkg install aom:%triplet%
+  - ps: If (${env:arch} -ne "Win32") { vcpkg install dav1d:${env:triplet} }
+  - vcpkg install libde265:%triplet%
+  - vcpkg install libjpeg-turbo:%triplet%
+  - vcpkg install libpng:%triplet%
+  - vcpkg install tiff:%triplet%
+  - vcpkg install x265:%triplet%
+  - vcpkg install zlib:%triplet%
   - cd c:\tools\vcpkg
   - vcpkg integrate install
   - cd %APPVEYOR_BUILD_FOLDER%
@@ -24,9 +42,12 @@ install:
 before_build:
   - mkdir build
   - cd build
-  - cmake .. -A %arch% -DCMAKE_TOOLCHAIN_FILE=c:/tools/vcpkg/scripts/buildsystems/vcpkg.cmake
+  - cmake .. -A %arch% -DCMAKE_TOOLCHAIN_FILE=c:/tools/vcpkg/scripts/buildsystems/vcpkg.cmake -DWITH_DAV1D=ON -DWITH_AOM_DECODER=ON -DWITH_AOM_ENCODER=ON -DWITH_JPEG_DECODER=ON -DWITH_JPEG_ENCODER=ON -DWITH_UNCOMPRESSED_CODEC=ON -DWITH_HEADER_COMPRESSION=ON -DWITH_FFMPEG_DECODER=ON
+  - dir
 
 build:
+  project: build\libheif.sln
+  parallel: true
   verbosity: normal
 
 artifacts:
diff --git a/autogen.sh b/autogen.sh
deleted file mode 100755
index 2a5d449030..0000000000
--- a/autogen.sh
+++ /dev/null
@@ -1,42 +0,0 @@
-#!/bin/bash
-set -eu
-#
-# HEIF codec.
-# Copyright (c) 2017 struktur AG, Joachim Bauch <bauch@struktur.de>
-#
-# This file is part of libheif.
-#
-# libheif is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# libheif is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with libheif.  If not, see <http://www.gnu.org/licenses/>.
-#
-ROOT="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-
-if [ -d "$ROOT/.git/hooks" ]; then
-    echo "Installing pre-commit hook ..."
-    ln -sf "$ROOT/scripts/pre-commit.hook" "$ROOT/.git/hooks/pre-commit"
-fi
-
-if [ -x "`which autoreconf 2>/dev/null`" ] ; then
-   exec autoreconf -ivf
-fi
-
-LIBTOOLIZE=libtoolize
-SYSNAME=`uname`
-if [ "x$SYSNAME" = "xDarwin" ] ; then
-  LIBTOOLIZE=glibtoolize
-fi
-aclocal -I m4 && \
-	autoheader && \
-	$LIBTOOLIZE && \
-	autoconf && \
-	automake --add-missing --force-missing --copy
diff --git a/build-emscripten.sh b/build-emscripten.sh
index 663e09ed2e..7fe4749a8a 100755
--- a/build-emscripten.sh
+++ b/build-emscripten.sh
@@ -2,60 +2,201 @@
 set -e
 DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
 
-CORES=$(nproc --all)
+if [[ $# -ne 1 ]] ; then
+    echo "Usage: $0 SRCDIR"
+    echo
+    echo "It is recommended to build in a separate directory."
+    echo "Then specify this directory as an argument to this script."
+    echo "Example:"
+    echo "  mkdir buildjs"
+    echo "  cd buildjs"
+    echo "  USE_WASM=0 ../build-emscripten.sh .."
+    echo
+    echo "This should generate a libheif.js and (optionally, without the USE_WASM=0) a libheif.wasm"
+    exit 5
+fi
+
+SRCDIR=$1
+
+CORES="${CORES:-`nproc --all`}"
+
+ENABLE_LIBDE265="${ENABLE_LIBDE265:-1}"
+LIBDE265_VERSION="${LIBDE265_VERSION:-1.0.15}"
+
+ENABLE_AOM="${ENABLE_AOM:-0}"
+AOM_VERSION="${AOM_VERSION:-3.6.1}"
+
+# Webcodecs is not on by default b/c asyncify increases the binary size considerably
+ENABLE_WEBCODECS="${ENABLE_WEBCODECS:-0}"
+
+ENABLE_UNCOMPRESSED="${ENABLE_UNCOMPRESSED:-0}"
+
+# J2K still defunct. OpenJPEG compiles, but library is not picked up by libheif cmake.
+ENABLE_OPENJPEG="${ENABLE_OPENJPEG:-0}"
+OPENJPEG_VERSION="${OPENJPEG_VERSION:-2.5.4}"
+
+STANDALONE="${STANDALONE:-0}"
+DEBUG="${DEBUG:-0}"
+USE_ES6="${USE_ES6:-0}"
+USE_WASM="${USE_WASM:-1}"
+USE_TYPESCRIPT="${USE_TYPESCRIPT:-1}"
+USE_UNSAFE_EVAL="${USE_UNSAFE_EVAL:-1}"
+
 echo "Build using ${CORES} CPU cores"
 
-LIBDE265_VERSION=1.0.2
-[ -s "libde265-${LIBDE265_VERSION}.tar.gz" ] || curl \
-    -L \
-    -o libde265-${LIBDE265_VERSION}.tar.gz \
-    https://github.com/strukturag/libde265/releases/download/v${LIBDE265_VERSION}/libde265-${LIBDE265_VERSION}.tar.gz
-if [ ! -s "libde265-${LIBDE265_VERSION}/libde265/.libs/libde265.so" ]; then
-    tar xf libde265-${LIBDE265_VERSION}.tar.gz
-    cd libde265-${LIBDE265_VERSION}
-    [ -x configure ] || ./autogen.sh
-    emconfigure ./configure --disable-sse --disable-dec265 --disable-sherlock265
-    emmake make -j${CORES}
-    cd ..
-fi
-
-CONFIGURE_ARGS="--disable-multithreading --disable-go"
-
-emconfigure ./configure $CONFIGURE_ARGS \
-    PKG_CONFIG_PATH="${DIR}/libde265-${LIBDE265_VERSION}" \
-    libde265_CFLAGS="-I${DIR}/libde265-${LIBDE265_VERSION}" \
-    libde265_LIBS="-L${DIR}/libde265-${LIBDE265_VERSION}/libde265/.libs"
-if [ ! -e "Makefile" ]; then
-    # Most likely the first run of "emscripten" which will generate the
-    # config file and terminate. Run "emconfigure" again.
-    emconfigure ./configure $CONFIGURE_ARGS \
-        PKG_CONFIG_PATH="${DIR}/libde265-${LIBDE265_VERSION}" \
-        libde265_CFLAGS="-I${DIR}/libde265-${LIBDE265_VERSION}" \
-        libde265_LIBS="-L${DIR}/libde265-${LIBDE265_VERSION}/libde265/.libs"
-fi
-emmake make -j${CORES}
-
-export TOTAL_MEMORY=16777216
+LIBRARY_LINKER_FLAGS=""
+LIBRARY_INCLUDE_FLAGS=""
+
+CONFIGURE_ARGS_LIBDE265=""
+if [ "$ENABLE_LIBDE265" = "1" ]; then
+    [ -s "libde265-${LIBDE265_VERSION}.tar.gz" ] || curl \
+        -L \
+        -o libde265-${LIBDE265_VERSION}.tar.gz \
+        https://github.com/strukturag/libde265/releases/download/v${LIBDE265_VERSION}/libde265-${LIBDE265_VERSION}.tar.gz
+    if [ ! -s "libde265-${LIBDE265_VERSION}/libde265/.libs/libde265.a" ]; then
+        tar xf libde265-${LIBDE265_VERSION}.tar.gz
+        cd libde265-${LIBDE265_VERSION}
+        [ -x configure ] || ./autogen.sh
+        CXXFLAGS=-O3 emconfigure ./configure --enable-static --disable-shared --disable-sse --disable-dec265 --disable-sherlock265
+        emmake make -j${CORES}
+        cd ..
+    fi
+    LIBDE265_DIR="$(pwd)/libde265-${LIBDE265_VERSION}"
+    CONFIGURE_ARGS_LIBDE265="-DLIBDE265_INCLUDE_DIR=${LIBDE265_DIR} -DLIBDE265_LIBRARY=-L${LIBDE265_DIR}/libde265/.libs"
+    LIBRARY_LINKER_FLAGS="$LIBRARY_LINKER_FLAGS -L${LIBDE265_DIR}/libde265/.libs -lde265"
+fi
+
+CONFIGURE_ARGS_AOM=""
+if [ "$ENABLE_AOM" = "1" ]; then
+    [ -s "aom-${AOM_VERSION}.tar.gz" ] || curl \
+        -L \
+        -o aom-${AOM_VERSION}.tar.gz \
+        "https://aomedia.googlesource.com/aom/+archive/v${AOM_VERSION}.tar.gz"
+    if [ ! -s "aom-${AOM_VERSION}/libaom.a" ]; then
+        mkdir -p aom-${AOM_VERSION}/aom-source
+        tar xf aom-${AOM_VERSION}.tar.gz -C aom-${AOM_VERSION}/aom-source
+        cd aom-${AOM_VERSION}
+
+        emcmake cmake aom-source \
+            -DENABLE_CCACHE=1 \
+            -DAOM_TARGET_CPU=generic \
+            -DENABLE_DOCS=0 \
+            -DENABLE_TESTS=0 \
+            -DENABLE_EXAMPLES=0 \
+            -DENABLE_TESTDATA=0 \
+            -DENABLE_TOOLS=0 \
+            -DCONFIG_MULTITHREAD=0 \
+            -DCONFIG_RUNTIME_CPU_DETECT=0 \
+            -DBUILD_SHARED_LIBS=0 \
+            -DCMAKE_BUILD_TYPE=Release
+
+        emmake make -j${CORES}
+
+        cd ..
+    fi
+
+    AOM_DIR="$(pwd)/aom-${AOM_VERSION}"
+    CONFIGURE_ARGS_AOM="-DAOM_INCLUDE_DIR=${AOM_DIR}/aom-source -DAOM_LIBRARY=-L${AOM_DIR}"
+    LIBRARY_LINKER_FLAGS="$LIBRARY_LINKER_FLAGS -L${AOM_DIR} -laom"
+fi
+
+CONFIGURE_ARGS_OPENJPEG=""
+if [ "$ENABLE_OPENJPEG" = "1" ]; then
+    [ -s "openjpeg-${OPENJPEG__VERSION}.tar.gz" ] || curl \
+        -L \
+        -o openjpeg-${OPENJPEG_VERSION}.tar.gz \
+	"https://github.com/uclouvain/openjpeg/archive/refs/tags/v${OPENJPEG_VERSION}.tar.gz"
+    if [ ! -s "openjpeg-${OPENJPEG_VERSION}/bin/libopenjp2.a" ]; then
+        mkdir -p openjpeg-${OPENJPEG_VERSION}/openjpeg-source
+        tar xf openjpeg-${OPENJPEG_VERSION}.tar.gz -C openjpeg-${OPENJPEG_VERSION}/openjpeg-source
+        cd openjpeg-${OPENJPEG_VERSION}
+        emcmake cmake openjpeg-source/openjpeg-${OPENJPEG_VERSION} \
+            -DBUILD_SHARED_LIBS=0 \
+            -DCMAKE_BUILD_TYPE=Release \
+	    -DCMAKE_INSTALL_PREFIX=openjpeg-install
+
+        emmake make -j${CORES}
+        emmake make install -j${CORES}
+
+        cd ..
+    fi
+
+    J2K_DIR="$(pwd)/openjpeg-${OPENJPEG_VERSION}"
+    CONFIGURE_ARGS_OPENJPEG="-DWITH_OpenJPEG_DECODER=ON -DCMAKE_PREFIX_PATH=${J2K_DIR}/openjpeg-install -DCMAKE_FIND_ROOT_PATH_MODE_PACKAGE=BOTH"
+    LIBRARY_LINKER_FLAGS="$LIBRARY_LINKER_FLAGS -L${J2K_DIR}/bin -lopenjp2"
+fi
+
+CONFIGURE_ARGS_WEBCODECS=""
+if [ "$ENABLE_WEBCODECS" = "1" ]; then
+    CONFIGURE_ARGS_WEBCODECS="-DWITH_WEBCODECS=ON"
+fi
+
+CONFIGURE_ARGS_UNCOMPRESSED=""
+if [ "$ENABLE_UNCOMPRESSED" = "1" ]; then
+    CONFIGURE_ARGS_UNCOMPRESSED="-DWITH_UNCOMPRESSED_CODEC=ON"
+fi
+
+EXTRA_EXE_LINKER_FLAGS="-lembind"
+EXTRA_COMPILER_FLAGS=""
+if [ "$STANDALONE" = "1" ]; then
+    EXTRA_EXE_LINKER_FLAGS=""
+    EXTRA_COMPILER_FLAGS="-D__EMSCRIPTEN_STANDALONE_WASM__=1"
+fi
+
+CONFIGURE_ARGS="-DENABLE_MULTITHREADING_SUPPORT=OFF -DWITH_GDK_PIXBUF=OFF -DWITH_EXAMPLES=OFF -DBUILD_SHARED_LIBS=OFF -DENABLE_PLUGIN_LOADING=OFF"
+emcmake cmake ${SRCDIR} $CONFIGURE_ARGS \
+    -DCMAKE_BUILD_TYPE=Release \
+    -DCMAKE_C_FLAGS="${EXTRA_COMPILER_FLAGS}" \
+    -DCMAKE_CXX_FLAGS="${EXTRA_COMPILER_FLAGS}" \
+    -DCMAKE_EXE_LINKER_FLAGS="${LIBRARY_LINKER_FLAGS} ${EXTRA_EXE_LINKER_FLAGS}" \
+    $CONFIGURE_ARGS_LIBDE265 \
+    $CONFIGURE_ARGS_AOM \
+    $CONFIGURE_ARGS_WEBCODECS \
+    $CONFIGURE_ARGS_UNCOMPRESSED \
+    $CONFIGURE_ARGS_OPENJPEG
+
+VERBOSE=1 emmake make -j${CORES}
+
+LIBHEIFA="libheif/libheif.a"
+EXPORTED_FUNCTIONS=$($EMSDK/upstream/bin/llvm-nm $LIBHEIFA --format=just-symbols | grep "^heif_\|^de265_\|^aom_" | grep "[^:]$" | sed 's/^/_/' | paste -sd "," -)
 
 echo "Running Emscripten..."
-emcc libheif/.libs/libheif.so \
-    --bind \
-    -s NO_EXIT_RUNTIME=1 \
-    -s TOTAL_MEMORY=${TOTAL_MEMORY} \
-    -s ALLOW_MEMORY_GROWTH=1 \
-    -s ASSERTIONS=0 \
-    -s INVOKE_RUN=0 \
-    -s DOUBLE_MODE=0 \
-    -s PRECISE_F32=0 \
-    -s PRECISE_I64_MATH=0 \
-    -s DISABLE_EXCEPTION_CATCHING=1 \
-    -s USE_CLOSURE_COMPILER=0 \
-    -s LEGACY_VM_SUPPORT=1 \
-    --memory-init-file 0 \
-    -O3 \
+
+BUILD_FLAGS="-lembind -o libheif.js --post-js ${SRCDIR}/post.js -sWASM=$USE_WASM -sDYNAMIC_EXECUTION=$USE_UNSAFE_EVAL"
+
+if [ "$ENABLE_WEBCODECS" = "1" ]; then
+    BUILD_FLAGS="$BUILD_FLAGS -sASYNCIFY -sASYNCIFY_IMPORTS=['decode_with_browser_hevc']"
+fi
+
+if [ "$USE_TYPESCRIPT" = "1" ]; then
+    BUILD_FLAGS="$BUILD_FLAGS --emit-tsd libheif.d.ts"
+fi
+
+RELEASE_BUILD_FLAGS="-O3"
+
+if [ "$STANDALONE" = "1" ]; then
+    # Note: this intentionally overwrites the BUILD_FLAGS set above
+    echo "Building in standalone (non-web) build mode"
+    BUILD_FLAGS="-sSTANDALONE_WASM -sWASM -o libheif.wasm --no-entry"
+fi
+
+if [ "$DEBUG" = "1" ]; then
+    echo "Building in debug mode"
+    RELEASE_BUILD_FLAGS="--profile -g"
+fi
+
+if [ "$USE_ES6" = "1" ]; then
+    BUILD_FLAGS="$BUILD_FLAGS -sEXPORT_ES6"
+fi
+
+emcc -Wl,--whole-archive "$LIBHEIFA" -Wl,--no-whole-archive \
+    -sEXPORTED_FUNCTIONS="$EXPORTED_FUNCTIONS,_free,_malloc,_memcpy" \
+    -sMODULARIZE \
+    -sEXPORT_NAME="libheif" \
+    -sWASM_ASYNC_COMPILATION=0 \
+    -sALLOW_MEMORY_GROWTH \
     -std=c++11 \
-    -L${DIR}/libde265-${LIBDE265_VERSION}/libde265/.libs \
-    -lde265 \
-    --pre-js pre.js \
-    --post-js post.js \
-    -o libheif.js
+    $LIBRARY_INCLUDE_FLAGS \
+    $LIBRARY_LINKER_FLAGS \
+    $BUILD_FLAGS \
+    $RELEASE_BUILD_FLAGS
diff --git a/cmake/modules/FindAOM.cmake b/cmake/modules/FindAOM.cmake
new file mode 100644
index 0000000000..a357cf7721
--- /dev/null
+++ b/cmake/modules/FindAOM.cmake
@@ -0,0 +1,53 @@
+find_package(AOM QUIET CONFIG)
+
+if(TARGET AOM::aom)
+  if(NOT AOM_FIND_QUIETLY)
+    message(STATUS "Found AOM: ${AOM_DIR}")
+  endif()
+else()
+  include(LibFindMacros)
+
+  libfind_pkg_check_modules(AOM_PKGCONF aom)
+
+  find_path(AOM_INCLUDE_DIR
+      NAMES aom/aom_decoder.h aom/aom_encoder.h
+      HINTS ${AOM_PKGCONF_INCLUDE_DIRS} ${AOM_PKGCONF_INCLUDEDIR}
+      PATH_SUFFIXES AOM
+  )
+
+  find_library(AOM_LIBRARY
+      NAMES libaom aom
+      HINTS ${AOM_PKGCONF_LIBRARY_DIRS} ${AOM_PKGCONF_LIBDIR}
+  )
+
+  set(AOM_PROCESS_LIBS AOM_LIBRARY)
+  set(AOM_PROCESS_INCLUDES AOM_INCLUDE_DIR)
+  libfind_process(AOM)
+
+  include(FindPackageHandleStandardArgs)
+  find_package_handle_standard_args(AOM
+      REQUIRED_VARS
+          AOM_INCLUDE_DIR
+          AOM_LIBRARY
+  )
+endif()
+
+if(AOM_FOUND)
+  include(CheckSymbolExists)
+
+  list(APPEND CMAKE_REQUIRED_INCLUDES ${AOM_INCLUDE_DIRS})
+  check_symbol_exists(AOM_USAGE_GOOD_QUALITY aom/aom_encoder.h aom_usage_flag_exists)
+  unset(CMAKE_REQUIRED_INCLUDES)
+
+  if(EXISTS "${AOM_INCLUDE_DIRS}/aom/aom_decoder.h")
+    set(AOM_DECODER_FOUND YES)
+  else()
+    set(AOM_DECODER_FOUND NO)
+  endif()
+
+  if((EXISTS "${AOM_INCLUDE_DIRS}/aom/aom_encoder.h") AND "${aom_usage_flag_exists}")
+    set(AOM_ENCODER_FOUND YES)
+  else()
+    set(AOM_ENCODER_FOUND NO)
+  endif()
+endif()
diff --git a/cmake/modules/FindBrotli.cmake b/cmake/modules/FindBrotli.cmake
new file mode 100644
index 0000000000..d0ea34c892
--- /dev/null
+++ b/cmake/modules/FindBrotli.cmake
@@ -0,0 +1,26 @@
+include(FindPackageHandleStandardArgs)
+
+find_path(BROTLI_DEC_INCLUDE_DIR "brotli/decode.h")
+find_path(BROTLI_ENC_INCLUDE_DIR "brotli/encode.h")
+
+find_library(BROTLI_COMMON_LIB NAMES brotlicommon)
+find_library(BROTLI_DEC_LIB NAMES brotlidec)
+find_library(BROTLI_ENC_LIB NAMES brotlienc)
+
+find_package_handle_standard_args(Brotli
+  FOUND_VAR
+    Brotli_FOUND
+  REQUIRED_VARS
+    BROTLI_COMMON_LIB
+    BROTLI_DEC_INCLUDE_DIR
+    BROTLI_DEC_LIB
+    BROTLI_ENC_INCLUDE_DIR
+    BROTLI_ENC_LIB
+  FAIL_MESSAGE
+    "Did not find Brotli"
+)
+
+
+set(HAVE_BROTLI ${Brotli_FOUND})
+set(BROTLI_INCLUDE_DIRS ${BROTLI_DEC_INCLUDE_DIR} ${BROTLI_ENC_INCLUDE_DIR})
+set(BROTLI_LIBS "${BROTLICOMMON_LIBRARY}" "${BROTLI_DEC_LIB}"  "${BROTLI_ENC_LIB}")
\ No newline at end of file
diff --git a/cmake/modules/FindDav1d.cmake b/cmake/modules/FindDAV1D.cmake
similarity index 100%
rename from cmake/modules/FindDav1d.cmake
rename to cmake/modules/FindDAV1D.cmake
diff --git a/cmake/modules/FindFFMPEG.cmake b/cmake/modules/FindFFMPEG.cmake
new file mode 100644
index 0000000000..f777aa70be
--- /dev/null
+++ b/cmake/modules/FindFFMPEG.cmake
@@ -0,0 +1,198 @@
+# Taken Oct.2023 from VTK (Visualization Toolkit)
+
+#[==[
+Provides the following variables:
+
+  * `FFMPEG_INCLUDE_DIRS`: Include directories necessary to use FFMPEG.
+  * `FFMPEG_LIBRARIES`: Libraries necessary to use FFMPEG. Note that this only
+    includes libraries for the components requested.
+  * `FFMPEG_VERSION`: The version of FFMPEG found.
+
+The following components are supported:
+
+  * `avcodec`
+  * `avdevice`
+  * `avfilter`
+  * `avformat`
+  * `avresample`
+  * `avutil`
+  * `swresample`
+  * `swscale`
+
+For each component, the following are provided:
+
+  * `FFMPEG_<component>_FOUND`: Libraries for the component.
+  * `FFMPEG_<component>_INCLUDE_DIRS`: Include directories for
+    the component.
+  * `FFMPEG_<component>_LIBRARIES`: Libraries for the component.
+  * `FFMPEG::<component>`: A target to use with `target_link_libraries`.
+
+Note that only components requested with `COMPONENTS` or `OPTIONAL_COMPONENTS`
+are guaranteed to set these variables or provide targets.
+#]==]
+
+function (_ffmpeg_find component headername)
+  find_path("FFMPEG_${component}_INCLUDE_DIR"
+    NAMES
+      "lib${component}/${headername}"
+    PATHS
+      "${FFMPEG_ROOT}/include"
+      ~/Library/Frameworks
+      /Library/Frameworks
+      /usr/local/include
+      /usr/include
+      /sw/include # Fink
+      /opt/local/include # DarwinPorts
+      /opt/csw/include # Blastwave
+      /opt/include
+      /usr/freeware/include
+    PATH_SUFFIXES
+      ffmpeg
+    DOC "FFMPEG's ${component} include directory")
+  mark_as_advanced("FFMPEG_${component}_INCLUDE_DIR")
+
+  # On Windows, static FFMPEG is sometimes built as `lib<name>.a`.
+  if (WIN32)
+    list(APPEND CMAKE_FIND_LIBRARY_SUFFIXES ".a" ".lib")
+    list(APPEND CMAKE_FIND_LIBRARY_PREFIXES "" "lib")
+  endif ()
+
+  find_library("FFMPEG_${component}_LIBRARY"
+    NAMES
+      "${component}"
+    PATHS
+      "${FFMPEG_ROOT}/lib"
+      ~/Library/Frameworks
+      /Library/Frameworks
+      /usr/local/lib
+      /usr/local/lib64
+      /usr/lib
+      /usr/lib64
+      /sw/lib
+      /opt/local/lib
+      /opt/csw/lib
+      /opt/lib
+      /usr/freeware/lib64
+      "${FFMPEG_ROOT}/bin"
+    DOC "FFMPEG's ${component} library")
+  mark_as_advanced("FFMPEG_${component}_LIBRARY")
+
+  if (FFMPEG_${component}_LIBRARY AND FFMPEG_${component}_INCLUDE_DIR)
+    set(_deps_found TRUE)
+    set(_deps_link)
+    foreach (_ffmpeg_dep IN LISTS ARGN)
+      if (TARGET "FFMPEG::${_ffmpeg_dep}")
+        list(APPEND _deps_link "FFMPEG::${_ffmpeg_dep}")
+      else ()
+        set(_deps_found FALSE)
+      endif ()
+    endforeach ()
+    if (_deps_found)
+      if (NOT TARGET "FFMPEG::${component}")
+        add_library("FFMPEG::${component}" UNKNOWN IMPORTED)
+        set_target_properties("FFMPEG::${component}" PROPERTIES
+          IMPORTED_LOCATION "${FFMPEG_${component}_LIBRARY}"
+          INTERFACE_INCLUDE_DIRECTORIES "${FFMPEG_${component}_INCLUDE_DIR}"
+          IMPORTED_LINK_INTERFACE_LIBRARIES "${_deps_link}")
+      endif ()
+      set("FFMPEG_${component}_FOUND" 1
+        PARENT_SCOPE)
+
+      set(version_header_path "${FFMPEG_${component}_INCLUDE_DIR}/lib${component}/version.h")
+      if (EXISTS "${version_header_path}")
+        string(TOUPPER "${component}" component_upper)
+        file(STRINGS "${version_header_path}" version
+          REGEX "#define  *LIB${component_upper}_VERSION_(MAJOR|MINOR|MICRO) ")
+        string(REGEX REPLACE ".*_MAJOR *\([0-9]*\).*" "\\1" major "${version}")
+        string(REGEX REPLACE ".*_MINOR *\([0-9]*\).*" "\\1" minor "${version}")
+        string(REGEX REPLACE ".*_MICRO *\([0-9]*\).*" "\\1" micro "${version}")
+        if (NOT major STREQUAL "" AND
+            NOT minor STREQUAL "" AND
+            NOT micro STREQUAL "")
+          set("FFMPEG_${component}_VERSION" "${major}.${minor}.${micro}"
+            PARENT_SCOPE)
+        endif ()
+      endif ()
+    else ()
+      set("FFMPEG_${component}_FOUND" 0
+        PARENT_SCOPE)
+      set(what)
+      if (NOT FFMPEG_${component}_LIBRARY)
+        set(what "library")
+      endif ()
+      if (NOT FFMPEG_${component}_INCLUDE_DIR)
+        if (what)
+          string(APPEND what " or headers")
+        else ()
+          set(what "headers")
+        endif ()
+      endif ()
+      set("FFMPEG_${component}_NOT_FOUND_MESSAGE"
+        "Could not find the ${what} for ${component}."
+        PARENT_SCOPE)
+    endif ()
+  endif ()
+endfunction ()
+
+_ffmpeg_find(avutil     avutil.h)
+_ffmpeg_find(avresample avresample.h
+  avutil)
+_ffmpeg_find(swresample swresample.h
+  avutil)
+_ffmpeg_find(swscale    swscale.h
+  avutil)
+_ffmpeg_find(avcodec    avcodec.h
+  avutil)
+_ffmpeg_find(avformat   avformat.h
+  avcodec avutil)
+_ffmpeg_find(avfilter   avfilter.h
+  avutil)
+_ffmpeg_find(avdevice   avdevice.h
+  avformat avutil)
+
+if (TARGET FFMPEG::avutil)
+  set(_ffmpeg_version_header_path "${FFMPEG_avutil_INCLUDE_DIR}/libavutil/ffversion.h")
+  if (EXISTS "${_ffmpeg_version_header_path}")
+    file(STRINGS "${_ffmpeg_version_header_path}" _ffmpeg_version
+      REGEX "FFMPEG_VERSION")
+    string(REGEX REPLACE ".*\"n?\(.*\)\"" "\\1" FFMPEG_VERSION "${_ffmpeg_version}")
+    unset(_ffmpeg_version)
+  else ()
+    set(FFMPEG_VERSION FFMPEG_VERSION-NOTFOUND)
+  endif ()
+  unset(_ffmpeg_version_header_path)
+endif ()
+
+set(FFMPEG_INCLUDE_DIRS)
+set(FFMPEG_LIBRARIES)
+set(_ffmpeg_required_vars)
+foreach (_ffmpeg_component IN LISTS FFMPEG_FIND_COMPONENTS)
+  if (TARGET "FFMPEG::${_ffmpeg_component}")
+    set(FFMPEG_${_ffmpeg_component}_INCLUDE_DIRS
+      "${FFMPEG_${_ffmpeg_component}_INCLUDE_DIR}")
+    set(FFMPEG_${_ffmpeg_component}_LIBRARIES
+      "${FFMPEG_${_ffmpeg_component}_LIBRARY}")
+    list(APPEND FFMPEG_INCLUDE_DIRS
+      "${FFMPEG_${_ffmpeg_component}_INCLUDE_DIRS}")
+    list(APPEND FFMPEG_LIBRARIES
+      "${FFMPEG_${_ffmpeg_component}_LIBRARIES}")
+    if (FFMEG_FIND_REQUIRED_${_ffmpeg_component})
+      list(APPEND _ffmpeg_required_vars
+        "FFMPEG_${_ffmpeg_required_vars}_INCLUDE_DIRS"
+        "FFMPEG_${_ffmpeg_required_vars}_LIBRARIES")
+    endif ()
+  endif ()
+endforeach ()
+unset(_ffmpeg_component)
+
+if (FFMPEG_INCLUDE_DIRS)
+  list(REMOVE_DUPLICATES FFMPEG_INCLUDE_DIRS)
+endif ()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(FFMPEG
+  REQUIRED_VARS FFMPEG_INCLUDE_DIRS FFMPEG_LIBRARIES ${_ffmpeg_required_vars}
+  VERSION_VAR FFMPEG_VERSION
+  HANDLE_COMPONENTS)
+unset(_ffmpeg_required_vars)
+
diff --git a/cmake/modules/FindLibde265.cmake b/cmake/modules/FindLIBDE265.cmake
similarity index 100%
rename from cmake/modules/FindLibde265.cmake
rename to cmake/modules/FindLIBDE265.cmake
diff --git a/cmake/modules/FindLibAOM.cmake b/cmake/modules/FindLibAOM.cmake
deleted file mode 100644
index 4e009a201c..0000000000
--- a/cmake/modules/FindLibAOM.cmake
+++ /dev/null
@@ -1,37 +0,0 @@
-include(LibFindMacros)
-
-libfind_pkg_check_modules(AOM_PKGCONF aom)
-
-find_path(AOM_INCLUDE_DIR
-    NAMES aom/aom_decoder.h aom/aom_encoder.h
-    HINTS ${AOM_PKGCONF_INCLUDE_DIRS} ${AOM_PKGCONF_INCLUDEDIR}
-    PATH_SUFFIXES AOM
-)
-
-find_library(AOM_LIBRARY
-    NAMES libaom aom
-    HINTS ${AOM_PKGCONF_LIBRARY_DIRS} ${AOM_PKGCONF_LIBDIR}
-)
-
-if(EXISTS "${AOM_INCLUDE_DIR}/aom/aom_decoder.h")
-    set(AOM_DECODER_FOUND YES)
-else()
-    set(AOM_DECODER_FOUND NO)
-endif()
-
-if(EXISTS "${AOM_INCLUDE_DIR}/aom/aom_encoder.h")
-    set(AOM_ENCODER_FOUND YES)
-else()
-    set(AOM_ENCODER_FOUND NO)
-endif()
-
-set(AOM_PROCESS_LIBS AOM_LIBRARY)
-set(AOM_PROCESS_INCLUDES AOM_INCLUDE_DIR)
-libfind_process(AOM)
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(AOM
-    REQUIRED_VARS
-        AOM_INCLUDE_DIR
-        AOM_LIBRARIES
-)
diff --git a/cmake/modules/FindOPENJPH.cmake b/cmake/modules/FindOPENJPH.cmake
new file mode 100644
index 0000000000..7edb122142
--- /dev/null
+++ b/cmake/modules/FindOPENJPH.cmake
@@ -0,0 +1,33 @@
+find_package(OPENJPH QUIET CONFIG NAMES openjph)
+
+if(TARGET openjph)
+  if(NOT OPENJPH_FIND_QUIETLY)
+    message(STATUS "Found openjph: ${OPENJPH_DIR}")
+  endif()
+  set(OPENJPH_LIBRARIES "openjph")
+else()
+  include(LibFindMacros)
+  libfind_pkg_check_modules(OPENJPH_PKGCONF openjph)
+
+  find_path(OPENJPH_INCLUDE_DIR
+      NAMES openjph/ojph_version.h
+      HINTS ${OPENJPH_PKGCONF_INCLUDE_DIRS} ${OPENJPH_PKGCONF_INCLUDEDIR}
+      PATH_SUFFIXES OPENJPH
+  )
+
+  find_library(OPENJPH_LIBRARY
+      NAMES libopenjph openjph
+      HINTS ${OPENJPH_PKGCONF_LIBRARY_DIRS} ${OPENJPH_PKGCONF_LIBDIR}
+  )
+
+  set(OPENJPH_PROCESS_LIBS OPENJPH_LIBRARY)
+  set(OPENJPH_PROCESS_INCLUDES OPENJPH_INCLUDE_DIR)
+  libfind_process(OPENJPH)
+
+  include(FindPackageHandleStandardArgs)
+  find_package_handle_standard_args(OPENJPH
+      REQUIRED_VARS
+          OPENJPH_INCLUDE_DIR
+          OPENJPH_LIBRARY
+  )
+endif()
diff --git a/cmake/modules/FindOpenH264.cmake b/cmake/modules/FindOpenH264.cmake
new file mode 100644
index 0000000000..a4933249ea
--- /dev/null
+++ b/cmake/modules/FindOpenH264.cmake
@@ -0,0 +1,26 @@
+include(LibFindMacros)
+include(CheckSymbolExists)
+
+libfind_pkg_check_modules(OpenH264_PKGCONF openh264)
+
+find_path(OpenH264_INCLUDE_DIR
+    NAMES wels/codec_api.h
+    HINTS ${OpenH264_PKGCONF_INCLUDE_DIRS} ${OpenH264_PKGCONF_INCLUDEDIR}
+    PATH_SUFFIXES OpenH264
+)
+
+find_library(OpenH264_LIBRARY
+    NAMES libopenh264 openh264
+    HINTS ${OpenH264_PKGCONF_LIBRARY_DIRS} ${OpenH264_PKGCONF_LIBDIR}
+)
+
+set(OpenH264_PROCESS_LIBS OpenH264_LIBRARY)
+set(OpenH264_PROCESS_INCLUDES OpenH264_INCLUDE_DIR)
+libfind_process(OpenH264)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(OpenH264
+    REQUIRED_VARS
+        OpenH264_INCLUDE_DIR
+        OpenH264_LIBRARIES
+)
diff --git a/cmake/modules/FindRav1e.cmake b/cmake/modules/FindRAV1E.cmake
similarity index 95%
rename from cmake/modules/FindRav1e.cmake
rename to cmake/modules/FindRAV1E.cmake
index 5f2435247e..3012c4ad59 100644
--- a/cmake/modules/FindRav1e.cmake
+++ b/cmake/modules/FindRAV1E.cmake
@@ -4,7 +4,7 @@ libfind_pkg_check_modules(RAV1E_PKGCONF rav1e)
 find_path(RAV1E_INCLUDE_DIR
     NAMES rav1e.h
     HINTS ${RAV1E_PKGCONF_INCLUDE_DIRS} ${RAV1E_PKGCONF_INCLUDEDIR}
-    PATH_SUFFIXES RAV1E
+    PATH_SUFFIXES RAV1E rav1e
 )
 
 find_library(RAV1E_LIBRARY
diff --git a/cmake/modules/FindSvtEnc.cmake b/cmake/modules/FindSvtEnc.cmake
new file mode 100644
index 0000000000..b0d230ab1a
--- /dev/null
+++ b/cmake/modules/FindSvtEnc.cmake
@@ -0,0 +1,24 @@
+include(LibFindMacros)
+libfind_pkg_check_modules(SvtEnc_PKGCONF SvtAv1Enc)
+
+find_path(SvtEnc_INCLUDE_DIR
+    NAMES svt-av1/EbSvtAv1Enc.h
+    HINTS ${SvtEnc_PKGCONF_INCLUDE_DIRS} ${SvtEnc_PKGCONF_INCLUDEDIR}
+    PATH_SUFFIXES SvtEnc
+)
+
+find_library(SvtEnc_LIBRARY
+    NAMES SvtAv1Enc libSvtAv1Enc
+    HINTS ${SvtEnc_PKGCONF_LIBRARY_DIRS} ${SvtEnc_PKGCONF_LIBDIR}
+)
+
+set(SvtEnc_PROCESS_LIBS SvtEnc_LIBRARY)
+set(SvtEnc_PROCESS_INCLUDES SvtEnc_INCLUDE_DIR)
+libfind_process(SvtEnc)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(SvtEnc
+    REQUIRED_VARS
+        SvtEnc_INCLUDE_DIR
+        SvtEnc_LIBRARIES
+)
diff --git a/cmake/modules/FindUVG266.cmake b/cmake/modules/FindUVG266.cmake
new file mode 100644
index 0000000000..ba2a7ec056
--- /dev/null
+++ b/cmake/modules/FindUVG266.cmake
@@ -0,0 +1,24 @@
+include(LibFindMacros)
+libfind_pkg_check_modules(UVG266_PKGCONF uvg266)
+
+find_path(UVG266_INCLUDE_DIR
+    NAMES uvg266.h
+    HINTS ${UVG266_PKGCONF_INCLUDE_DIRS} ${UVG266_PKGCONF_INCLUDEDIR}
+    PATH_SUFFIXES UVG266 uvg266
+)
+
+find_library(UVG266_LIBRARY
+    NAMES libuvg266 uvg266 uvg266.dll
+    HINTS ${UVG266_PKGCONF_LIBRARY_DIRS} ${UVG266_PKGCONF_LIBDIR}
+)
+
+set(UVG266_PROCESS_LIBS UVG266_LIBRARY)
+set(UVG266_PROCESS_INCLUDES UVG266_INCLUDE_DIR)
+libfind_process(UVG266)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(UVG266
+    REQUIRED_VARS
+        UVG266_INCLUDE_DIR
+        UVG266_LIBRARIES
+)
diff --git a/cmake/modules/FindX264.cmake b/cmake/modules/FindX264.cmake
new file mode 100644
index 0000000000..0d40c2bda3
--- /dev/null
+++ b/cmake/modules/FindX264.cmake
@@ -0,0 +1,38 @@
+include(LibFindMacros)
+libfind_pkg_check_modules(X264_PKGCONF x264)
+
+find_path(X264_INCLUDE_DIR
+    NAMES x264.h
+    HINTS ${X264_PKGCONF_INCLUDE_DIRS} ${X264_PKGCONF_INCLUDEDIR}
+    PATH_SUFFIXES X264
+)
+
+find_library(X264_LIBRARY
+    NAMES libx264 x264
+    HINTS ${X264_PKGCONF_LIBRARY_DIRS} ${X264_PKGCONF_LIBDIR}
+)
+
+set(X264_PROCESS_LIBS X264_LIBRARY)
+set(X264_PROCESS_INCLUDES X264_INCLUDE_DIR)
+libfind_process(X264)
+
+if(X264_INCLUDE_DIR)
+  set(x264_config_file "${X264_INCLUDE_DIR}/x264_config.h")
+  if(EXISTS ${x264_config_file})
+      file(STRINGS
+           ${x264_config_file}
+           TMP
+           REGEX "#define X264_BUILD .*$")
+      string(REGEX REPLACE "#define X264_BUILD" "" TMP "${TMP}")
+      string(REGEX MATCHALL "[0-9.]+" X264_BUILD "${TMP}")
+  endif()
+endif()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(X264
+    REQUIRED_VARS
+        X264_INCLUDE_DIR
+        X264_LIBRARIES
+    VERSION_VAR
+        X264_BUILD
+)
diff --git a/cmake/modules/Findkvazaar.cmake b/cmake/modules/Findkvazaar.cmake
new file mode 100644
index 0000000000..90f0c1d723
--- /dev/null
+++ b/cmake/modules/Findkvazaar.cmake
@@ -0,0 +1,36 @@
+include(LibFindMacros)
+include(CheckStructHasMember)
+include(CheckSymbolExists)
+
+libfind_pkg_check_modules(KVAZAAR_PKGCONF kvazaar)
+
+find_path(KVAZAAR_INCLUDE_DIR
+    NAMES kvazaar.h
+    HINTS ${KVAZAAR_PKGCONF_INCLUDE_DIRS} ${KVAZAAR_PKGCONF_INCLUDEDIR}
+    PATH_SUFFIXES KVAZAAR kvazaar
+)
+
+find_library(KVAZAAR_LIBRARY
+    NAMES libkvazaar kvazaar kvazaar.dll
+    HINTS ${KVAZAAR_PKGCONF_LIBRARY_DIRS} ${KVAZAAR_PKGCONF_LIBDIR}
+)
+
+set(KVAZAAR_PROCESS_LIBS KVAZAAR_LIBRARY)
+set(KVAZAAR_PROCESS_INCLUDES KVAZAAR_INCLUDE_DIR)
+libfind_process(KVAZAAR)
+
+set(CMAKE_REQUIRED_INCLUDES ${KVAZAAR_INCLUDE_DIR})
+set(CMAKE_REQUIRED_LIBRARIES ${KVAZAAR_LIBRARY})
+CHECK_STRUCT_HAS_MEMBER("struct kvz_config" enable_logging_output kvazaar.h
+                        HAVE_KVAZAAR_ENABLE_LOGGING LANGUAGE CXX)
+check_symbol_exists(kvz_get_version_string kvazaar.h
+                        HAVE_KVAZAAR_VERSION_STRING)
+unset(CMAKE_REQUIRED_INCLUDES)
+unset(CMAKE_REQUIRED_LIBRARIES)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(kvazaar
+    REQUIRED_VARS
+        KVAZAAR_INCLUDE_DIR
+        KVAZAAR_LIBRARIES
+)
diff --git a/cmake/modules/Findlibsharpyuv.cmake b/cmake/modules/Findlibsharpyuv.cmake
new file mode 100644
index 0000000000..c6f2336e91
--- /dev/null
+++ b/cmake/modules/Findlibsharpyuv.cmake
@@ -0,0 +1,25 @@
+include(LibFindMacros)
+
+libfind_pkg_check_modules(LIBSHARPYUV_PKGCONF libsharpyuv)
+
+find_path(LIBSHARPYUV_INCLUDE_DIR
+    NAMES sharpyuv/sharpyuv.h
+    HINTS ${LIBSHARPYUV_PKGCONF_INCLUDE_DIRS} ${LIBSHARPYUV_PKGCONF_INCLUDEDIR}
+    PATH_SUFFIXES LIBSHARPYUV
+)
+
+find_library(LIBSHARPYUV_LIBRARY
+    NAMES sharpyuv
+    HINTS ${LIBSHARPYUV_PKGCONF_LIBRARY_DIRS} ${LIBSHARPYUV_PKGCONF_LIBDIR}
+)
+
+set(LIBSHARPYUV_PROCESS_LIBS LIBSHARPYUV_LIBRARY)
+set(LIBSHARPYUV_PROCESS_INCLUDES LIBSHARPYUV_INCLUDE_DIR)
+libfind_process(LIBSHARPYUV)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(libsharpyuv
+    REQUIRED_VARS
+        LIBSHARPYUV_INCLUDE_DIR
+        LIBSHARPYUV_LIBRARIES
+)
diff --git a/cmake/modules/LibFindMacros.cmake b/cmake/modules/LibFindMacros.cmake
index e293efff89..3d1f2459f8 100644
--- a/cmake/modules/LibFindMacros.cmake
+++ b/cmake/modules/LibFindMacros.cmake
@@ -1,7 +1,7 @@
 # Version 2.3
 # Public Domain, originally written by Lasse Kärkkäinen <tronic>
 # Maintained at https://github.com/Tronic/cmake-modules
-# Please send your improvements as pull requests on Github.
+# Please send your improvements as pull requests on GitHub.
 
 # Find another package and make it a dependency of the current package.
 # This also automatically forwards the "REQUIRED" argument.
diff --git a/configure.ac b/configure.ac
deleted file mode 100644
index 8f0c1e96b3..0000000000
--- a/configure.ac
+++ /dev/null
@@ -1,335 +0,0 @@
-AC_PREREQ([2.68])
-AC_INIT([libheif], [1.12.0], [opensource@struktur.de])
-AC_CONFIG_SRCDIR([libheif/box.cc])
-AC_CONFIG_HEADERS([config.h])
-
-# Note: do not forget to set the version in the CMakeLists.txt file accordingly
-PROJECT_VERSION_MAJOR=1
-PROJECT_VERSION_MINOR=12
-PROJECT_VERSION_PATCH=0
-PROJECT_VERSION_TWEAK=0
-AC_SUBST(PROJECT_VERSION_MAJOR)
-AC_SUBST(PROJECT_VERSION_MINOR)
-AC_SUBST(PROJECT_VERSION_PATCH)
-AC_SUBST(PROJECT_VERSION_TWEAK)
-
-# From https://www.gnu.org/software/libtool/manual/html_node/Updating-version-info.html:
-# If the library source code has changed at all since the last update, then increment revision (‘c:r:a’ becomes ‘c:r+1:a’).
-# If any interfaces have been added, removed, or changed since the last update, increment current, and set revision to 0.
-# If any interfaces have been added since the last public release, then increment age.
-# If any interfaces have been removed or changed since the last public release, then set age to 0.
-
-LIBHEIF_CURRENT=13
-LIBHEIF_REVISION=0
-LIBHEIF_AGE=12
-AC_SUBST(LIBHEIF_CURRENT)
-AC_SUBST(LIBHEIF_REVISION)
-AC_SUBST(LIBHEIF_AGE)
-
-AC_CANONICAL_SYSTEM
-LT_INIT
-AC_CONFIG_MACRO_DIR([m4])
-AC_CONFIG_AUX_DIR([.])
-
-# Checks for programs.
-AM_PROG_AS
-AC_PROG_CXX
-AC_PROG_CC
-AC_PROG_INSTALL
-AC_PROG_LN_S
-AC_PROG_GREP
-AC_ARG_ENABLE([go], AS_HELP_STRING([--disable-go],
-    [Disable building Go code / examples.]))
-if eval "test x$enable_go = x" ; then
-    AC_PATH_PROG([GO], [go], [no], [$PATH$PATH_SEPARATOR/usr/lib/go-1.10$PATH_SEPARATOR/usr/lib/go-1.9$PATH_SEPARATOR/usr/lib/go-1.8$PATH_SEPARATOR/usr/lib/go-1.7$PATH_SEPARATOR/usr/lib/go-1.6])
-    AC_SUBST(GO)
-fi
-AM_CONDITIONAL([HAVE_GO], [test "x$GO" != "xno" && test "x$GO" != "x"])
-AC_SUBST(HAVE_GO)
-
-AC_ARG_ENABLE([examples], AS_HELP_STRING([--disable-examples],
-    [Disable building examples.]), [], [enable_examples=yes])
-AM_CONDITIONAL([WITH_EXAMPLES], [test "x$enable_examples" = "xyes"])
-AC_SUBST(WITH_EXAMPLES)
-
-AM_CONDITIONAL(MINGW, expr $host : '.*-mingw' >/dev/null 2>&1)
-
-AM_INIT_AUTOMAKE([1.13 foreign])
-AM_EXTRA_RECURSIVE_TARGETS([format test])
-
-AX_CXX_COMPILE_STDCXX_11()
-
-AC_HEADER_STDBOOL
-AC_CHECK_HEADERS([inttypes.h stddef.h unistd.h])
-AC_C_INLINE
-AC_FUNC_ERROR_AT_LINE
-
-AC_TYPE_SIZE_T
-AC_TYPE_UINT8_T
-AC_TYPE_UINT16_T
-AC_TYPE_UINT32_T
-AC_TYPE_UINT64_T
-
-AC_CHECK_LIB([pthread], [pthread_create])
-
-AC_ARG_ENABLE([visibility], AS_HELP_STRING([--disable-visibility],
-    [Disable visibility definitions.]),
-    [HAVE_VISIBILITY=0],
-    [gl_VISIBILITY])
-
-AC_ARG_ENABLE([tests], AS_HELP_STRING([--enable-tests],
-    [Enable compiling tests ('visibility' will be disabled).]))
-AS_IF([test "x$enable_tests" = "xyes"], [
-    HAVE_TESTS=1
-    enable_visibility=no
-    HAVE_VISIBILITY=0
-    CFLAG_VISIBILITY=
-])
-AM_CONDITIONAL([HAVE_TESTS], [test "x$HAVE_TESTS" == "x1"])
-
-AM_CONDITIONAL([HAVE_VISIBILITY], [test "x$HAVE_VISIBILITY" != "x0"])
-if eval "test x$enable_visibility = x" ; then enable_visibility=yes ; fi
-
-REQUIRES_PRIVATE=""
-AC_SUBST([REQUIRES_PRIVATE])
-
-PKG_PROG_PKG_CONFIG
-
-have_avif_decoder="no"
-have_avif_encoder="no"
-
-AC_ARG_ENABLE([aom], AS_HELP_STRING([--disable-aom],
-    [Disable building of aom decoder/encoder.]))
-if eval "test x$enable_aom = x" ; then enable_aom=yes ; fi
-if eval "test x$enable_aom != xno"; then
-    PKG_CHECK_MODULES([aom], [aom], [
-        AC_DEFINE([HAVE_AOM], [1], [Whether aom was found.])
-        AC_SUBST(aom_CFLAGS)
-        AC_SUBST(aom_LIBS)
-        REQUIRES_PRIVATE="$REQUIRES_PRIVATE aom"
-        have_aom="yes"
-    ], [have_aom="no"])
-
-    if eval "test x$have_aom = xyes"; then
-        AC_CHECK_HEADER([aom/aom_decoder.h], [
-            AC_DEFINE([HAVE_AOM_DECODER], [1], [Whether aom decoder was found.])
-            have_aom_decoder="yes"
-            have_avif_decoder="yes"
-        ], [have_aom_decoder="no"])
-
-        AC_CHECK_HEADER([aom/aom_encoder.h], [
-            AC_DEFINE([HAVE_AOM_ENCODER], [1], [Whether aom encoder was found.])
-            have_aom_encoder="yes"
-            have_avif_encoder="yes"
-        ], [have_aom_encoder="no"])
-    fi
-else
-    have_aom="no"
-    have_aom_decoder="no"
-    have_aom_encoder="no"
-fi
-AM_CONDITIONAL([HAVE_AOM], [test "x$have_aom" = "xyes"])
-AC_SUBST([have_aom])
-AM_CONDITIONAL([HAVE_AOM_DECODER], [test "x$have_aom_decoder" = "xyes"])
-AC_SUBST([have_aom_decoder])
-AM_CONDITIONAL([HAVE_AOM_ENCODER], [test "x$have_aom_encoder" = "xyes"])
-AC_SUBST([have_aom_encoder])
-
-AC_ARG_ENABLE([libde265], AS_HELP_STRING([--disable-libde265],
-    [Disable building of libde265 decoder.]))
-if eval "test x$enable_libde265 = x" ; then enable_libde265=yes ; fi
-if eval "test x$enable_libde265 != xno"; then
-    PKG_CHECK_MODULES([libde265], [libde265], [
-        AC_DEFINE([HAVE_LIBDE265], [1], [Whether libde265 was found.])
-        AC_SUBST(libde265_CFLAGS)
-        AC_SUBST(libde265_LIBS)
-        REQUIRES_PRIVATE="$REQUIRES_PRIVATE libde265"
-        have_libde265="yes"
-    ], [have_libde265="no"])
-else
-    have_libde265="no"
-fi
-AM_CONDITIONAL([HAVE_LIBDE265], [test "x$have_libde265" = "xyes"])
-AC_SUBST([have_libde265])
-
-AC_ARG_ENABLE([x265], AS_HELP_STRING([--disable-x265],
-    [Disable building of x265 encoder.]))
-if eval "test x$enable_x265 = x" ; then enable_x265=yes ; fi
-if eval "test x$enable_x265 != xno"; then
-    PKG_CHECK_MODULES([x265], [x265], [
-        AC_DEFINE([HAVE_X265], [1], [Whether x265 was found.])
-        AC_SUBST(x265_CFLAGS)
-        AC_SUBST(x265_LIBS)
-        REQUIRES_PRIVATE="$REQUIRES_PRIVATE x265"
-        have_x265="yes"
-    ], [have_x265="no"])
-else
-    have_x265="no"
-fi
-AM_CONDITIONAL([HAVE_X265], [test "x$have_x265" = "xyes"])
-AC_SUBST([have_x265])
-
-AC_CHECK_HEADERS([jpeglib.h])
-AC_CHECK_LIB([jpeg], [jpeg_CreateCompress], [
-    AC_DEFINE([HAVE_LIBJPEG], [1], [Whether libjpeg was found.])
-    libjpeg_CFLAGS=""
-    AC_SUBST(libjpeg_CFLAGS)
-    libjpeg_LIBS="-ljpeg"
-    AC_SUBST(libjpeg_LIBS)
-    have_libjpeg="yes"
-], [have_libjpeg="no"])
-if eval "test x$have_libjpeg = xno"; then
-AC_CHECK_LIB([jpeg], [jpeg_destroy_compress], [
-    AC_DEFINE([HAVE_LIBJPEG], [1], [Whether libjpeg was found.])
-    libjpeg_CFLAGS=""
-    AC_SUBST(libjpeg_CFLAGS)
-    libjpeg_LIBS="-ljpeg"
-    AC_SUBST(libjpeg_LIBS)
-    have_libjpeg="yes"
-], [have_libjpeg="no"])
-fi
-AM_CONDITIONAL([HAVE_LIBJPEG], [test "x$have_libjpeg" = "xyes"])
-if eval "test x$have_libjpeg = xyes"; then
-AC_MSG_CHECKING([for jpeg_write_icc_profile])
-AC_LANG_PUSH(C++)
-AC_TRY_COMPILE([
-    #include <stddef.h>
-    #include <stdio.h>
-    #include <jpeglib.h>
-],[
-    jpeg_write_icc_profile(NULL, NULL, 0);
-],[has_jpeg_write_icc_profile=yes],[has_jpeg_write_icc_profile=no]);
-AC_LANG_POP(C++)
-AC_MSG_RESULT([$has_jpeg_write_icc_profile])
-if eval "test x$has_jpeg_write_icc_profile = xyes"; then
-    AC_DEFINE(HAVE_JPEG_WRITE_ICC_PROFILE, 1, [Define to 1 if jpeg_write_icc_profile is available in libjpeg.])
-fi
-fi
-
-PKG_CHECK_MODULES([libpng], [libpng], [
-    AC_DEFINE([HAVE_LIBPNG], [1], [Whether libpng was found.])
-    AC_SUBST(libpng_CFLAGS)
-    AC_SUBST(libpng_LIBS)
-    have_libpng="yes"
-], [have_libpng="no"])
-AM_CONDITIONAL([HAVE_LIBPNG], [test "x$have_libpng" = "xyes"])
-
-AC_ARG_ENABLE([gdk-pixbuf], AS_HELP_STRING([--disable-gdk-pixbuf],
-    [Disable building of gdk-pixbuf plugin.]))
-if eval "test x$enable_gdk_pixbuf = x" ; then enable_gdk_pixbuf=yes ; fi
-if eval "test x$enable_gdk_pixbuf != xno"; then
-    PKG_CHECK_MODULES([gdkpixbuf], [gdk-pixbuf-2.0], [
-        AC_DEFINE([HAVE_GDKPIXBUF2], [1], [Whether gdk-pixbuf-2.0 was found.])
-        AC_SUBST(gdkpixbuf_CFLAGS)
-        AC_SUBST(gdkpixbuf_LIBS)
-        have_gdkpixbuf2="yes"
-    ], [have_gdkpixbuf2="no"])
-else
-    have_gdkpixbuf2="no"
-fi
-AM_CONDITIONAL([HAVE_GDKPIXBUF2], [test "x$have_gdkpixbuf2" = "xyes"])
-
-if eval "test x$have_gdkpixbuf2 = xyes"; then
-    gdk_pixbuf_binary_version="`$PKG_CONFIG --variable=gdk_pixbuf_binary_version gdk-pixbuf-2.0`"
-    gdk_pixbuf_binarydir="`$PKG_CONFIG --variable=gdk_pixbuf_binarydir gdk-pixbuf-2.0`"
-    gdk_pixbuf_moduledir=`$PKG_CONFIG --variable gdk_pixbuf_moduledir gdk-pixbuf-2.0`
-    gdk_pixbuf_cache_file=`$PKG_CONFIG --variable gdk_pixbuf_cache_file gdk-pixbuf-2.0`
-
-    AC_SUBST([gdk_pixbuf_binary_version])
-    AC_SUBST([gdk_pixbuf_binarydir])
-    AC_SUBST([gdk_pixbuf_moduledir])
-    AC_SUBST([gdk_pixbuf_cache_file])
-fi
-
-AC_ARG_ENABLE([rav1e], AS_HELP_STRING([--disable-rav1e],
-    [Disable building of rav1e encoder.]))
-if eval "test x$enable_rav1e = x" ; then enable_rav1e=yes ; fi
-if eval "test x$enable_rav1e != xno"; then
-    PKG_CHECK_MODULES([rav1e], [rav1e], [
-        AC_DEFINE([HAVE_RAV1E], [1], [Whether rav1e was found.])
-        AC_SUBST(rav1e_CFLAGS)
-        AC_SUBST(rav1e_LIBS)
-        have_avif_encoder="yes"
-        REQUIRES_PRIVATE="$REQUIRES_PRIVATE rav1e"
-        have_rav1e="yes"
-    ], [have_rav1e="no"])
-else
-    have_rav1e="no"
-fi
-AM_CONDITIONAL([HAVE_RAV1E], [test "x$have_rav1e" = "xyes"])
-AC_SUBST([have_rav1e])
-
-PKG_CHECK_MODULES([dav1d], [dav1d], [
-    AC_DEFINE([HAVE_DAV1D], [1], [Whether dav1d was found.])
-    AC_SUBST(dav1d_CFLAGS)
-    AC_SUBST(dav1d_LIBS)
-    have_avif_decoder="yes"
-    REQUIRES_PRIVATE="$REQUIRES_PRIVATE dav1d"
-    have_dav1d="yes"
-], [have_dav1d="no"])
-AM_CONDITIONAL([HAVE_DAV1D], [test "x$have_dav1d" = "xyes"])
-
-AC_SUBST(have_avif_decoder)
-AC_SUBST(have_avif_encoder)
-
-AC_ARG_ENABLE([libfuzzer], AS_HELP_STRING([--enable-libfuzzer],
-    [Enable fuzzing with libFuzzer.]), [], [enable_libfuzzer=no])
-if eval "test x$enable_libfuzzer != xno"; then
-    AC_MSG_NOTICE([Enable libFuzzer])
-    AC_DEFINE([HAVE_LIBFUZZER], [1], [Whether building with libFuzzer.])
-
-    FUZZING_ENGINE="-lFuzzingEngine"
-    if eval "test x$enable_libfuzzer != xyes"; then
-        FUZZING_ENGINE="$enable_libfuzzer"
-    fi
-    AC_MSG_NOTICE([Fuzzing engine flags: $FUZZING_ENGINE])
-    AC_SUBST([FUZZING_ENGINE])
-fi
-AM_CONDITIONAL([ENABLE_LIBFUZZER], [test "x$enable_libfuzzer" != "xno"])
-AC_SUBST(ENABLE_LIBFUZZER)
-
-AC_ARG_ENABLE([multithreading], AS_HELP_STRING([--disable-multithreading],
-    [Disable multithreaded decoding.]))
-if eval "test x$enable_multithreading = x" ; then enable_multithreading=yes ; fi
-if eval "test x$enable_multithreading != xno"; then
-    AC_MSG_NOTICE([Enable multithreading])
-    AC_DEFINE([ENABLE_PARALLEL_TILE_DECODING], [1], [Whether we enable multithreaded decoding.])
-fi
-AC_SUBST(ENABLE_PARALLEL_TILE_DECODING)
-
-WARNING_FLAGS="-Wall -Werror -Wsign-compare -Wconversion -Wno-sign-conversion -Wno-error=conversion -Wno-error=unused-parameter -Wno-error=deprecated-declarations"
-
-CXXFLAGS="$CXXFLAGS $WARNING_FLAGS"
-CFLAGS="$CFLAGS $WARNING_FLAGS"
-
-AC_C_CXX_COMPILE_FLAGS([-Wno-error=potentially-evaluated-expression])
-
-AC_MSG_NOTICE([---------------------------------------])
-AC_MSG_NOTICE([Multithreading: $enable_multithreading])
-AC_MSG_NOTICE([Symbol visibility: $enable_visibility])
-AC_MSG_NOTICE([libaom decoder: $have_aom_decoder])
-AC_MSG_NOTICE([libaom encoder: $have_aom_encoder])
-AC_MSG_NOTICE([rav1e encoder: $have_rav1e])
-AC_MSG_NOTICE([dav1d decoder: $have_dav1d])
-AC_MSG_NOTICE([libde265 decoder: $have_libde265])
-AC_MSG_NOTICE([libx265 encoder: $have_x265])
-AC_MSG_NOTICE([JPEG output: $have_libjpeg])
-AC_MSG_NOTICE([PNG output: $have_libpng])
-AC_MSG_NOTICE([GdkPixbuf2 loader: $have_gdkpixbuf2])
-AC_MSG_NOTICE([Examples: $enable_examples])
-AC_MSG_NOTICE([Tests: $enable_tests (tests will cause 'visibility' to be turned off)])
-AC_MSG_NOTICE([---------------------------------------])
-
-AC_CONFIG_FILES([Makefile])
-AC_CONFIG_FILES([examples/Makefile])
-AC_CONFIG_FILES([extra/Makefile])
-AC_CONFIG_FILES([fuzzing/Makefile])
-AC_CONFIG_FILES([gdk-pixbuf/Makefile])
-AC_CONFIG_FILES([go/Makefile])
-AC_CONFIG_FILES([gnome/Makefile])
-AC_CONFIG_FILES([scripts/Makefile])
-AC_CONFIG_FILES([tests/Makefile])
-AC_CONFIG_FILES([libheif/Makefile])
-AC_CONFIG_FILES([libheif/heif_version.h])
-AC_CONFIG_FILES([libheif.pc])
-AC_OUTPUT
diff --git a/diagram.svg b/diagram.svg
deleted file mode 100644
index 45d365de42..0000000000
--- a/diagram.svg
+++ /dev/null
@@ -1 +0,0 @@
-<svg width="1000" height="1000" style="background:white;font-family:sans-serif;overflow:visible" xmlns="http://www.w3.org/2000/svg"><defs><filter id="glow" x="-50%" y="-50%" width="200%" height="200%"><feGaussianBlur stdDeviation="4" result="coloredBlur"></feGaussianBlur><feMerge><feMergeNode in="coloredBlur"></feMergeNode><feMergeNode in="SourceGraphic"></feMergeNode></feMerge></filter></defs><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(307.39886539102775, 461.42084744282545)"><circle r="27.486284536779824" style="transition:all 0.5s ease-out" stroke="#290819" opacity="0.2" stroke-width="1" fill="none"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(365.08629432189406, 594.8760642183305)"><circle r="67.16395239911964" style="transition:all 0.5s ease-out" stroke="#290819" opacity="0.2" stroke-width="1" fill="none"></circle></g><g style="fill:#badc58;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(302.2028777031694, 896.3002410566528)"><circle r="103.69975894334726" style="transition:all 0.5s ease-out" stroke="#290819" opacity="0.2" stroke-width="1" fill="none"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(299.0490531768326, 368.9420579154785)"><circle r="45.385569189916325" style="transition:all 0.5s ease-out" stroke="#290819" opacity="0.2" stroke-width="1" fill="none"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(658.8199629330827, 697.2776788460035)"><circle r="223.86365744891555" style="transition:all 0.5s ease-out" stroke="#290819" opacity="0.2" stroke-width="1" fill="none"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(447.3791608202811, 431.6380841907212)"><circle r="95.65215373583086" style="transition:all 0.5s ease-out" stroke="#290819" opacity="0.2" stroke-width="1" fill="none"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(410.798597767195, 797.093722942152)"><circle r="23.49394687473817" style="transition:all 0.5s ease-out" stroke="#290819" opacity="0.2" stroke-width="1" fill="none"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(368.03940306201076, 723.5617158258433)"><circle r="41.56944423995263" style="transition:all 0.5s ease-out" stroke="#290819" opacity="0.2" stroke-width="1" fill="none"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(682.468527789423, 300.600354602205)"><circle r="153.49066761050034" style="transition:all 0.5s ease-out" stroke="#290819" opacity="0.2" stroke-width="1" fill="none"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(226.79000944709546, 526.113716110053)"><circle r="55.89623643317314" style="transition:all 0.5s ease-out" stroke="#290819" opacity="0.2" stroke-width="1" fill="none"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(387.51983369006774, 176.5118129198911)"><circle r="146.5118129198911" style="transition:all 0.5s ease-out" stroke="#290819" opacity="0.2" stroke-width="1" fill="none"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(187.4808072541689, 404.66122787644656)"><circle r="51.764100845557444" style="transition:all 0.5s ease-out" stroke="#290819" opacity="0.2" stroke-width="1" fill="none"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(295.3946903343058, 461.42084744282545)"><circle style="transition:all 0.5s ease-out" r="10.949470528653004" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(320.6146553953832, 461.42084744282545)"><circle style="transition:all 0.5s ease-out" r="9.737855581019545" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(343.1953624106547, 600.4985017278589)"><circle style="transition:all 0.5s ease-out" r="31.59553058337493" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(404.54942880101, 598.9109452387233)"><circle style="transition:all 0.5s ease-out" r="24.495082390440082" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(380.78054692972313, 638.4065147220423)"><circle style="transition:all 0.5s ease-out" r="17.890745400096428" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#E67E23;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(379.485170047747, 561.0184849527279)"><circle style="transition:all 0.5s ease-out" r="17.371788887101008" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(348.4110990467695, 555.718324416348)"><circle style="transition:all 0.5s ease-out" r="11.603516265742117" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(349.3017464053699, 645.2736844125141)"><circle style="transition:all 0.5s ease-out" r="11.352286318922724" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#5758BB;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(259.7877836325603, 901.5821689524196)"><circle style="transition:all 0.5s ease-out" r="40.79554534705368" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#badc58;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(357.0262036099313, 899.5074253547301)"><circle style="transition:all 0.5s ease-out" r="33.22607876136702" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#badc58;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(314.4510982680234, 944.2341379184234)"><circle style="transition:all 0.5s ease-out" r="24.524495052499724" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(319.16036845643686, 828.5875429836603)"><circle style="transition:all 0.5s ease-out" r="20.895991330335246" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#badc58;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(277.3089491940085, 827.313597635176)"><circle style="transition:all 0.5s ease-out" r="17.359015511192176" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#badc58;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(291.18592617289283, 980.4923833003345)"><circle style="transition:all 0.5s ease-out" r="15.789865311328185" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#badc58;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(354.9653088805562, 846.8010341977331)"><circle style="transition:all 0.5s ease-out" r="15.520659901117936" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#badc58;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(357.5906858216178, 952.123863404961)"><circle style="transition:all 0.5s ease-out" r="15.326509188120125" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CE83F1;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(246.33316128158512, 844.7759046708888)"><circle style="transition:all 0.5s ease-out" r="14.698558603999944" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#badc58;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(239.55186648022513, 955.9418545734966)"><circle style="transition:all 0.5s ease-out" r="14.199635994590361" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#badc58;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(294.802878500849, 856.0005350949485)"><circle style="transition:all 0.5s ease-out" r="12.694426317720094" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#badc58;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(382.28881055021475, 859.466539204626)"><circle style="transition:all 0.5s ease-out" r="12.549442823066348" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#badc58;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(269.3571423354117, 957.9985998980039)"><circle style="transition:all 0.5s ease-out" r="12.429562149693435" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#badc58;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(322.1678786444281, 864.7192642366011)"><circle style="transition:all 0.5s ease-out" r="12.025940968745076" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(314.36357311362593, 906.6322804864762)"><circle style="transition:all 0.5s ease-out" r="5.910654159261699" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(281.38403141832373, 368.9420579154785)"><circle style="transition:all 0.5s ease-out" r="23.187908480002605" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(324.50328113253767, 368.9420579154785)"><circle style="transition:all 0.5s ease-out" r="15.398702282806438" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(308.4583361146468, 390.1999356724099)"><circle style="transition:all 0.5s ease-out" r="6.702051853335436" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(637.0443931827837, 697.5985304847917)"><circle style="transition:all 0.5s ease-out" r="31.670910489944593" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(704.3798606109617, 697.8177317688694)"><circle style="transition:all 0.5s ease-out" r="31.66390597576185" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(661.9812672904644, 760.1124269810293)"><circle style="transition:all 0.5s ease-out" r="31.65689991173633" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(670.934306929805, 639.4841642840804)"><circle style="transition:all 0.5s ease-out" r="31.653396298210936" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(604.3171763871136, 629.8512451041792)"><circle style="transition:all 0.5s ease-out" r="31.6498922968388" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(595.3819206111697, 750.4380053191775)"><circle style="transition:all 0.5s ease-out" r="31.646387907491086" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(738.1363909009708, 636.515144148231)"><circle style="transition:all 0.5s ease-out" r="31.644635567286116" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(740.5460754862295, 754.520998651475)"><circle style="transition:all 0.5s ease-out" r="31.641130595733323" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(570.4524878114511, 687.9817944500898)"><circle style="transition:all 0.5s ease-out" r="31.632366467765376" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(528.7886842815417, 740.8097019735602)"><circle style="transition:all 0.5s ease-out" r="31.630613350770773" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(771.6061255472321, 694.855467247177)"><circle style="transition:all 0.5s ease-out" r="31.62886013660482" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(807.748226296807, 751.5663130492524)"><circle style="transition:all 0.5s ease-out" r="31.625353416694203" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(610.0368743852628, 562.7142525247313)"><circle style="transition:all 0.5s ease-out" r="31.621846307904192" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(616.580580871706, 814.2565992058935)"><circle style="transition:all 0.5s ease-out" r="31.61833881010538" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(703.0883642242435, 579.1373929372038)"><circle style="transition:all 0.5s ease-out" r="31.616584915287216" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(681.1159743522193, 833.0093417391124)"><circle style="transition:all 0.5s ease-out" r="31.604304926231567" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(662.3614576501155, 520.5127364643226)"><circle style="transition:all 0.5s ease-out" r="31.60255025255361" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(639.5017238798058, 885.5538080444974)"><circle style="transition:all 0.5s ease-out" r="31.599040612890104" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(804.248982859874, 635.3791172152698)"><circle style="transition:all 0.5s ease-out" r="30.48067145084699" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(516.0828675574876, 652.2574485123323)"><circle style="transition:all 0.5s ease-out" r="29.429167946557957" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(744.3437135970462, 819.7520574275438)"><circle style="transition:all 0.5s ease-out" r="29.011657948417223" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(754.1234870630815, 541.9155434593154)"><circle style="transition:all 0.5s ease-out" r="28.599687275134663" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(554.2573620656697, 799.5768347573992)"><circle style="transition:all 0.5s ease-out" r="28.42659587756067" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(547.3495323485586, 562.9239780101367)"><circle style="transition:all 0.5s ease-out" r="27.12693555304999" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(502.9114672687367, 596.4882098766321)"><circle style="transition:all 0.5s ease-out" r="25.21351315743579" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(799.9615178164918, 576.457696358716)"><circle style="transition:all 0.5s ease-out" r="25.072358720652094" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(497.28989021082276, 792.6005347954515)"><circle style="transition:all 0.5s ease-out" r="24.97041111365231" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(808.2330366122889, 811.9841280888674)"><circle style="transition:all 0.5s ease-out" r="24.689007637988443" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(485.04760984410973, 700.4110921442674)"><circle style="transition:all 0.5s ease-out" r="23.866722278751524" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(830.6014688840232, 687.3782097559209)"><circle style="transition:all 0.5s ease-out" r="23.829517700748212" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(471.4748571366998, 748.517928773927)"><circle style="transition:all 0.5s ease-out" r="22.118150096032338" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(855.9005358279788, 726.8447742881848)"><circle style="transition:all 0.5s ease-out" r="21.57751807774017" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(576.942163008979, 524.5418686133636)"><circle style="transition:all 0.5s ease-out" r="19.704994927077085" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(565.1082282403643, 868.7593187301867)"><circle style="transition:all 0.5s ease-out" r="16.84013760959184" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(652.9215031888931, 591.2479789035988)"><circle style="transition:all 0.5s ease-out" r="16.009591283601363" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(703.4992479211926, 788.1937431348674)"><circle style="transition:all 0.5s ease-out" r="14.493399365317345" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(722.0992508873811, 861.4649668979866)"><circle style="transition:all 0.5s ease-out" r="14.281411620876025" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(598.0715783276835, 859.6065429349833)"><circle style="transition:all 0.5s ease-out" r="13.366818227751425" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(710.0473164575907, 530.8234806601935)"><circle style="transition:all 0.5s ease-out" r="13.199830806938117" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(614.1806604228092, 514.3131523575727)"><circle style="transition:all 0.5s ease-out" r="12.97953574937296" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(475.7261577102399, 629.12406089623)"><circle style="transition:all 0.5s ease-out" r="13.081671376029284" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(848.5138026411448, 651.1534062413527)"><circle style="transition:all 0.5s ease-out" r="12.509610246685208" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(775.6998172712741, 787.0586845176362)"><circle style="transition:all 0.5s ease-out" r="12.294990568586265" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(749.7185759388113, 589.8833206310394)"><circle style="transition:all 0.5s ease-out" r="12.276936240831004" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(575.7492278365207, 838.0532447673793)"><circle style="transition:all 0.5s ease-out" r="11.655967192167264" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(561.425507365426, 613.3329401878481)"><circle style="transition:all 0.5s ease-out" r="10.296964563730931" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(525.0507835885152, 695.0604525632343)"><circle style="transition:all 0.5s ease-out" r="10.31310823379049" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(576.0753772063981, 593.6119574070174)"><circle style="transition:all 0.5s ease-out" r="10.2700020545999" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(473.1862482525266, 660.6178908760987)"><circle style="transition:all 0.5s ease-out" r="10.2700020545999" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(771.4958115449388, 604.9921818763369)"><circle style="transition:all 0.5s ease-out" r="10.226714182037899" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(769.8804216139433, 656.8624133535586)"><circle style="transition:all 0.5s ease-out" r="2.052920210786939" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#E67E23;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(433.40151185406387, 431.6380841907212)"><circle r="71.70269907652296" style="transition:all 0.5s ease-out" stroke="#290819" opacity="0.2" stroke-width="1" fill="none"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(524.0677627433495, 431.6380841907212)"><circle style="transition:all 0.5s ease-out" r="8.99174611967189" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(397.30708107674894, 792.382832128218)"><circle style="transition:all 0.5s ease-out" r="6.203617456932836" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(423.77936966197433, 789.8363268542845)"><circle style="transition:all 0.5s ease-out" r="5.622153541031336" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(421.340785231382, 804.0394549231709)"><circle style="transition:all 0.5s ease-out" r="4.883143668325712" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(408.3945979568219, 801.5989778043112)"><circle style="transition:all 0.5s ease-out" r="4.290760915981489" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(410.7517457507399, 790.1556963688014)"><circle style="transition:all 0.5s ease-out" r="3.555762108967988" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(355.984110301932, 723.5617158258433)"><circle style="transition:all 0.5s ease-out" r="24.98151252846903" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(395.28723506618223, 723.5617158258433)"><circle style="transition:all 0.5s ease-out" r="9.788973284376327" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(387.0208360842943, 743.7954108394747)"><circle style="transition:all 0.5s ease-out" r="7.5355551477663045" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(674.0795697561605, 300.600354602205)"><circle r="140.56907062583295" style="transition:all 0.5s ease-out" stroke="#290819" opacity="0.2" stroke-width="1" fill="none"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(825.3039178909584, 300.600354602205)"><circle style="transition:all 0.5s ease-out" r="6.122638557560121" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(821.105566120347, 313.0120383925832)"><circle style="transition:all 0.5s ease-out" r="2.447243321094082" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(202.23516946563453, 523.3217123470383)"><circle style="transition:all 0.5s ease-out" r="26.650535115322466" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(255.71876514808886, 523.3217123470383)"><circle style="transition:all 0.5s ease-out" r="22.300421615726997" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(232.69476117899163, 560.2694106219385)"><circle style="transition:all 0.5s ease-out" r="16.701261140941916" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(231.55135229921913, 506.4458877360689)"><circle style="transition:all 0.5s ease-out" r="2.643324898320205" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#C7ECEE;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(353.07627392441975, 190.8679710598927)"><circle style="transition:all 0.5s ease-out" r="36.21742508121083" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(424.9040239392803, 189.27718406805653)"><circle style="transition:all 0.5s ease-out" r="31.630613350770773" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(394.742774353987, 249.39778808171005)"><circle style="transition:all 0.5s ease-out" r="31.62886013660482" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(392.1135984828186, 130.55579639746892)"><circle style="transition:all 0.5s ease-out" r="31.62710682525135" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(325.126236161116, 124.69442386870242)"><circle style="transition:all 0.5s ease-out" r="31.616584915287216" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(323.09706166313623, 256.1513987083403)"><circle style="transition:all 0.5s ease-out" r="31.614830923168295" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(457.54682916181844, 132.5560619009207)"><circle style="transition:all 0.5s ease-out" r="29.81294926809045" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(455.3760443538731, 242.1844765375489)"><circle style="transition:all 0.5s ease-out" r="25.425956501770568" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(271.2824990757185, 148.91440187943059)"><circle style="transition:all 0.5s ease-out" r="23.413998017353215" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#E67E23;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(274.14579118371773, 213.21544295368173)"><circle style="transition:all 0.5s ease-out" r="23.192690971232174" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(482.7703598068774, 197.67321353002308)"><circle style="transition:all 0.5s ease-out" r="22.840937663544764" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(506.97617740169204, 156.3536590007171)"><circle style="transition:all 0.5s ease-out" r="21.046714132263784" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(362.3457395812587, 84.9721922624578)"><circle style="transition:all 0.5s ease-out" r="18.815324523271695" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(368.00314292405244, 295.2987126687979)"><circle style="transition:all 0.5s ease-out" r="17.49267076606267" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(434.5177409688905, 283.0953515427923)"><circle style="transition:all 0.5s ease-out" r="16.49747774630882" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(451.5139025493969, 82.67903038711952)"><circle style="transition:all 0.5s ease-out" r="16.416607270346134" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(404.37507520324596, 303.13087540980916)"><circle style="transition:all 0.5s ease-out" r="15.77581113381146" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(499.4615939493446, 236.12270490246144)"><circle style="transition:all 0.5s ease-out" r="15.074789316775137" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(405.1706195710393, 81.65746218389964)"><circle style="transition:all 0.5s ease-out" r="14.982542768800487" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(299.41910521782717, 180.01816391951292)"><circle style="transition:all 0.5s ease-out" r="14.527793769462075" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(466.47959017252447, 280.87795511216837)"><circle style="transition:all 0.5s ease-out" r="12.641897431771781" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(336.8128105602677, 299.069705032622)"><circle style="transition:all 0.5s ease-out" r="10.878336324418195" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(427.0053900435777, 100.93684529705767)"><circle style="transition:all 0.5s ease-out" r="10.145051595993086" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(330.73128697656233, 80.2855284003549)"><circle style="transition:all 0.5s ease-out" r="9.144625930395213" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(309.9846193195671, 213.87717473743635)"><circle style="transition:all 0.5s ease-out" r="8.652311737795564" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(171.18105517593244, 410.0312279643661)"><circle style="transition:all 0.5s ease-out" r="31.60255025255361" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(225.06841584167276, 407.4879608957709)"><circle style="transition:all 0.5s ease-out" r="11.070351511086441" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(215.43782725308424, 430.9894135616146)"><circle style="transition:all 0.5s ease-out" r="10.361388328178668" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(216.3212774534159, 384.42726614827797)"><circle style="transition:all 0.5s ease-out" r="9.617524411758309" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(196.60783581426946, 375.4542625124257)"><circle style="transition:all 0.5s ease-out" r="8.1642728049948" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(197.5080670379602, 444.0525260600412)"><circle style="transition:all 0.5s ease-out" r="8.116587866772312" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(186.10156293891686, 706.3964319187853)"><circle style="transition:all 0.5s ease-out" r="31.61132264696339" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(256.60979673618516, 699.0241719950761)"><circle style="transition:all 0.5s ease-out" r="31.597285646872102" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#6473F2;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(226.8657929585081, 756.6120914226389)"><circle style="transition:all 0.5s ease-out" r="30.25057022699439" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CE83F1;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(221.02113884960755, 644.9057188806429)"><circle style="transition:all 0.5s ease-out" r="26.975238359015666" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(170.99900803011707, 653.7983495832228)"><circle style="transition:all 0.5s ease-out" r="21.326773504341023" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#badc58;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(263.9003010590054, 652.0207387103106)"><circle style="transition:all 0.5s ease-out" r="15.08582099722466" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#badc58;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(181.14984650590975, 753.6623652510492)"><circle style="transition:all 0.5s ease-out" r="11.905446806082933" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CE83F1;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(270.76830677197717, 744.0159082010381)"><circle style="transition:all 0.5s ease-out" r="11.517172241416816" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(290.0056529972758, 728.5406305758225)"><circle style="transition:all 0.5s ease-out" r="9.31882493414669" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(155.3230837559973, 736.2281276296034)"><circle style="transition:all 0.5s ease-out" r="7.250524808120427" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(285.92848696022304, 667.6664043609763)"><circle style="transition:all 0.5s ease-out" r="7.32660794936228" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(152.79748336707422, 679.8452002881739)"><circle style="transition:all 0.5s ease-out" r="6.969752033710382" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(223.8849100734516, 678.5342768296385)"><circle style="transition:all 0.5s ease-out" r="2.424477772137891" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#E67E23;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(407.0188404138471, 431.6380841907212)"><circle style="transition:all 0.5s ease-out" r="40.787388684901366" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#E67E23;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(476.45522001466765, 431.6380841907212)"><circle style="transition:all 0.5s ease-out" r="24.11635196451432" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#E67E23;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(453.0418831489632, 462.5151815945517)"><circle style="transition:all 0.5s ease-out" r="10.10122827407493" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#E67E23;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(453.02866663589435, 400.84014802411934)"><circle style="transition:all 0.5s ease-out" r="10.046180298724584" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(640.2281851871037, 307.42573164017404)"><circle style="transition:all 0.5s ease-out" r="31.621846307904192" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(707.9922388092577, 307.42573164017404)"><circle style="transition:all 0.5s ease-out" r="31.609568362845003" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(674.121945939142, 362.61697543947986)"><circle style="transition:all 0.5s ease-out" r="28.613256788957838" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(674.1219399661941, 252.27317363420661)"><circle style="transition:all 0.5s ease-out" r="28.580291079431134" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(612.8635467089508, 249.15147964233762)"><circle style="transition:all 0.5s ease-out" r="28.224951558259836" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(735.3854167050042, 249.17411555761942)"><circle style="transition:all 0.5s ease-out" r="28.228880694710732" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(617.4934983794641, 362.5593303507239)"><circle style="transition:all 0.5s ease-out" r="23.482581159298437" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(730.669835016624, 362.4825884182124)"><circle style="transition:all 0.5s ease-out" r="23.40215302341594" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(765.056215106845, 324.3827358024808)"><circle style="transition:all 0.5s ease-out" r="23.38793111203047" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(583.1373939009395, 324.3271675009003)"><circle style="transition:all 0.5s ease-out" r="23.385559952586846" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(563.97656832516, 276.74346816722857)"><circle style="transition:all 0.5s ease-out" r="23.378445031286557" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(784.2212340445247, 276.82119472086214)"><circle style="transition:all 0.5s ease-out" r="23.357087263514842" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(707.4703988563117, 408.2173533623207)"><circle style="transition:all 0.5s ease-out" r="23.347588650977464" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(640.8753945304458, 408.28876356581117)"><circle style="transition:all 0.5s ease-out" r="23.345213393974422" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(645.0999090640322, 213.69965377382078)"><circle style="transition:all 0.5s ease-out" r="15.159160374548522" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(703.4136995847219, 219.24880092571436)"><circle style="transition:all 0.5s ease-out" r="11.030205045175853" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(679.4166912909445, 208.9195643387979)"><circle style="transition:all 0.5s ease-out" r="10.562805000527778" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(662.9705145655823, 190.38897773357547)"><circle style="transition:all 0.5s ease-out" r="9.680741565928962" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(768.192226416654, 361.7664340433833)"><circle style="transition:all 0.5s ease-out" r="9.594433083333872" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(581.3017815130943, 360.43738978728953)"><circle style="transition:all 0.5s ease-out" r="8.238648668921096" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(674.18659324282, 422.22717587571464)"><circle style="transition:all 0.5s ease-out" r="8.231914994997608" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(724.9744093368314, 209.77933623643003)"><circle style="transition:all 0.5s ease-out" r="7.985722127842087" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(741.2283440364877, 396.6325759185068)"><circle style="transition:all 0.5s ease-out" r="7.810190316303742" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(607.4463637456836, 396.645477625835)"><circle style="transition:all 0.5s ease-out" r="7.52082286554666" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(618.2865211880004, 209.27710050006982)"><circle style="transition:all 0.5s ease-out" r="7.483865281369319" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(698.4267158674387, 196.76331090884327)"><circle style="transition:all 0.5s ease-out" r="7.469031044224364" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(770.2630346542035, 250.24116891321927)"><circle style="transition:all 0.5s ease-out" r="2.132417315396809" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(578.0437253190368, 250.25638392890454)"><circle style="transition:all 0.5s ease-out" r="2.079756908128056" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(589.3741634137172, 372.63337707166085)"><circle style="transition:all 0.5s ease-out" r="1.8542193927675654" stroke-width="0" stroke="#374151"></circle></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(343.1953624106547, 600.4985017278589)"><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;transition:all 0.5s ease-out" fill="#4B5563" text-anchor="middle" dominant-baseline="middle" stroke="white" stroke-width="3" stroke-linejoin="round">catch.hpp</text><text style="pointer-events:none;opacity:1;font-size:14px;font-weight:500;transition:all 0.5s ease-out" text-anchor="middle" dominant-baseline="middle">catch.hpp</text><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;mix-blend-mode:color-burn;transition:all 0.5s ease-out" fill="#110101" text-anchor="middle" dominant-baseline="middle">catch.hpp</text></g><g style="fill:#5758BB;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(259.7877836325603, 901.5821689524196)"><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;transition:all 0.5s ease-out" fill="#4B5563" text-anchor="middle" dominant-baseline="middle" stroke="white" stroke-width="3" stroke-linejoin="round">cpplint.py</text><text style="pointer-events:none;opacity:1;font-size:14px;font-weight:500;transition:all 0.5s ease-out" text-anchor="middle" dominant-baseline="middle">cpplint.py</text><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;mix-blend-mode:color-burn;transition:all 0.5s ease-out" fill="#110101" text-anchor="middle" dominant-baseline="middle">cpplint.py</text></g><g style="fill:#badc58;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(357.0262036099313, 899.5074253547301)"><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;transition:all 0.5s ease-out" fill="#4B5563" text-anchor="middle" dominant-baseline="middle" stroke="white" stroke-width="3" stroke-linejoin="round">run-ci.sh</text><text style="pointer-events:none;opacity:1;font-size:14px;font-weight:500;transition:all 0.5s ease-out" text-anchor="middle" dominant-baseline="middle">run-ci.sh</text><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;mix-blend-mode:color-burn;transition:all 0.5s ease-out" fill="#110101" text-anchor="middle" dominant-baseline="middle">run-ci.sh</text></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(637.0443931827837, 697.5985304847917)"><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;transition:all 0.5s ease-out" fill="#4B5563" text-anchor="middle" dominant-baseline="middle" stroke="white" stroke-width="3" stroke-linejoin="round">heif_plugin.h</text><text style="pointer-events:none;opacity:1;font-size:14px;font-weight:500;transition:all 0.5s ease-out" text-anchor="middle" dominant-baseline="middle">heif_plugin.h</text><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;mix-blend-mode:color-burn;transition:all 0.5s ease-out" fill="#110101" text-anchor="middle" dominant-baseline="middle">heif_plugin.h</text></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(704.3798606109617, 697.8177317688694)"><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;transition:all 0.5s ease-out" fill="#4B5563" text-anchor="middle" dominant-baseline="middle" stroke="white" stroke-width="3" stroke-linejoin="round">heif_image.cc</text><text style="pointer-events:none;opacity:1;font-size:14px;font-weight:500;transition:all 0.5s ease-out" text-anchor="middle" dominant-baseline="middle">heif_image.cc</text><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;mix-blend-mode:color-burn;transition:all 0.5s ease-out" fill="#110101" text-anchor="middle" dominant-baseline="middle">heif_image.cc</text></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(661.9812672904644, 760.1124269810293)"><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;transition:all 0.5s ease-out" fill="#4B5563" text-anchor="middle" dominant-baseline="middle" stroke="white" stroke-width="3" stroke-linejoin="round">heif_file.cc</text><text style="pointer-events:none;opacity:1;font-size:14px;font-weight:500;transition:all 0.5s ease-out" text-anchor="middle" dominant-baseline="middle">heif_file.cc</text><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;mix-blend-mode:color-burn;transition:all 0.5s ease-out" fill="#110101" text-anchor="middle" dominant-baseline="middle">heif_file.cc</text></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(670.934306929805, 639.4841642840804)"><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;transition:all 0.5s ease-out" fill="#4B5563" text-anchor="middle" dominant-baseline="middle" stroke="white" stroke-width="3" stroke-linejoin="round">heif_encoder_...</text><text style="pointer-events:none;opacity:1;font-size:14px;font-weight:500;transition:all 0.5s ease-out" text-anchor="middle" dominant-baseline="middle">heif_encoder_...</text><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;mix-blend-mode:color-burn;transition:all 0.5s ease-out" fill="#110101" text-anchor="middle" dominant-baseline="middle">heif_encoder_...</text></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(604.3171763871136, 629.8512451041792)"><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;transition:all 0.5s ease-out" fill="#4B5563" text-anchor="middle" dominant-baseline="middle" stroke="white" stroke-width="3" stroke-linejoin="round">heif_encoder_...</text><text style="pointer-events:none;opacity:1;font-size:14px;font-weight:500;transition:all 0.5s ease-out" text-anchor="middle" dominant-baseline="middle">heif_encoder_...</text><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;mix-blend-mode:color-burn;transition:all 0.5s ease-out" fill="#110101" text-anchor="middle" dominant-baseline="middle">heif_encoder_...</text></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(595.3819206111697, 750.4380053191775)"><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;transition:all 0.5s ease-out" fill="#4B5563" text-anchor="middle" dominant-baseline="middle" stroke="white" stroke-width="3" stroke-linejoin="round">heif_encoder_...</text><text style="pointer-events:none;opacity:1;font-size:14px;font-weight:500;transition:all 0.5s ease-out" text-anchor="middle" dominant-baseline="middle">heif_encoder_...</text><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;mix-blend-mode:color-burn;transition:all 0.5s ease-out" fill="#110101" text-anchor="middle" dominant-baseline="middle">heif_encoder_...</text></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(738.1363909009708, 636.515144148231)"><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;transition:all 0.5s ease-out" fill="#4B5563" text-anchor="middle" dominant-baseline="middle" stroke="white" stroke-width="3" stroke-linejoin="round">heif_emscript...</text><text style="pointer-events:none;opacity:1;font-size:14px;font-weight:500;transition:all 0.5s ease-out" text-anchor="middle" dominant-baseline="middle">heif_emscript...</text><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;mix-blend-mode:color-burn;transition:all 0.5s ease-out" fill="#110101" text-anchor="middle" dominant-baseline="middle">heif_emscript...</text></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(740.5460754862295, 754.520998651475)"><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;transition:all 0.5s ease-out" fill="#4B5563" text-anchor="middle" dominant-baseline="middle" stroke="white" stroke-width="3" stroke-linejoin="round">heif_decoder_...</text><text style="pointer-events:none;opacity:1;font-size:14px;font-weight:500;transition:all 0.5s ease-out" text-anchor="middle" dominant-baseline="middle">heif_decoder_...</text><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;mix-blend-mode:color-burn;transition:all 0.5s ease-out" fill="#110101" text-anchor="middle" dominant-baseline="middle">heif_decoder_...</text></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(570.4524878114511, 687.9817944500898)"><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;transition:all 0.5s ease-out" fill="#4B5563" text-anchor="middle" dominant-baseline="middle" stroke="white" stroke-width="3" stroke-linejoin="round">heif_cxx.h</text><text style="pointer-events:none;opacity:1;font-size:14px;font-weight:500;transition:all 0.5s ease-out" text-anchor="middle" dominant-baseline="middle">heif_cxx.h</text><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;mix-blend-mode:color-burn;transition:all 0.5s ease-out" fill="#110101" text-anchor="middle" dominant-baseline="middle">heif_cxx.h</text></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(528.7886842815417, 740.8097019735602)"><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;transition:all 0.5s ease-out" fill="#4B5563" text-anchor="middle" dominant-baseline="middle" stroke="white" stroke-width="3" stroke-linejoin="round">heif_context.h</text><text style="pointer-events:none;opacity:1;font-size:14px;font-weight:500;transition:all 0.5s ease-out" text-anchor="middle" dominant-baseline="middle">heif_context.h</text><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;mix-blend-mode:color-burn;transition:all 0.5s ease-out" fill="#110101" text-anchor="middle" dominant-baseline="middle">heif_context.h</text></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(771.6061255472321, 694.855467247177)"><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;transition:all 0.5s ease-out" fill="#4B5563" text-anchor="middle" dominant-baseline="middle" stroke="white" stroke-width="3" stroke-linejoin="round">heif_context.cc</text><text style="pointer-events:none;opacity:1;font-size:14px;font-weight:500;transition:all 0.5s ease-out" text-anchor="middle" dominant-baseline="middle">heif_context.cc</text><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;mix-blend-mode:color-burn;transition:all 0.5s ease-out" fill="#110101" text-anchor="middle" dominant-baseline="middle">heif_context.cc</text></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(807.748226296807, 751.5663130492524)"><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;transition:all 0.5s ease-out" fill="#4B5563" text-anchor="middle" dominant-baseline="middle" stroke="white" stroke-width="3" stroke-linejoin="round">heif_colorcon...</text><text style="pointer-events:none;opacity:1;font-size:14px;font-weight:500;transition:all 0.5s ease-out" text-anchor="middle" dominant-baseline="middle">heif_colorcon...</text><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;mix-blend-mode:color-burn;transition:all 0.5s ease-out" fill="#110101" text-anchor="middle" dominant-baseline="middle">heif_colorcon...</text></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(610.0368743852628, 562.7142525247313)"><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;transition:all 0.5s ease-out" fill="#4B5563" text-anchor="middle" dominant-baseline="middle" stroke="white" stroke-width="3" stroke-linejoin="round">heif_avif.cc</text><text style="pointer-events:none;opacity:1;font-size:14px;font-weight:500;transition:all 0.5s ease-out" text-anchor="middle" dominant-baseline="middle">heif_avif.cc</text><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;mix-blend-mode:color-burn;transition:all 0.5s ease-out" fill="#110101" text-anchor="middle" dominant-baseline="middle">heif_avif.cc</text></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(616.580580871706, 814.2565992058935)"><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;transition:all 0.5s ease-out" fill="#4B5563" text-anchor="middle" dominant-baseline="middle" stroke="white" stroke-width="3" stroke-linejoin="round">heif.h</text><text style="pointer-events:none;opacity:1;font-size:14px;font-weight:500;transition:all 0.5s ease-out" text-anchor="middle" dominant-baseline="middle">heif.h</text><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;mix-blend-mode:color-burn;transition:all 0.5s ease-out" fill="#110101" text-anchor="middle" dominant-baseline="middle">heif.h</text></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(703.0883642242435, 579.1373929372038)"><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;transition:all 0.5s ease-out" fill="#4B5563" text-anchor="middle" dominant-baseline="middle" stroke="white" stroke-width="3" stroke-linejoin="round">heif.cc</text><text style="pointer-events:none;opacity:1;font-size:14px;font-weight:500;transition:all 0.5s ease-out" text-anchor="middle" dominant-baseline="middle">heif.cc</text><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;mix-blend-mode:color-burn;transition:all 0.5s ease-out" fill="#110101" text-anchor="middle" dominant-baseline="middle">heif.cc</text></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(681.1159743522193, 833.0093417391124)"><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;transition:all 0.5s ease-out" fill="#4B5563" text-anchor="middle" dominant-baseline="middle" stroke="white" stroke-width="3" stroke-linejoin="round">box.h</text><text style="pointer-events:none;opacity:1;font-size:14px;font-weight:500;transition:all 0.5s ease-out" text-anchor="middle" dominant-baseline="middle">box.h</text><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;mix-blend-mode:color-burn;transition:all 0.5s ease-out" fill="#110101" text-anchor="middle" dominant-baseline="middle">box.h</text></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(662.3614576501155, 520.5127364643226)"><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;transition:all 0.5s ease-out" fill="#4B5563" text-anchor="middle" dominant-baseline="middle" stroke="white" stroke-width="3" stroke-linejoin="round">box.cc</text><text style="pointer-events:none;opacity:1;font-size:14px;font-weight:500;transition:all 0.5s ease-out" text-anchor="middle" dominant-baseline="middle">box.cc</text><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;mix-blend-mode:color-burn;transition:all 0.5s ease-out" fill="#110101" text-anchor="middle" dominant-baseline="middle">box.cc</text></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(639.5017238798058, 885.5538080444974)"><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;transition:all 0.5s ease-out" fill="#4B5563" text-anchor="middle" dominant-baseline="middle" stroke="white" stroke-width="3" stroke-linejoin="round">bitstream.cc</text><text style="pointer-events:none;opacity:1;font-size:14px;font-weight:500;transition:all 0.5s ease-out" text-anchor="middle" dominant-baseline="middle">bitstream.cc</text><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;mix-blend-mode:color-burn;transition:all 0.5s ease-out" fill="#110101" text-anchor="middle" dominant-baseline="middle">bitstream.cc</text></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(804.248982859874, 635.3791172152698)"><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;transition:all 0.5s ease-out" fill="#4B5563" text-anchor="middle" dominant-baseline="middle" stroke="white" stroke-width="3" stroke-linejoin="round">heif_hevc.cc</text><text style="pointer-events:none;opacity:1;font-size:14px;font-weight:500;transition:all 0.5s ease-out" text-anchor="middle" dominant-baseline="middle">heif_hevc.cc</text><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;mix-blend-mode:color-burn;transition:all 0.5s ease-out" fill="#110101" text-anchor="middle" dominant-baseline="middle">heif_hevc.cc</text></g><g style="fill:#C7ECEE;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(353.07627392441975, 190.8679710598927)"><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;transition:all 0.5s ease-out" fill="#4B5563" text-anchor="middle" dominant-baseline="middle" stroke="white" stroke-width="3" stroke-linejoin="round">demo.html</text><text style="pointer-events:none;opacity:1;font-size:14px;font-weight:500;transition:all 0.5s ease-out" text-anchor="middle" dominant-baseline="middle">demo.html</text><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;mix-blend-mode:color-burn;transition:all 0.5s ease-out" fill="#110101" text-anchor="middle" dominant-baseline="middle">demo.html</text></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(424.9040239392803, 189.27718406805653)"><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;transition:all 0.5s ease-out" fill="#4B5563" text-anchor="middle" dominant-baseline="middle" stroke="white" stroke-width="3" stroke-linejoin="round">heif_info.cc</text><text style="pointer-events:none;opacity:1;font-size:14px;font-weight:500;transition:all 0.5s ease-out" text-anchor="middle" dominant-baseline="middle">heif_info.cc</text><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;mix-blend-mode:color-burn;transition:all 0.5s ease-out" fill="#110101" text-anchor="middle" dominant-baseline="middle">heif_info.cc</text></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(394.742774353987, 249.39778808171005)"><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;transition:all 0.5s ease-out" fill="#4B5563" text-anchor="middle" dominant-baseline="middle" stroke="white" stroke-width="3" stroke-linejoin="round">heif_enc.cc</text><text style="pointer-events:none;opacity:1;font-size:14px;font-weight:500;transition:all 0.5s ease-out" text-anchor="middle" dominant-baseline="middle">heif_enc.cc</text><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;mix-blend-mode:color-burn;transition:all 0.5s ease-out" fill="#110101" text-anchor="middle" dominant-baseline="middle">heif_enc.cc</text></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(392.1135984828186, 130.55579639746892)"><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;transition:all 0.5s ease-out" fill="#4B5563" text-anchor="middle" dominant-baseline="middle" stroke="white" stroke-width="3" stroke-linejoin="round">heif_convert.cc</text><text style="pointer-events:none;opacity:1;font-size:14px;font-weight:500;transition:all 0.5s ease-out" text-anchor="middle" dominant-baseline="middle">heif_convert.cc</text><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;mix-blend-mode:color-burn;transition:all 0.5s ease-out" fill="#110101" text-anchor="middle" dominant-baseline="middle">heif_convert.cc</text></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(325.126236161116, 124.69442386870242)"><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;transition:all 0.5s ease-out" fill="#4B5563" text-anchor="middle" dominant-baseline="middle" stroke="white" stroke-width="3" stroke-linejoin="round">example.heic</text><text style="pointer-events:none;opacity:1;font-size:14px;font-weight:500;transition:all 0.5s ease-out" text-anchor="middle" dominant-baseline="middle">example.heic</text><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;mix-blend-mode:color-burn;transition:all 0.5s ease-out" fill="#110101" text-anchor="middle" dominant-baseline="middle">example.heic</text></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(323.09706166313623, 256.1513987083403)"><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;transition:all 0.5s ease-out" fill="#4B5563" text-anchor="middle" dominant-baseline="middle" stroke="white" stroke-width="3" stroke-linejoin="round">example.avif</text><text style="pointer-events:none;opacity:1;font-size:14px;font-weight:500;transition:all 0.5s ease-out" text-anchor="middle" dominant-baseline="middle">example.avif</text><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;mix-blend-mode:color-burn;transition:all 0.5s ease-out" fill="#110101" text-anchor="middle" dominant-baseline="middle">example.avif</text></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(171.18105517593244, 410.0312279643661)"><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;transition:all 0.5s ease-out" fill="#4B5563" text-anchor="middle" dominant-baseline="middle" stroke="white" stroke-width="3" stroke-linejoin="round">LibFindMacros...</text><text style="pointer-events:none;opacity:1;font-size:14px;font-weight:500;transition:all 0.5s ease-out" text-anchor="middle" dominant-baseline="middle">LibFindMacros...</text><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;mix-blend-mode:color-burn;transition:all 0.5s ease-out" fill="#110101" text-anchor="middle" dominant-baseline="middle">LibFindMacros...</text></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(186.10156293891686, 706.3964319187853)"><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;transition:all 0.5s ease-out" fill="#4B5563" text-anchor="middle" dominant-baseline="middle" stroke="white" stroke-width="3" stroke-linejoin="round">configure.ac</text><text style="pointer-events:none;opacity:1;font-size:14px;font-weight:500;transition:all 0.5s ease-out" text-anchor="middle" dominant-baseline="middle">configure.ac</text><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;mix-blend-mode:color-burn;transition:all 0.5s ease-out" fill="#110101" text-anchor="middle" dominant-baseline="middle">configure.ac</text></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(256.60979673618516, 699.0241719950761)"><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;transition:all 0.5s ease-out" fill="#4B5563" text-anchor="middle" dominant-baseline="middle" stroke="white" stroke-width="3" stroke-linejoin="round">COPYING</text><text style="pointer-events:none;opacity:1;font-size:14px;font-weight:500;transition:all 0.5s ease-out" text-anchor="middle" dominant-baseline="middle">COPYING</text><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;mix-blend-mode:color-burn;transition:all 0.5s ease-out" fill="#110101" text-anchor="middle" dominant-baseline="middle">COPYING</text></g><g style="fill:#6473F2;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(226.8657929585081, 756.6120914226389)"><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;transition:all 0.5s ease-out" fill="#4B5563" text-anchor="middle" dominant-baseline="middle" stroke="white" stroke-width="3" stroke-linejoin="round">README.md</text><text style="pointer-events:none;opacity:1;font-size:14px;font-weight:500;transition:all 0.5s ease-out" text-anchor="middle" dominant-baseline="middle">README.md</text><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;mix-blend-mode:color-burn;transition:all 0.5s ease-out" fill="#110101" text-anchor="middle" dominant-baseline="middle">README.md</text></g><g style="fill:#E67E23;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(407.0188404138471, 431.6380841907212)"><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;transition:all 0.5s ease-out" fill="#4B5563" text-anchor="middle" dominant-baseline="middle" stroke="white" stroke-width="3" stroke-linejoin="round">heif.go</text><text style="pointer-events:none;opacity:1;font-size:14px;font-weight:500;transition:all 0.5s ease-out" text-anchor="middle" dominant-baseline="middle">heif.go</text><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;mix-blend-mode:color-burn;transition:all 0.5s ease-out" fill="#110101" text-anchor="middle" dominant-baseline="middle">heif.go</text></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(640.2281851871037, 307.42573164017404)"><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;transition:all 0.5s ease-out" fill="#4B5563" text-anchor="middle" dominant-baseline="middle" stroke="white" stroke-width="3" stroke-linejoin="round">github_20.heic</text><text style="pointer-events:none;opacity:1;font-size:14px;font-weight:500;transition:all 0.5s ease-out" text-anchor="middle" dominant-baseline="middle">github_20.heic</text><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;mix-blend-mode:color-burn;transition:all 0.5s ease-out" fill="#110101" text-anchor="middle" dominant-baseline="middle">github_20.heic</text></g><g style="fill:#CED6E0;transition:transform 0s ease-out, fill 0.1s ease-out" transform="translate(707.9922388092577, 307.42573164017404)"><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;transition:all 0.5s ease-out" fill="#4B5563" text-anchor="middle" dominant-baseline="middle" stroke="white" stroke-width="3" stroke-linejoin="round">clusterfuzz-t...</text><text style="pointer-events:none;opacity:1;font-size:14px;font-weight:500;transition:all 0.5s ease-out" text-anchor="middle" dominant-baseline="middle">clusterfuzz-t...</text><text style="pointer-events:none;opacity:0.9;font-size:14px;font-weight:500;mix-blend-mode:color-burn;transition:all 0.5s ease-out" fill="#110101" text-anchor="middle" dominant-baseline="middle">clusterfuzz-t...</text></g><g style="pointer-events:none;transition:all 0.5s ease-out" transform="translate(307.39886539102775, 461.42084744282545)"><path fill="none" d="M 0 24.486284536779824 A 24.486284536779824 24.486284536779824 0 0 1 0 -24.486284536779824 A 24.486284536779824 24.486284536779824 0 0 1 0 24.486284536779824" id="CircleText--1" transform="rotate(0)" style="pointer-events:none"></path><text text-anchor="middle" style="font-size:14px;transition:all 0.5s ease-out" fill="#374151" stroke="white" stroke-width="6"><textPath href="#CircleText--1" startOffset="50%">third-party</textPath></text><path fill="none" d="M 0 24.486284536779824 A 24.486284536779824 24.486284536779824 0 0 1 0 -24.486284536779824 A 24.486284536779824 24.486284536779824 0 0 1 0 24.486284536779824" id="CircleText--2" transform="rotate(0)" style="pointer-events:none"></path><text text-anchor="middle" style="font-size:14px;transition:all 0.5s ease-out" fill="#374151"><textPath href="#CircleText--2" startOffset="50%">third-party</textPath></text></g><g style="pointer-events:none;transition:all 0.5s ease-out" transform="translate(365.08629432189406, 594.8760642183305)"><path fill="none" d="M 0 64.16395239911964 A 64.16395239911964 64.16395239911964 0 0 1 0 -64.16395239911964 A 64.16395239911964 64.16395239911964 0 0 1 0 64.16395239911964" id="CircleText--3" transform="rotate(0)" style="pointer-events:none"></path><text text-anchor="middle" style="font-size:14px;transition:all 0.5s ease-out" fill="#374151" stroke="white" stroke-width="6"><textPath href="#CircleText--3" startOffset="50%">tests</textPath></text><path fill="none" d="M 0 64.16395239911964 A 64.16395239911964 64.16395239911964 0 0 1 0 -64.16395239911964 A 64.16395239911964 64.16395239911964 0 0 1 0 64.16395239911964" id="CircleText--4" transform="rotate(0)" style="pointer-events:none"></path><text text-anchor="middle" style="font-size:14px;transition:all 0.5s ease-out" fill="#374151"><textPath href="#CircleText--4" startOffset="50%">tests</textPath></text></g><g style="pointer-events:none;transition:all 0.5s ease-out" transform="translate(302.2028777031694, 896.3002410566528)"><path fill="none" d="M 0 100.69975894334726 A 100.69975894334726 100.69975894334726 0 0 1 0 -100.69975894334726 A 100.69975894334726 100.69975894334726 0 0 1 0 100.69975894334726" id="CircleText--5" transform="rotate(0)" style="pointer-events:none"></path><text text-anchor="middle" style="font-size:14px;transition:all 0.5s ease-out" fill="#374151" stroke="white" stroke-width="6"><textPath href="#CircleText--5" startOffset="50%">scripts</textPath></text><path fill="none" d="M 0 100.69975894334726 A 100.69975894334726 100.69975894334726 0 0 1 0 -100.69975894334726 A 100.69975894334726 100.69975894334726 0 0 1 0 100.69975894334726" id="CircleText--6" transform="rotate(0)" style="pointer-events:none"></path><text text-anchor="middle" style="font-size:14px;transition:all 0.5s ease-out" fill="#374151"><textPath href="#CircleText--6" startOffset="50%">scripts</textPath></text></g><g style="pointer-events:none;transition:all 0.5s ease-out" transform="translate(299.0490531768326, 368.9420579154785)"><path fill="none" d="M 0 42.385569189916325 A 42.385569189916325 42.385569189916325 0 0 1 0 -42.385569189916325 A 42.385569189916325 42.385569189916325 0 0 1 0 42.385569189916325" id="CircleText--7" transform="rotate(0)" style="pointer-events:none"></path><text text-anchor="middle" style="font-size:14px;transition:all 0.5s ease-out" fill="#374151" stroke="white" stroke-width="6"><textPath href="#CircleText--7" startOffset="50%">m4</textPath></text><path fill="none" d="M 0 42.385569189916325 A 42.385569189916325 42.385569189916325 0 0 1 0 -42.385569189916325 A 42.385569189916325 42.385569189916325 0 0 1 0 42.385569189916325" id="CircleText--8" transform="rotate(0)" style="pointer-events:none"></path><text text-anchor="middle" style="font-size:14px;transition:all 0.5s ease-out" fill="#374151"><textPath href="#CircleText--8" startOffset="50%">m4</textPath></text></g><g style="pointer-events:none;transition:all 0.5s ease-out" transform="translate(658.8199629330827, 697.2776788460035)"><path fill="none" d="M 0 220.86365744891555 A 220.86365744891555 220.86365744891555 0 0 1 0 -220.86365744891555 A 220.86365744891555 220.86365744891555 0 0 1 0 220.86365744891555" id="CircleText--9" transform="rotate(0)" style="pointer-events:none"></path><text text-anchor="middle" style="font-size:14px;transition:all 0.5s ease-out" fill="#374151" stroke="white" stroke-width="6"><textPath href="#CircleText--9" startOffset="50%">libheif</textPath></text><path fill="none" d="M 0 220.86365744891555 A 220.86365744891555 220.86365744891555 0 0 1 0 -220.86365744891555 A 220.86365744891555 220.86365744891555 0 0 1 0 220.86365744891555" id="CircleText--10" transform="rotate(0)" style="pointer-events:none"></path><text text-anchor="middle" style="font-size:14px;transition:all 0.5s ease-out" fill="#374151"><textPath href="#CircleText--10" startOffset="50%">libheif</textPath></text></g><g style="pointer-events:none;transition:all 0.5s ease-out" transform="translate(447.3791608202811, 431.6380841907212)"><path fill="none" d="M 0 92.65215373583086 A 92.65215373583086 92.65215373583086 0 0 1 0 -92.65215373583086 A 92.65215373583086 92.65215373583086 0 0 1 0 92.65215373583086" id="CircleText--11" transform="rotate(0)" style="pointer-events:none"></path><text text-anchor="middle" style="font-size:14px;transition:all 0.5s ease-out" fill="#374151" stroke="white" stroke-width="6"><textPath href="#CircleText--11" startOffset="50%">go</textPath></text><path fill="none" d="M 0 92.65215373583086 A 92.65215373583086 92.65215373583086 0 0 1 0 -92.65215373583086 A 92.65215373583086 92.65215373583086 0 0 1 0 92.65215373583086" id="CircleText--12" transform="rotate(0)" style="pointer-events:none"></path><text text-anchor="middle" style="font-size:14px;transition:all 0.5s ease-out" fill="#374151"><textPath href="#CircleText--12" startOffset="50%">go</textPath></text></g><g style="pointer-events:none;transition:all 0.5s ease-out" transform="translate(410.798597767195, 797.093722942152)"><path fill="none" d="M 0 20.49394687473817 A 20.49394687473817 20.49394687473817 0 0 1 0 -20.49394687473817 A 20.49394687473817 20.49394687473817 0 0 1 0 20.49394687473817" id="CircleText--13" transform="rotate(0)" style="pointer-events:none"></path><text text-anchor="middle" style="font-size:14px;transition:all 0.5s ease-out" fill="#374151" stroke="white" stroke-width="6"><textPath href="#CircleText--13" startOffset="50%">gnome</textPath></text><path fill="none" d="M 0 20.49394687473817 A 20.49394687473817 20.49394687473817 0 0 1 0 -20.49394687473817 A 20.49394687473817 20.49394687473817 0 0 1 0 20.49394687473817" id="CircleText--14" transform="rotate(0)" style="pointer-events:none"></path><text text-anchor="middle" style="font-size:14px;transition:all 0.5s ease-out" fill="#374151"><textPath href="#CircleText--14" startOffset="50%">gnome</textPath></text></g><g style="pointer-events:none;transition:all 0.5s ease-out" transform="translate(368.03940306201076, 723.5617158258433)"><path fill="none" d="M 0 38.56944423995263 A 38.56944423995263 38.56944423995263 0 0 1 0 -38.56944423995263 A 38.56944423995263 38.56944423995263 0 0 1 0 38.56944423995263" id="CircleText--15" transform="rotate(0)" style="pointer-events:none"></path><text text-anchor="middle" style="font-size:14px;transition:all 0.5s ease-out" fill="#374151" stroke="white" stroke-width="6"><textPath href="#CircleText--15" startOffset="50%">gdk-pixbuf</textPath></text><path fill="none" d="M 0 38.56944423995263 A 38.56944423995263 38.56944423995263 0 0 1 0 -38.56944423995263 A 38.56944423995263 38.56944423995263 0 0 1 0 38.56944423995263" id="CircleText--16" transform="rotate(0)" style="pointer-events:none"></path><text text-anchor="middle" style="font-size:14px;transition:all 0.5s ease-out" fill="#374151"><textPath href="#CircleText--16" startOffset="50%">gdk-pixbuf</textPath></text></g><g style="pointer-events:none;transition:all 0.5s ease-out" transform="translate(682.468527789423, 300.600354602205)"><path fill="none" d="M 0 150.49066761050034 A 150.49066761050034 150.49066761050034 0 0 1 0 -150.49066761050034 A 150.49066761050034 150.49066761050034 0 0 1 0 150.49066761050034" id="CircleText--17" transform="rotate(0)" style="pointer-events:none"></path><text text-anchor="middle" style="font-size:14px;transition:all 0.5s ease-out" fill="#374151" stroke="white" stroke-width="6"><textPath href="#CircleText--17" startOffset="50%">fuzzing</textPath></text><path fill="none" d="M 0 150.49066761050034 A 150.49066761050034 150.49066761050034 0 0 1 0 -150.49066761050034 A 150.49066761050034 150.49066761050034 0 0 1 0 150.49066761050034" id="CircleText--18" transform="rotate(0)" style="pointer-events:none"></path><text text-anchor="middle" style="font-size:14px;transition:all 0.5s ease-out" fill="#374151"><textPath href="#CircleText--18" startOffset="50%">fuzzing</textPath></text></g><g style="pointer-events:none;transition:all 0.5s ease-out" transform="translate(226.79000944709546, 526.113716110053)"><path fill="none" d="M 0 52.89623643317314 A 52.89623643317314 52.89623643317314 0 0 1 0 -52.89623643317314 A 52.89623643317314 52.89623643317314 0 0 1 0 52.89623643317314" id="CircleText--19" transform="rotate(0)" style="pointer-events:none"></path><text text-anchor="middle" style="font-size:14px;transition:all 0.5s ease-out" fill="#374151" stroke="white" stroke-width="6"><textPath href="#CircleText--19" startOffset="50%">extra</textPath></text><path fill="none" d="M 0 52.89623643317314 A 52.89623643317314 52.89623643317314 0 0 1 0 -52.89623643317314 A 52.89623643317314 52.89623643317314 0 0 1 0 52.89623643317314" id="CircleText--20" transform="rotate(0)" style="pointer-events:none"></path><text text-anchor="middle" style="font-size:14px;transition:all 0.5s ease-out" fill="#374151"><textPath href="#CircleText--20" startOffset="50%">extra</textPath></text></g><g style="pointer-events:none;transition:all 0.5s ease-out" transform="translate(387.51983369006774, 176.5118129198911)"><path fill="none" d="M 0 143.5118129198911 A 143.5118129198911 143.5118129198911 0 0 1 0 -143.5118129198911 A 143.5118129198911 143.5118129198911 0 0 1 0 143.5118129198911" id="CircleText--21" transform="rotate(0)" style="pointer-events:none"></path><text text-anchor="middle" style="font-size:14px;transition:all 0.5s ease-out" fill="#374151" stroke="white" stroke-width="6"><textPath href="#CircleText--21" startOffset="50%">examples</textPath></text><path fill="none" d="M 0 143.5118129198911 A 143.5118129198911 143.5118129198911 0 0 1 0 -143.5118129198911 A 143.5118129198911 143.5118129198911 0 0 1 0 143.5118129198911" id="CircleText--22" transform="rotate(0)" style="pointer-events:none"></path><text text-anchor="middle" style="font-size:14px;transition:all 0.5s ease-out" fill="#374151"><textPath href="#CircleText--22" startOffset="50%">examples</textPath></text></g><g style="pointer-events:none;transition:all 0.5s ease-out" transform="translate(187.4808072541689, 404.66122787644656)"><path fill="none" d="M 0 48.764100845557444 A 48.764100845557444 48.764100845557444 0 0 1 0 -48.764100845557444 A 48.764100845557444 48.764100845557444 0 0 1 0 48.764100845557444" id="CircleText--23" transform="rotate(0)" style="pointer-events:none"></path><text text-anchor="middle" style="font-size:14px;transition:all 0.5s ease-out" fill="#374151" stroke="white" stroke-width="6"><textPath href="#CircleText--23" startOffset="50%">cmake/modules</textPath></text><path fill="none" d="M 0 48.764100845557444 A 48.764100845557444 48.764100845557444 0 0 1 0 -48.764100845557444 A 48.764100845557444 48.764100845557444 0 0 1 0 48.764100845557444" id="CircleText--24" transform="rotate(0)" style="pointer-events:none"></path><text text-anchor="middle" style="font-size:14px;transition:all 0.5s ease-out" fill="#374151"><textPath href="#CircleText--24" startOffset="50%">cmake/modules</textPath></text></g><g style="pointer-events:none;transition:all 0.5s ease-out" transform="translate(433.40151185406387, 431.6380841907212)"><path fill="none" d="M 0 68.70269907652296 A 68.70269907652296 68.70269907652296 0 0 1 0 -68.70269907652296 A 68.70269907652296 68.70269907652296 0 0 1 0 68.70269907652296" id="CircleText--25" transform="rotate(0)" style="pointer-events:none"></path><text text-anchor="middle" style="font-size:14px;transition:all 0.5s ease-out" fill="#374151" stroke="white" stroke-width="6"><textPath href="#CircleText--25" startOffset="50%">heif</textPath></text><path fill="none" d="M 0 68.70269907652296 A 68.70269907652296 68.70269907652296 0 0 1 0 -68.70269907652296 A 68.70269907652296 68.70269907652296 0 0 1 0 68.70269907652296" id="CircleText--26" transform="rotate(0)" style="pointer-events:none"></path><text text-anchor="middle" style="font-size:14px;transition:all 0.5s ease-out" fill="#374151"><textPath href="#CircleText--26" startOffset="50%">heif</textPath></text></g><g style="pointer-events:none;transition:all 0.5s ease-out" transform="translate(674.0795697561605, 300.600354602205)"><path fill="none" d="M 0 137.56907062583295 A 137.56907062583295 137.56907062583295 0 0 1 0 -137.56907062583295 A 137.56907062583295 137.56907062583295 0 0 1 0 137.56907062583295" id="CircleText--27" transform="rotate(0)" style="pointer-events:none"></path><text text-anchor="middle" style="font-size:14px;transition:all 0.5s ease-out" fill="#374151" stroke="white" stroke-width="6"><textPath href="#CircleText--27" startOffset="50%">corpus</textPath></text><path fill="none" d="M 0 137.56907062583295 A 137.56907062583295 137.56907062583295 0 0 1 0 -137.56907062583295 A 137.56907062583295 137.56907062583295 0 0 1 0 137.56907062583295" id="CircleText--28" transform="rotate(0)" style="pointer-events:none"></path><text text-anchor="middle" style="font-size:14px;transition:all 0.5s ease-out" fill="#374151"><textPath href="#CircleText--28" startOffset="50%">corpus</textPath></text></g><g transform="translate(920, 890)"><g transform="translate(0, 0)"><circle r="5" fill="#E67E23"></circle><text x="10" style="font-size:14px;font-weight:300" dominant-baseline="middle">.go</text></g><g transform="translate(0, 15)"><circle r="5" fill="#C7ECEE"></circle><text x="10" style="font-size:14px;font-weight:300" dominant-baseline="middle">.html</text></g><g transform="translate(0, 30)"><circle r="5" fill="#CE83F1"></circle><text x="10" style="font-size:14px;font-weight:300" dominant-baseline="middle">.js</text></g><g transform="translate(0, 45)"><circle r="5" fill="#6473F2"></circle><text x="10" style="font-size:14px;font-weight:300" dominant-baseline="middle">.md</text></g><g transform="translate(0, 60)"><circle r="5" fill="#5758BB"></circle><text x="10" style="font-size:14px;font-weight:300" dominant-baseline="middle">.py</text></g><g transform="translate(0, 75)"><circle r="5" fill="#badc58"></circle><text x="10" style="font-size:14px;font-weight:300" dominant-baseline="middle">.sh</text></g><div class="w-20 whitespace-nowrap text-sm text-gray-500 font-light italic">each dot sized by file size</div></g></svg>
\ No newline at end of file
diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
index 7365d20c16..fc7f2258ee 100644
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@@ -1,143 +1,145 @@
 # Needed to find libheif/heif_version.h while compiling the library
-include_directories(${libheif_BINARY_DIR} ${libheif_SOURCE_DIR})
-
-set (heif_convert_sources
-  encoder.cc
-  encoder.h
-  encoder_y4m.cc
-  encoder_y4m.h
-  heif_convert.cc
-)
-
-set (additional_link_directories)
-set (additional_libraries)
-set (additional_includes)
+include_directories(${libheif_BINARY_DIR} ${libheif_SOURCE_DIR}/libheif/api ${libheif_SOURCE_DIR}/libheif)
+
+if (MSVC)
+    set(getopt_sources
+            ../extra/getopt.c
+            ../extra/getopt.h
+            ../extra/getopt_long.c
+            )
+    include_directories("../extra")
+endif ()
+
+add_executable(heif-info ${getopt_sources}
+        heif_info.cc
+        common.cc
+        common.h)
+if(WIN32)
+    if(MSVC)
+        target_sources(heif-info PRIVATE utf8.manifest)
+    elseif(MINGW)
+        target_sources(heif-info PRIVATE utf8.rc)
+    endif()
+endif()
+target_link_libraries(heif-info heif)
+install(TARGETS heif-info RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+install(FILES heif-info.1 DESTINATION ${CMAKE_INSTALL_MANDIR}/man1)
 
-include (${CMAKE_ROOT}/Modules/FindJPEG.cmake)
 
-if(JPEG_FOUND)
-add_definitions(-DHAVE_LIBJPEG=1)
-include_directories(SYSTEM ${JPEG_INCLUDE_DIR})
+add_executable(heif-dec ${getopt_sources}
+        heif_dec.cc
+        common.cc
+        common.h)
+if(WIN32)
+    if(MSVC)
+        target_sources(heif-dec PRIVATE utf8.manifest)
+    elseif(MINGW)
+        target_sources(heif-dec PRIVATE utf8.rc)
+    endif()
+endif()
+target_link_libraries(heif-dec PRIVATE heif heifio)
+target_include_directories(heif-dec PRIVATE ${libheif_SOURCE_DIR})
+install(TARGETS heif-dec RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+install(FILES heif-dec.1 DESTINATION ${CMAKE_INSTALL_MANDIR}/man1)
+
+# create symbolic link from the old name `heif-convert` to `heif-dec`
+if(NOT WIN32)
+  install(CODE "execute_process(COMMAND ${CMAKE_COMMAND} -E create_symlink heif-dec${CMAKE_EXECUTABLE_SUFFIX} \$ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_BINDIR}/heif-convert${CMAKE_EXECUTABLE_SUFFIX})")
+else()
+  install(CODE "execute_process(COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_BINDIR}/heif-dec${CMAKE_EXECUTABLE_SUFFIX} ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_BINDIR}/heif-convert${CMAKE_EXECUTABLE_SUFFIX})")
+endif()
 
-include (${CMAKE_ROOT}/Modules/CheckCXXSourceCompiles.cmake)
 
-set(CMAKE_REQUIRED_LIBRARIES ${JPEG_LIBRARIES})
+add_executable(heif-enc ${getopt_sources}
+        heif_enc.cc
+        benchmark.h
+        benchmark.cc
+        common.cc
+        common.h
+        SAI_datafile.cc
+        SAI_datafile.h)
+if(WIN32)
+    if(MSVC)
+        target_sources(heif-enc PRIVATE utf8.manifest)
+    elseif(MINGW)
+        target_sources(heif-enc PRIVATE utf8.rc)
+    endif()
+endif()
+target_link_libraries(heif-enc PRIVATE heif heifio)
+target_include_directories(heif-enc PRIVATE ${libheif_SOURCE_DIR})
+install(TARGETS heif-enc RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+install(FILES heif-enc.1 DESTINATION ${CMAKE_INSTALL_MANDIR}/man1)
 
-# while the docs say JPEG_INCLUDE_DIRS, my FindJPEG.cmake script returns it in JPEG_INCLUDE_DIR
-set(CMAKE_REQUIRED_INCLUDES ${JPEG_INCLUDE_DIRS} ${JPEG_INCLUDE_DIR})
+if (WITH_HEADER_COMPRESSION)
+    target_compile_definitions(heif-enc PRIVATE WITH_HEADER_COMPRESSION=1)
+endif ()
 
-check_cxx_source_compiles("
-#include <stddef.h>
-#include <stdio.h>
-#include <jpeglib.h>
+if (ENABLE_EXPERIMENTAL_FEATURES)
+    target_sources(heif-enc PRIVATE vmt.cc vmt.h)
+endif ()
 
-int main() {
-  jpeg_write_icc_profile(NULL, NULL, 0);
-  return 0;
-}
-" HAVE_JPEG_WRITE_ICC_PROFILE)
-if(HAVE_JPEG_WRITE_ICC_PROFILE)
-  add_definitions(-DHAVE_JPEG_WRITE_ICC_PROFILE=1)
-endif()
 
-set (heif_convert_sources
-  ${heif_convert_sources}
-  encoder_jpeg.cc
-  encoder_jpeg.h
-)
-set (additional_libraries
-  ${additional_libraries}
-  ${JPEG_LIBRARIES}
-)
-set (additional_includes
-  ${additional_includes}
-  ${JPEG_INCLUDE_DIRS}
-  ${JPEG_INCLUDE_DIR}
-)
+if (BUILD_DEVELOPMENT_TOOLS AND PNG_FOUND)
+    add_executable(heif-gen-bayer
+            heif_gen_bayer.cc)
+    target_link_libraries(heif-gen-bayer PRIVATE heif heifio)
+    target_include_directories(heif-gen-bayer PRIVATE ${libheif_SOURCE_DIR})
 endif()
 
-if(UNIX OR MINGW)
-  include (${CMAKE_ROOT}/Modules/FindPkgConfig.cmake)
-  pkg_check_modules (LIBPNG libpng)
-  if(LIBPNG_FOUND)
-    add_definitions(-DHAVE_LIBPNG=1)
-    set (heif_convert_sources
-      ${heif_convert_sources}
-      encoder_png.cc
-      encoder_png.h
-    )
-    set (additional_link_directories
-      ${additional_link_directories}
-      ${LIBPNG_LIBRARY_DIRS}
-    )
-    set (additional_libraries
-      ${additional_libraries}
-      ${LIBPNG_LINK_LIBRARIES} ${LIBPNG_LIBRARIES}
-    )
-    set (additional_includes
-      ${additional_includes}
-      ${LIBPNG_INCLUDE_DIRS}
-    )
-  endif()
-endif()
 
-set (heif_info_sources
-  heif_info.cc
-)
-
-set (heif_enc_sources
-  heif_enc.cc
-)
-
-set (heif_test_sources
-  heif_test.cc
-)
-
-if(MSVC)
-  set (getopt_sources
-    ../extra/getopt.c
-    ../extra/getopt.h
-    ../extra/getopt_long.c
-  )
-  include_directories ("../extra")
+if (WITH_EXAMPLE_HEIF_THUMB AND PNG_FOUND)
+    add_executable(heif-thumbnailer ${getopt_sources}
+            heif_thumbnailer.cc
+            common.cc
+            common.h)
+    if(WIN32)
+        if(MSVC)
+                target_sources(heif-thumbnailer PRIVATE utf8.manifest)
+        elseif(MINGW)
+                target_sources(heif-thumbnailer PRIVATE utf8.rc)
+        endif()
+    endif()
+    target_link_libraries(heif-thumbnailer heif heifio)
+    target_include_directories(heif-thumbnailer PRIVATE ${libheif_SOURCE_DIR})
+
+    install(TARGETS heif-thumbnailer RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+    install(FILES heif-thumbnailer.1 DESTINATION ${CMAKE_INSTALL_MANDIR}/man1)
 endif()
 
-add_executable (heif-convert ${heif_convert_sources} ${getopt_sources})
-target_link_directories (heif-convert PRIVATE ${additional_link_directories})
-target_link_libraries (heif-convert heif ${additional_libraries})
-target_include_directories(heif-convert PRIVATE ${additional_includes})
-install(TARGETS heif-convert RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
-install(FILES heif-convert.1 DESTINATION ${CMAKE_INSTALL_MANDIR}/man1)
-
-add_executable (heif-info ${heif_info_sources} ${getopt_sources})
-target_link_libraries (heif-info heif)
-install(TARGETS heif-info RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
-install(FILES heif-info.1 DESTINATION ${CMAKE_INSTALL_MANDIR}/man1)
 
-add_executable (heif-enc ${heif_enc_sources} ${getopt_sources})
-target_link_directories (heif-enc PRIVATE ${additional_link_directories})
-target_link_libraries (heif-enc heif ${additional_libraries})
-target_include_directories(heif-enc PRIVATE ${additional_includes})
-install(TARGETS heif-enc RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
-install(FILES heif-enc.1 DESTINATION ${CMAKE_INSTALL_MANDIR}/man1)
 
-add_executable (heif-test ${heif_test_sources} ${getopt_sources})
-target_link_libraries (heif-test heif)
-
-
-if(LIBPNG_FOUND)
-  set (heif_thumbnailer_sources
-    encoder.cc
-    encoder.h
-    heif_thumbnailer.cc
-    encoder_png.cc
-    encoder_png.h
-    )
-
-  add_executable (heif-thumbnailer ${heif_thumbnailer_sources})
-  target_link_directories (heif-thumbnailer PRIVATE ${LIBPNG_LIBRARY_DIRS})
-  target_link_libraries (heif-thumbnailer heif ${LIBPNG_LINK_LIBRARIES} ${LIBPNG_LIBRARIES})
-  target_include_directories(heif-thumbnailer PRIVATE ${LIBPNG_INCLUDE_DIRS})
-  install(TARGETS heif-thumbnailer RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
-  install(FILES heif-thumbnailer.1 DESTINATION ${CMAKE_INSTALL_MANDIR}/man1)
+if (WITH_EXAMPLE_HEIF_VIEW)
+    find_package(SDL2 NO_MODULE)
+
+    if (SDL2_FOUND)
+        add_executable(heif-view ${getopt_sources}
+                heif_view.cc
+                sdl.cc
+                sdl.hh
+                common.cc
+                common.h)
+        if(WIN32)
+            if(MSVC)
+                target_sources(heif-view PRIVATE utf8.manifest)
+            elseif(MINGW)
+                target_sources(heif-view PRIVATE utf8.rc)
+            endif()
+        endif()
+        target_link_libraries(heif-view PRIVATE heif SDL2::SDL2main SDL2::SDL2)
+        install(TARGETS heif-view RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+    endif ()
+endif ()
+
+
+add_executable(heif-test ${getopt_sources}
+        heif_test.cc
+        common.cc
+        common.h)
+if(WIN32)
+    if(MSVC)
+        target_sources(heif-test PRIVATE utf8.manifest)
+    elseif(MINGW)
+        target_sources(heif-test PRIVATE utf8.rc)
+    endif()
 endif()
+target_link_libraries(heif-test heif)
diff --git a/examples/Makefile.am b/examples/Makefile.am
deleted file mode 100644
index bb2909fbec..0000000000
--- a/examples/Makefile.am
+++ /dev/null
@@ -1,112 +0,0 @@
-AUTOMAKE_OPTIONS = subdir-objects
-
-examples = \
-  heif-convert \
-  heif-enc \
-  heif-info
-
-examples_noinst = \
-  heif-test \
-  test-c-api
-
-dist_man_MANS =
-
-heif_convert_DEPENDENCIES = ../libheif/libheif.la
-heif_convert_CXXFLAGS = -I$(top_srcdir) -I$(top_builddir)/.
-heif_convert_LDFLAGS =
-heif_convert_LDADD = ../libheif/libheif.la
-heif_convert_SOURCES = encoder.cc encoder.h heif_convert.cc encoder_y4m.cc encoder_y4m.h
-dist_man_MANS += heif-convert.1
-
-
-if HAVE_LIBPNG
-examples += heif-thumbnailer
-heif_thumbnailer_DEPENDENCIES = ../libheif/libheif.la
-heif_thumbnailer_CXXFLAGS = -I$(top_srcdir) -I$(top_builddir) $(libpng_CFLAGS)
-heif_thumbnailer_LDFLAGS = $(libpng_LIBS)
-heif_thumbnailer_LDADD = ../libheif/libheif.la
-heif_thumbnailer_SOURCES = encoder.cc encoder.h heif_thumbnailer.cc encoder_png.cc encoder_png.h
-dist_man_MANS += heif-thumbnailer.1
-endif
-
-if HAVE_LIBJPEG
-heif_convert_CXXFLAGS += $(libjpeg_CFLAGS)
-heif_convert_LDADD += $(libjpeg_LIBS)
-heif_convert_SOURCES += encoder_jpeg.cc encoder_jpeg.h
-endif
-
-if HAVE_LIBPNG
-heif_convert_CXXFLAGS += $(libpng_CFLAGS)
-heif_convert_LDADD += $(libpng_LIBS)
-heif_convert_SOURCES += encoder_png.cc encoder_png.h
-endif
-
-heif_info_DEPENDENCIES = ../libheif/libheif.la
-heif_info_CXXFLAGS = -I$(top_srcdir) -I$(top_builddir)
-heif_info_LDFLAGS =
-heif_info_LDADD = ../libheif/libheif.la
-heif_info_SOURCES = heif_info.cc
-dist_man_MANS += heif-info.1
-
-heif_enc_DEPENDENCIES = ../libheif/libheif.la
-heif_enc_CXXFLAGS = -I$(top_srcdir) -I$(top_builddir)
-heif_enc_LDFLAGS =
-heif_enc_LDADD = ../libheif/libheif.la
-heif_enc_SOURCES = heif_enc.cc
-dist_man_MANS += heif-enc.1
-
-if HAVE_LIBJPEG
-heif_enc_CXXFLAGS += $(libjpeg_CFLAGS)
-heif_enc_LDADD += $(libjpeg_LIBS)
-endif
-
-if HAVE_LIBPNG
-heif_enc_CXXFLAGS += $(libpng_CFLAGS)
-heif_enc_LDADD += $(libpng_LIBS)
-endif
-
-heif_test_DEPENDENCIES = ../libheif/libheif.la
-heif_test_CXXFLAGS = -I$(top_srcdir) -I$(top_builddir)
-heif_test_LDFLAGS =
-heif_test_LDADD = ../libheif/libheif.la
-heif_test_SOURCES = heif_test.cc
-
-test_c_api_DEPENDENCIES = ../libheif/libheif.la
-test_c_api_CFLAGS = -I$(top_srcdir) -I$(top_builddir)
-test_c_api_LDFLAGS =
-test_c_api_LDADD = ../libheif/libheif.la
-test_c_api_SOURCES = test_c_api.c
-
-EXTRA_DIST = \
-    CMakeLists.txt \
-    COPYING \
-    demo.html \
-    example.avif \
-    example.heic
-
-if HAVE_GO
-examples_noinst += \
-	heif-test-go
-
-heif_test_go_SOURCES = heif-test.go
-
-gopath:
-	mkdir -p ${CURDIR}/src/github.com/strukturag/libheif
-	ln -sf ${CURDIR}/../go ${CURDIR}/src/github.com/strukturag/libheif/
-
-heif-test-go: gopath $(top_builddir)/libheif/libheif.la $(top_builddir)/libheif.pc heif-test.go
-	GOPATH=${CURDIR} PKG_CONFIG_PATH=${PKG_CONFIG_PATH}:$(abs_top_builddir):$(abs_top_builddir)/libde265/dist/lib/pkgconfig/ CGO_CFLAGS="-I$(abs_top_builddir)" CGO_LDFLAGS="-L$(abs_top_builddir)/libheif/.libs" LD_LIBRARY_PATH=$(abs_top_builddir)/libheif/.libs $(GO) build -o heif-test-go ${heif_test_go_SOURCES}
-
-format-go: ${heif_test_go_SOURCES}
-	$(GO) fmt ${heif_test_go_SOURCES}
-else
-format-go:
-	echo ""go" not present in "${PATH}", skipping formatting"
-endif
-
-if WITH_EXAMPLES
-bin_PROGRAMS = $(examples)
-noinst_PROGRAMS = $(examples_noinst)
-endif
-
-format-local: format-go
diff --git a/examples/SAI_datafile.cc b/examples/SAI_datafile.cc
new file mode 100644
index 0000000000..072225aadb
--- /dev/null
+++ b/examples/SAI_datafile.cc
@@ -0,0 +1,238 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2025 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "SAI_datafile.h"
+
+#include <algorithm>
+#include <fstream>
+#include <iostream>
+#include <sstream>
+
+
+SAI_datafile::~SAI_datafile()
+{
+  heif_tai_clock_info_release(tai_clock_info);
+
+  for (auto tai : tai_timestamps) {
+    heif_tai_timestamp_packet_release(tai);
+  }
+}
+
+
+void SAI_datafile::handleHeaderEntry(const std::string& code,
+                                const std::vector<std::string>& values)
+{
+  if (code == "suid") {
+    active_sais.push_back(code);
+    if (!values.empty()) {
+      std::cerr << "Invalid 'suid' header line. May not have additional parameters.\n";
+      exit(5);
+    }
+  }
+  else if (code == "stai") {
+    active_sais.push_back(code);
+    if (values.size() > 4) {
+      std::cerr << "Invalid 'stai' header line. May not have more than 4 parameters.\n";
+      exit(5);
+    }
+
+    tai_clock_info = heif_tai_clock_info_alloc();
+
+    for (size_t i=0;i<values.size();i++) {
+      int64_t val = std::stoll(values[i]);
+      if (i==1 && (val < 0 || val > 0xffffffff)) {
+        std::cerr << "Invalid SAI tai clock info entry in header\n";
+        exit(5);
+      }
+
+      if (i==2 && (val < 0 || val > 0x7fffffff)) {
+        std::cerr << "Invalid SAI tai clock info entry in header\n";
+        exit(5);
+      }
+
+      if (i==3 && (val < 0 || val > 0xff)) {
+        std::cerr << "Invalid SAI tai clock info entry in header\n";
+        exit(5);
+      }
+
+      switch (i) {
+        case 0:
+          tai_clock_info->time_uncertainty = val;
+          break;
+        case 1:
+          tai_clock_info->clock_resolution = static_cast<uint32_t>(val);
+          break;
+        case 2:
+          tai_clock_info->clock_drift_rate = static_cast<int32_t>(val);
+          break;
+        case 3:
+          tai_clock_info->clock_type = static_cast<uint8_t>(val);
+          break;
+      }
+    }
+  }
+  else {
+    std::cerr << "Unknown code in SAI data file header: " << code << "\n";
+    exit(5);
+  }
+}
+
+void SAI_datafile::handleMainEntry(const std::vector<std::string>& values, int line, int main_item_line)
+{
+  if (active_sais.empty()) {
+    std::cerr << "Invalid SAI data file: data received, but no SAIs defined.";
+    exit(5);
+  }
+
+  size_t idx = main_item_line % active_sais.size();
+  if (active_sais[idx] == "suid") {
+    if (values.size() > 1) {
+      std::cerr << "Invalid SAI content-id entry in line " << line << "\n";
+      exit(5);
+    }
+
+    if (values.empty()) {
+      gimi_content_ids.push_back({});
+    }
+    else {
+      gimi_content_ids.push_back(values[0]);
+    }
+  }
+  else if (active_sais[idx] == "stai") {
+    if (values.size() > 4) {
+      std::cerr << "Invalid SAI timestamp entry in line " << line << "\n";
+      exit(5);
+    }
+
+    if (values.empty()) {
+      tai_timestamps.push_back(nullptr);
+    }
+    else {
+      heif_tai_timestamp_packet* tai = heif_tai_timestamp_packet_alloc();
+      for (size_t i=0;i<values.size();i++) {
+        int64_t val = std::stoll(values[i]);
+        if (i>=1 && i<=3 && (val < 0 || val > 1)) {
+          std::cerr << "Invalid SAI timestamp entry in line " << line << "\n";
+          exit(5);
+        }
+
+        switch (i) {
+          case 0:
+            tai->tai_timestamp = val;
+            break;
+          case 1:
+            tai->synchronization_state = static_cast<uint8_t>(val);
+            break;
+          case 2:
+            tai->timestamp_generation_failure = static_cast<uint8_t>(val);
+            break;
+          case 3:
+            tai->timestamp_is_modified = static_cast<uint8_t>(val);
+            break;
+        }
+      }
+
+      tai_timestamps.push_back(tai);
+    }
+  }
+}
+
+bool SAI_datafile::isSeparatorLine(const std::string& line)
+{
+  return line.starts_with("---");
+}
+
+std::vector<std::string> SAI_datafile::splitCSV(const std::string& line)
+{
+  std::vector<std::string> parts;
+  std::stringstream ss(line);
+  std::string item;
+
+  while (std::getline(ss, item, ',')) {
+    // Trim whitespace
+    item.erase(item.begin(),
+        std::find_if(item.begin(), item.end(), [](unsigned char ch){ return !std::isspace(ch); }));
+    item.erase(
+        std::find_if(item.rbegin(), item.rend(), [](unsigned char ch){ return !std::isspace(ch); }).base(),
+        item.end()
+    );
+    parts.push_back(item);
+  }
+
+  return parts;
+}
+
+
+void SAI_datafile::load_sai_data_from_file(const char* sai_file)
+{
+  std::ifstream istr(sai_file);
+  if (!istr) {
+    std::cerr << "Could not open SAI data file\n";
+    exit(5);
+  }
+
+  // --- read header
+
+  std::string line;
+  bool inHeader = true;
+  int line_counter = 0;
+  int main_item_line = 0;
+
+  while (std::getline(istr, line)) {
+    line_counter++;
+
+    if (inHeader && line.empty())
+      continue;
+
+    if (inHeader && isSeparatorLine(line)) {
+      // Switch to main part
+      inHeader = false;
+      continue;
+    }
+
+    if (inHeader) {
+      // Header line: starts with 4-character code, optional CSV list
+      if (line.size() < 4) {
+        std::cerr << "Invalid header line: " << line << "\n";
+        continue;
+      }
+
+      std::string code = line.substr(0, 4);
+
+      std::vector<std::string> values;
+      if (line.size() > 4) {
+        // Skip the space after the code, if present
+        std::string rest = line.substr(4);
+        if (!rest.empty() && (rest[0] == ' ' || rest[0] == '\t'))
+          rest.erase(0, 1);
+
+        if (!rest.empty())
+          values = splitCSV(rest);
+      }
+
+      handleHeaderEntry(code, values);
+    }
+    else {
+      // Main section: entire line is CSV
+      auto values = splitCSV(line);
+      handleMainEntry(values, line_counter, main_item_line++);
+    }
+  }
+}
diff --git a/examples/SAI_datafile.h b/examples/SAI_datafile.h
new file mode 100644
index 0000000000..bb95c3a825
--- /dev/null
+++ b/examples/SAI_datafile.h
@@ -0,0 +1,54 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2025 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef SAI_DATAFILE_H
+#define SAI_DATAFILE_H
+#include <string>
+#include <vector>
+
+#include "libheif/heif_tai_timestamps.h"
+
+// Helper class for heif-enc to read a SAI data file and provide the data for the track's SAI items.
+struct SAI_datafile
+{
+  ~SAI_datafile();
+
+  void load_sai_data_from_file(const char* sai_file);
+
+  heif_tai_clock_info* tai_clock_info = nullptr;
+
+  std::vector<heif_tai_timestamp_packet*> tai_timestamps;
+  std::vector<std::string> gimi_content_ids;
+
+  std::vector<std::string> active_sais;
+
+private:
+  void handleHeaderEntry(const std::string& code,
+                         const std::vector<std::string>& values);
+
+  void handleMainEntry(const std::vector<std::string>& values, int line, int main_item_line);
+
+  bool isSeparatorLine(const std::string& line);
+
+  std::vector<std::string> splitCSV(const std::string& line);
+};
+
+
+#endif //SAI_DATAFILE_H
diff --git a/examples/benchmark.cc b/examples/benchmark.cc
new file mode 100644
index 0000000000..7694584485
--- /dev/null
+++ b/examples/benchmark.cc
@@ -0,0 +1,99 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2022 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "benchmark.h"
+#include "libheif/heif.h"
+#include <math.h>
+
+
+double compute_psnr(heif_image* original_image, const std::string& encoded_file)
+{
+  double psnr = 0.0;
+
+  // read encoded image
+
+  struct heif_context* ctx = nullptr;
+  struct heif_image_handle* handle = nullptr;
+  struct heif_image* image = nullptr;
+  heif_error err{};
+
+  int orig_stride = 0;
+  const uint8_t* orig_p = nullptr;
+  int compressed_stride = 0;
+  const uint8_t* compressed_p = nullptr;
+
+  int w = 0, h = 0;
+  double mse = 0.0;
+
+
+  if (heif_image_get_colorspace(original_image) != heif_colorspace_YCbCr &&
+      heif_image_get_colorspace(original_image) != heif_colorspace_monochrome) {
+    fprintf(stderr, "Benchmark can only be computed on YCbCr or monochrome images\n");
+    goto cleanup;
+  }
+
+
+  ctx = heif_context_alloc();
+
+  err = heif_context_read_from_file(ctx, encoded_file.c_str(), nullptr);
+  if (err.code) {
+    fprintf(stderr, "Error reading encoded file: %s\n", err.message);
+    goto cleanup;
+  }
+
+  err = heif_context_get_primary_image_handle(ctx, &handle);
+  if (err.code) {
+    fprintf(stderr, "Error getting primary image handle: %s\n", err.message);
+    goto cleanup;
+  }
+
+  err = heif_decode_image(handle, &image,
+                          heif_image_get_colorspace(original_image),
+                          heif_image_get_chroma_format(original_image),
+                          nullptr);
+  if (err.code) {
+    fprintf(stderr, "Error decoding image: %s\n", err.message);
+    goto cleanup;
+  }
+
+  w = heif_image_get_width(original_image, heif_channel_Y);
+  h = heif_image_get_height(original_image, heif_channel_Y);
+
+  orig_p = heif_image_get_plane_readonly(original_image, heif_channel_Y, &orig_stride);
+  compressed_p = heif_image_get_plane_readonly(image, heif_channel_Y, &compressed_stride);
+
+  for (int y = 0; y < h; y++) {
+    for (int x = 0; x < w; x++) {
+      int d = orig_p[y * orig_stride + x] - compressed_p[y * compressed_stride + x];
+      mse += d * d;
+    }
+  }
+
+  mse /= w * h;
+
+  psnr = 10 * log10(255.0 * 255.0 / mse);
+
+  cleanup:
+  heif_image_release(image);
+  heif_image_handle_release(handle);
+  heif_context_free(ctx);
+
+  return psnr;
+}
diff --git a/examples/benchmark.h b/examples/benchmark.h
new file mode 100644
index 0000000000..a214efb30b
--- /dev/null
+++ b/examples/benchmark.h
@@ -0,0 +1,32 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2022 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef LIBHEIF_BENCHMARK_H
+#define LIBHEIF_BENCHMARK_H
+
+#include <memory>
+#include <string>
+
+struct heif_image;
+
+double compute_psnr(heif_image* original_image, const std::string& encoded_file);
+
+#endif //LIBHEIF_BENCHMARK_H
diff --git a/examples/common.cc b/examples/common.cc
new file mode 100644
index 0000000000..04408a1fa1
--- /dev/null
+++ b/examples/common.cc
@@ -0,0 +1,151 @@
+/*
+  libheif example application "heif".
+
+  MIT License
+
+  Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#include "common.h"
+#include "libheif/heif.h"
+#include <iostream>
+#include <fstream>
+#include <array>
+#include <vector>
+#include <algorithm>
+
+#include "common_utils.h"
+
+namespace heif_examples {
+  void show_version()
+  {
+    std::cout << LIBHEIF_VERSION << '\n'
+              << "libheif: " << heif_get_version() << '\n';
+    {
+      auto paths = heif_get_plugin_directories();
+      for (int i = 0; paths[i]; i++) {
+        std::cout << "plugin path: " << paths[i] << '\n';
+      }
+
+      if (paths[0] == nullptr) {
+        std::cout << "plugin path: plugins are disabled\n";
+      }
+
+      heif_free_plugin_directories(paths);
+    }
+  }
+
+
+#define MAX_DECODERS 20
+
+  void list_decoders(heif_compression_format format)
+  {
+    const heif_decoder_descriptor* decoders[MAX_DECODERS];
+    int n = heif_get_decoder_descriptors(format, decoders, MAX_DECODERS);
+
+    for (int i = 0; i < n; i++) {
+      const char* id = heif_decoder_descriptor_get_id_name(decoders[i]);
+      if (id == nullptr) {
+        id = "---";
+      }
+
+      std::cout << "- " << id << " = " << heif_decoder_descriptor_get_name(decoders[i]) << "\n";
+    }
+  }
+
+
+  void list_all_decoders()
+  {
+    std::cout << "AVC decoders:\n";
+    list_decoders(heif_compression_AVC);
+
+    std::cout << "AVIF decoders:\n";
+    list_decoders(heif_compression_AV1);
+
+    std::cout << "HEIC decoders:\n";
+    list_decoders(heif_compression_HEVC);
+
+    std::cout << "JPEG decoders:\n";
+    list_decoders(heif_compression_JPEG);
+
+    std::cout << "JPEG 2000 decoders:\n";
+    list_decoders(heif_compression_JPEG2000);
+
+    std::cout << "JPEG 2000 (HT) decoders:\n";
+    list_decoders(heif_compression_HTJ2K);
+
+    std::cout << "uncompressed:\n";
+    list_decoders(heif_compression_uncompressed);
+
+    std::cout << "VVIC decoders:\n";
+    list_decoders(heif_compression_VVC);
+  }
+
+
+  std::string fourcc_to_string(uint32_t fourcc)
+  {
+    char s[5];
+    s[0] = static_cast<char>((fourcc >> 24) & 0xFF);
+    s[1] = static_cast<char>((fourcc >> 16) & 0xFF);
+    s[2] = static_cast<char>((fourcc >> 8) & 0xFF);
+    s[3] = static_cast<char>((fourcc) & 0xFF);
+    s[4] = 0;
+
+    return s;
+  }
+
+
+  int check_for_valid_input_HEIF_file(const std::string& input_filename)
+  {
+    std::ifstream istr(input_filename.c_str(), std::ios_base::binary);
+    if (istr.fail()) {
+      fprintf(stderr, "Input file does not exist.\n");
+      return 10;
+    }
+
+    std::array<uint8_t, 4> length{};
+    istr.read((char*) length.data(), length.size());
+    uint32_t box_size = four_bytes_to_uint32(length[0], length[1], length[2], length[3]);
+    if ((box_size < 16) || (box_size > 512)) {
+      fprintf(stderr, "Input file does not appear to start with a valid box length.");
+      if ((box_size & 0xFFFFFFF0) == 0xFFD8FFE0) {
+        fprintf(stderr, " Possibly could be a JPEG file instead.\n");
+      }
+      else {
+        fprintf(stderr, "\n");
+      }
+      return 1;
+    }
+
+    std::vector<uint8_t> ftyp_bytes(box_size);
+    std::copy(length.begin(), length.end(), ftyp_bytes.begin());
+    istr.read((char*) ftyp_bytes.data() + 4, ftyp_bytes.size() - 4);
+
+    heif_error filetype_check = heif_has_compatible_filetype(ftyp_bytes.data(), (int) ftyp_bytes.size());
+    if (filetype_check.code != heif_error_Ok) {
+      fprintf(stderr, "Input file is not a supported format. %s\n", filetype_check.message);
+      return 1;
+    }
+
+    return 0;
+  }
+
+}
diff --git a/examples/common.h b/examples/common.h
new file mode 100644
index 0000000000..cdf721492f
--- /dev/null
+++ b/examples/common.h
@@ -0,0 +1,47 @@
+/*
+  libheif example application "heif".
+
+  MIT License
+
+  Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#ifndef LIBHEIF_COMMON_H
+#define LIBHEIF_COMMON_H
+
+#include <libheif/heif.h>
+#include <string>
+
+namespace heif_examples {
+// Note: the same function is also exists in common_utils.h, but is not in the public API.
+  std::string fourcc_to_string(uint32_t fourcc);
+
+  void show_version();
+
+  void list_all_decoders();
+
+  void list_decoders(heif_compression_format format);
+
+// returns 0 on success, or program exit code in case of warning/error
+  int check_for_valid_input_HEIF_file(const std::string& input_filename);
+}
+
+#endif //LIBHEIF_COMMON_H
diff --git a/examples/demo.html b/examples/demo.html
index beb200346b..1c6f8275a7 100644
--- a/examples/demo.html
+++ b/examples/demo.html
@@ -191,6 +191,8 @@ <h1>libheif decoder demo</h1>
         }.bind(this));
         this.drawer = new CanvasDrawer(canvas);
         this.decoder = new libheif.HeifDecoder();
+
+        console.log("Using libheif", libheif.heif_get_version());
         saveSupported = this.canvas.toBlob &&
             ((URL && URL.createObjectURL) || navigator.msSaveOrOpenBlob);
         if (saveSupported) {
@@ -313,8 +315,7 @@ <h1>libheif decoder demo</h1>
             return;
         }
 
-        console.log("Using libheif", libheif.heif_get_version());
-        var demo = new HeifDemo(libheif);
+        var demo = new HeifDemo(libheif());
 
         show("form");
 
diff --git a/examples/encoder_png.cc b/examples/encoder_png.cc
deleted file mode 100644
index d5158dbf4a..0000000000
--- a/examples/encoder_png.cc
+++ /dev/null
@@ -1,142 +0,0 @@
-/*
-  libheif example application "convert".
-
-  MIT License
-
-  Copyright (c) 2017 struktur AG, Joachim Bauch <bauch@struktur.de>
-
-  Permission is hereby granted, free of charge, to any person obtaining a copy
-  of this software and associated documentation files (the "Software"), to deal
-  in the Software without restriction, including without limitation the rights
-  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-  copies of the Software, and to permit persons to whom the Software is
-  furnished to do so, subject to the following conditions:
-
-  The above copyright notice and this permission notice shall be included in all
-  copies or substantial portions of the Software.
-
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-  SOFTWARE.
-*/
-#include <assert.h>
-#include <errno.h>
-#include <math.h>
-#include <png.h>
-#include <string.h>
-#include <stdlib.h>
-
-#include "encoder_png.h"
-
-PngEncoder::PngEncoder()
-{}
-
-
-bool PngEncoder::Encode(const struct heif_image_handle* handle,
-                        const struct heif_image* image, const std::string& filename)
-{
-  png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, nullptr,
-                                                nullptr, nullptr);
-  if (!png_ptr) {
-    fprintf(stderr, "libpng initialization failed (1)\n");
-    return false;
-  }
-
-  png_infop info_ptr = png_create_info_struct(png_ptr);
-  if (!info_ptr) {
-    png_destroy_write_struct(&png_ptr, nullptr);
-    fprintf(stderr, "libpng initialization failed (2)\n");
-    return false;
-  }
-
-  FILE* fp = fopen(filename.c_str(), "wb");
-  if (!fp) {
-    fprintf(stderr, "Can't open %s: %s\n", filename.c_str(), strerror(errno));
-    png_destroy_write_struct(&png_ptr, &info_ptr);
-    return false;
-  }
-
-  if (setjmp(png_jmpbuf(png_ptr))) {
-    png_destroy_write_struct(&png_ptr, &info_ptr);
-    fclose(fp);
-    fprintf(stderr, "Error while encoding image\n");
-    return false;
-  }
-
-  png_init_io(png_ptr, fp);
-
-  bool withAlpha = (heif_image_get_chroma_format(image) == heif_chroma_interleaved_RGBA ||
-                    heif_image_get_chroma_format(image) == heif_chroma_interleaved_RRGGBBAA_BE);
-
-  int width = heif_image_get_width(image, heif_channel_interleaved);
-  int height = heif_image_get_height(image, heif_channel_interleaved);
-
-  int bitDepth;
-  int input_bpp = heif_image_get_bits_per_pixel_range(image, heif_channel_interleaved);
-  if (input_bpp > 8) {
-    bitDepth = 16;
-  }
-  else {
-    bitDepth = 8;
-  }
-
-  const int colorType = withAlpha ? PNG_COLOR_TYPE_RGBA : PNG_COLOR_TYPE_RGB;
-
-  png_set_IHDR(png_ptr, info_ptr, width, height, bitDepth, colorType,
-               PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
-
-  size_t profile_size = heif_image_handle_get_raw_color_profile_size(handle);
-  if (profile_size > 0) {
-    uint8_t* profile_data = static_cast<uint8_t*>(malloc(profile_size));
-    heif_image_handle_get_raw_color_profile(handle, profile_data);
-    char profile_name[] = "unknown";
-    png_set_iCCP(png_ptr, info_ptr, profile_name, PNG_COMPRESSION_TYPE_BASE,
-#if PNG_LIBPNG_VER < 10500
-        (png_charp)profile_data,
-#else
-                 (png_const_bytep) profile_data,
-#endif
-                 (png_uint_32) profile_size);
-    free(profile_data);
-  }
-  png_write_info(png_ptr, info_ptr);
-
-  uint8_t** row_pointers = new uint8_t* [height];
-
-  int stride_rgb;
-  const uint8_t* row_rgb = heif_image_get_plane_readonly(image,
-                                                         heif_channel_interleaved, &stride_rgb);
-
-  for (int y = 0; y < height; ++y) {
-    row_pointers[y] = const_cast<uint8_t*>(&row_rgb[y * stride_rgb]);
-  }
-
-  if (bitDepth == 16) {
-    // shift image data to full 16bit range
-
-    int shift = 16 - input_bpp;
-    if (shift > 0) {
-      for (int y = 0; y < height; ++y) {
-        for (int x = 0; x < stride_rgb; x += 2) {
-          uint8_t* p = (&row_pointers[y][x]);
-          int v = (p[0] << 8) | p[1];
-          v = (v << shift) | (v >> (16 - shift));
-          p[0] = (uint8_t) (v >> 8);
-          p[1] = (uint8_t) (v & 0xFF);
-        }
-      }
-    }
-  }
-
-
-  png_write_image(png_ptr, row_pointers);
-  png_write_end(png_ptr, nullptr);
-  png_destroy_write_struct(&png_ptr, &info_ptr);
-  delete[] row_pointers;
-  fclose(fp);
-  return true;
-}
diff --git a/examples/example.heic b/examples/example.heic
index 91d5dc1497..8293840378 100644
Binary files a/examples/example.heic and b/examples/example.heic differ
diff --git a/examples/heif-convert.1 b/examples/heif-dec.1
similarity index 88%
rename from examples/heif-convert.1
rename to examples/heif-dec.1
index 171acbbc78..da55eae503 100644
--- a/examples/heif-convert.1
+++ b/examples/heif-dec.1
@@ -1,18 +1,18 @@
-.TH HEIF-THUMBNAILER 1
+.TH HEIF-CONVERT 1
 .SH NAME
-heif-convert \- convert HEIC/HEIF image
+heif-dec \- decode HEIC/HEIF image
 .SH SYNOPSIS
-.B heif-convert
+.B heif-dec
 [\fB\-q\fR \fIQUALITY\fR]
 .IR filename
 .IR output[.jpg|.png|.y4m]
 .SH DESCRIPTION
-.B heif-convert
+.B heif-dec
 Convert HEIC/HEIF image to a different image format.
 .SH OPTIONS
 .TP
 .BR \-q\fR\ \fIQUALITY\fR
-Defines quality level between 0 and 100 for the generated output file.
+Defines quality level between 0 and 100 for the generated output file. Only used for JPEG.
 .SH EXIT STATUS
 .PP
 \fB0\fR
diff --git a/examples/heif-enc.1 b/examples/heif-enc.1
index 22164cdaf8..b7ee50bd2b 100644
--- a/examples/heif-enc.1
+++ b/examples/heif-enc.1
@@ -38,11 +38,11 @@ Do not save alpha channel in thumbnail image.
 .BR \-o\fR\ \fIFILENAME\fR ", " \-\-output\fR\ \fIFILENAME\fR
 Output filename (optional).
 .TP
-.BR \-v ", "\-\-verbose\fR
-Enable logging output (more \fB\-v\fR will increase logging level).
+.BR \-\-verbose\fR
+Enable logging output (more will increase logging level).
 .TP
 .BR \-P ", "\-\-params\fR
-Show all encoder parameters.
+Show all encoder parameters and exit. Input file is not required or used.
 .TP
 .BR \-b\fR\ \fIDEPTH\fR
 Bit-depth of generated HEIF file when using 16-bit PNG input (default: 10 bit).
diff --git a/examples/heif-info.1 b/examples/heif-info.1
index 00dc149a53..67ef284023 100644
--- a/examples/heif-info.1
+++ b/examples/heif-info.1
@@ -5,6 +5,7 @@ heif-info \- show information on HEIC/HEIF file
 .B heif-info
 [\fB\-d\fR|\fB--dump-boxes\fR]
 [\fB\-h\fR|\fB--help\fR]
+[\fB\-v\fR|\fB--version\fR]
 .IR filename
 .SH DESCRIPTION
 .B heif-info
@@ -14,8 +15,11 @@ Show information on HEIC/HEIF file.
 .BR \-d ", " \-\-dump-boxes\fR
 Show a low-level dump of all MP4 file boxes.
 .TP
-.BR \-help ", " \-\-help\fR
-Show help.
+.BR \-h ", " \-\-help\fR
+Show help. A filename is not required or used.
+.TP
+.BR \-v ", " \-\-version\fR
+Show version information for the tool, library version, and the plugin path. A filename is not required or used.
 .SH EXIT STATUS
 .PP
 \fB0\fR
diff --git a/examples/heif-test.go b/examples/heif-test.go
index 7540394abb..aed6c6c0ea 100644
--- a/examples/heif-test.go
+++ b/examples/heif-test.go
@@ -3,7 +3,7 @@
 
   MIT License
 
-  Copyright (c) 2018 struktur AG, Dirk Farin <farin@struktur.de>
+  Copyright (c) 2018 Dirk Farin <dirk.farin@gmail.com>
 
   Permission is hereby granted, free of charge, to any person obtaining a copy
   of this software and associated documentation files (the "Software"), to deal
diff --git a/examples/heif_convert.cc b/examples/heif_convert.cc
deleted file mode 100644
index d878a97112..0000000000
--- a/examples/heif_convert.cc
+++ /dev/null
@@ -1,388 +0,0 @@
-/*
-  libheif example application "convert".
-
-  MIT License
-
-  Copyright (c) 2017 struktur AG, Joachim Bauch <bauch@struktur.de>
-
-  Permission is hereby granted, free of charge, to any person obtaining a copy
-  of this software and associated documentation files (the "Software"), to deal
-  in the Software without restriction, including without limitation the rights
-  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-  copies of the Software, and to permit persons to whom the Software is
-  furnished to do so, subject to the following conditions:
-
-  The above copyright notice and this permission notice shall be included in all
-  copies or substantial portions of the Software.
-
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-  SOFTWARE.
-*/
-#if defined(HAVE_CONFIG_H)
-#include "config.h"
-#endif
-
-#include <cstring>
-
-#if defined(HAVE_UNISTD_H)
-
-#include <unistd.h>
-
-#endif
-
-#include <fstream>
-#include <iostream>
-#include <sstream>
-#include <cassert>
-#include <algorithm>
-#include <vector>
-#include <cctype>
-
-#include <libheif/heif.h>
-
-#include "encoder.h"
-
-#if HAVE_LIBJPEG
-
-#include "encoder_jpeg.h"
-
-#endif
-#if HAVE_LIBPNG
-
-#include "encoder_png.h"
-
-#endif
-
-#include "encoder_y4m.h"
-
-#if defined(__MINGW32__)  || defined(__MINGW64__) || defined(_MSC_VER)
-#include "getopt.h"
-#endif
-
-#define UNUSED(x) (void)x
-
-static int usage(const char* command)
-{
-  fprintf(stderr, "USAGE: %s [-q quality 0..100] <filename> <output>\n", command);
-  return 1;
-}
-
-class ContextReleaser
-{
-public:
-  ContextReleaser(struct heif_context* ctx) : ctx_(ctx)
-  {}
-
-  ~ContextReleaser()
-  {
-    heif_context_free(ctx_);
-  }
-
-private:
-  struct heif_context* ctx_;
-};
-
-int main(int argc, char** argv)
-{
-  int opt;
-  int quality = -1;  // Use default quality.
-  UNUSED(quality);  // The quality will only be used by encoders that support it.
-  while ((opt = getopt(argc, argv, "q:")) != -1) {
-    switch (opt) {
-      case 'q':
-        quality = atoi(optarg);
-        break;
-      default: /* '?' */
-        return usage(argv[0]);
-    }
-  }
-
-  if (optind + 2 > argc) {
-    // Need input and output filenames as additional arguments.
-    return usage(argv[0]);
-  }
-
-  std::string input_filename(argv[optind++]);
-  std::string output_filename(argv[optind++]);
-
-  std::unique_ptr<Encoder> encoder;
-
-  size_t dot_pos = output_filename.rfind('.');
-  if (dot_pos != std::string::npos) {
-    std::string suffix_lowercase = output_filename.substr(dot_pos + 1);
-
-    std::transform(suffix_lowercase.begin(), suffix_lowercase.end(),
-                   suffix_lowercase.begin(), ::tolower);
-
-    if (suffix_lowercase == "jpg" || suffix_lowercase == "jpeg") {
-#if HAVE_LIBJPEG
-      static const int kDefaultJpegQuality = 90;
-      if (quality == -1) {
-        quality = kDefaultJpegQuality;
-      }
-      encoder.reset(new JpegEncoder(quality));
-#else
-      fprintf(stderr, "JPEG support has not been compiled in.\n");
-      return 1;
-#endif  // HAVE_LIBJPEG
-    }
-
-    if (suffix_lowercase == "png") {
-#if HAVE_LIBPNG
-      encoder.reset(new PngEncoder());
-#else
-      fprintf(stderr, "PNG support has not been compiled in.\n");
-      return 1;
-#endif  // HAVE_LIBPNG
-    }
-
-    if (suffix_lowercase == "y4m") {
-      encoder.reset(new Y4MEncoder());
-    }
-  }
-
-  if (!encoder) {
-    fprintf(stderr, "Unknown file type in %s\n", output_filename.c_str());
-    return 1;
-  }
-
-
-  // --- check whether input is a supported HEIF file
-
-  // TODO: when we are reading from named pipes, we probably should not consume any bytes
-  // just for file-type checking.
-  // TODO: check, whether reading from named pipes works at all.
-
-  std::ifstream istr(input_filename.c_str(), std::ios_base::binary);
-  uint8_t magic[12];
-  istr.read((char*) magic, 12);
-  enum heif_filetype_result filetype_check = heif_check_filetype(magic, 12);
-  if (filetype_check == heif_filetype_no) {
-    fprintf(stderr, "Input file is not an HEIF/AVIF file\n");
-    return 1;
-  }
-
-  if (filetype_check == heif_filetype_yes_unsupported) {
-    fprintf(stderr, "Input file is an unsupported HEIF/AVIF file type\n");
-    return 1;
-  }
-
-
-
-  // --- read the HEIF file
-
-  struct heif_context* ctx = heif_context_alloc();
-  if (!ctx) {
-    fprintf(stderr, "Could not create context object\n");
-    return 1;
-  }
-
-  ContextReleaser cr(ctx);
-  struct heif_error err;
-  err = heif_context_read_from_file(ctx, input_filename.c_str(), nullptr);
-  if (err.code != 0) {
-    std::cerr << "Could not read HEIF/AVIF file: " << err.message << "\n";
-    return 1;
-  }
-
-  int num_images = heif_context_get_number_of_top_level_images(ctx);
-  if (num_images == 0) {
-    fprintf(stderr, "File doesn't contain any images\n");
-    return 1;
-  }
-
-  printf("File contains %d images\n", num_images);
-
-  std::vector<heif_item_id> image_IDs(num_images);
-  num_images = heif_context_get_list_of_top_level_image_IDs(ctx, image_IDs.data(), num_images);
-
-
-  std::string filename;
-  size_t image_index = 1;  // Image filenames are "1" based.
-
-  for (int idx = 0; idx < num_images; ++idx) {
-
-    if (num_images > 1) {
-      std::ostringstream s;
-      s << output_filename.substr(0, output_filename.find_last_of('.'));
-      s << "-" << image_index;
-      s << output_filename.substr(output_filename.find_last_of('.'));
-      filename.assign(s.str());
-    }
-    else {
-      filename.assign(output_filename);
-    }
-
-    struct heif_image_handle* handle;
-    err = heif_context_get_image_handle(ctx, image_IDs[idx], &handle);
-    if (err.code) {
-      std::cerr << "Could not read HEIF/AVIF image " << idx << ": "
-                << err.message << "\n";
-      return 1;
-    }
-
-    int has_alpha = heif_image_handle_has_alpha_channel(handle);
-    struct heif_decoding_options* decode_options = heif_decoding_options_alloc();
-    encoder->UpdateDecodingOptions(handle, decode_options);
-
-    int bit_depth = heif_image_handle_get_luma_bits_per_pixel(handle);
-    if (bit_depth < 0) {
-      heif_decoding_options_free(decode_options);
-      heif_image_handle_release(handle);
-      std::cerr << "Input image has undefined bit-depth\n";
-      return 1;
-    }
-
-    struct heif_image* image;
-    err = heif_decode_image(handle,
-                            &image,
-                            encoder->colorspace(has_alpha),
-                            encoder->chroma(has_alpha, bit_depth),
-                            decode_options);
-    heif_decoding_options_free(decode_options);
-    if (err.code) {
-      heif_image_handle_release(handle);
-      std::cerr << "Could not decode image: " << idx << ": "
-                << err.message << "\n";
-      return 1;
-    }
-
-    if (image) {
-      bool written = encoder->Encode(handle, image, filename);
-      if (!written) {
-        fprintf(stderr, "could not write image\n");
-      }
-      else {
-        printf("Written to %s\n", filename.c_str());
-      }
-      heif_image_release(image);
-
-
-      int has_depth = heif_image_handle_has_depth_image(handle);
-      if (has_depth) {
-        heif_item_id depth_id;
-        int nDepthImages = heif_image_handle_get_list_of_depth_image_IDs(handle, &depth_id, 1);
-        assert(nDepthImages == 1);
-        (void) nDepthImages;
-
-        struct heif_image_handle* depth_handle;
-        err = heif_image_handle_get_depth_image_handle(handle, depth_id, &depth_handle);
-        if (err.code) {
-          heif_image_handle_release(handle);
-          std::cerr << "Could not read depth channel\n";
-          return 1;
-        }
-
-        int depth_bit_depth = heif_image_handle_get_luma_bits_per_pixel(depth_handle);
-
-        struct heif_image* depth_image;
-        err = heif_decode_image(depth_handle,
-                                &depth_image,
-                                encoder->colorspace(false),
-                                encoder->chroma(false, depth_bit_depth),
-                                nullptr);
-        if (err.code) {
-          heif_image_handle_release(depth_handle);
-          heif_image_handle_release(handle);
-          std::cerr << "Could not decode depth image: " << err.message << "\n";
-          return 1;
-        }
-
-        std::ostringstream s;
-        s << output_filename.substr(0, output_filename.find('.'));
-        s << "-depth";
-        s << output_filename.substr(output_filename.find('.'));
-
-        written = encoder->Encode(depth_handle, depth_image, s.str());
-        if (!written) {
-          fprintf(stderr, "could not write depth image\n");
-        }
-        else {
-          printf("Depth image written to %s\n", s.str().c_str());
-        }
-
-        heif_image_release(depth_image);
-        heif_image_handle_release(depth_handle);
-      }
-
-
-      // --- aux images
-
-      int nAuxImages = heif_image_handle_get_number_of_auxiliary_images(handle, LIBHEIF_AUX_IMAGE_FILTER_OMIT_ALPHA | LIBHEIF_AUX_IMAGE_FILTER_OMIT_DEPTH);
-      if (nAuxImages>0) {
-
-        std::vector<heif_item_id> auxIDs(nAuxImages);
-        heif_image_handle_get_list_of_auxiliary_image_IDs(handle,
-                                                          LIBHEIF_AUX_IMAGE_FILTER_OMIT_ALPHA | LIBHEIF_AUX_IMAGE_FILTER_OMIT_DEPTH,
-                                                          auxIDs.data(), nAuxImages);
-
-        for (heif_item_id auxId : auxIDs) {
-
-          struct heif_image_handle* aux_handle;
-          err = heif_image_handle_get_auxiliary_image_handle(handle, auxId, &aux_handle);
-          if (err.code) {
-            heif_image_handle_release(handle);
-            std::cerr << "Could not read auxiliary image\n";
-            return 1;
-          }
-
-          int aux_bit_depth = heif_image_handle_get_luma_bits_per_pixel(aux_handle);
-
-          struct heif_image* aux_image;
-          err = heif_decode_image(aux_handle,
-                                  &aux_image,
-                                  encoder->colorspace(false),
-                                  encoder->chroma(false, aux_bit_depth),
-                                  nullptr);
-          if (err.code) {
-            heif_image_handle_release(aux_handle);
-            heif_image_handle_release(handle);
-            std::cerr << "Could not decode auxiliary image: " << err.message << "\n";
-            return 1;
-          }
-
-          const char* auxTypeC = nullptr;
-          err = heif_image_handle_get_auxiliary_type(aux_handle, &auxTypeC);
-          if (err.code) {
-            heif_image_handle_release(aux_handle);
-            heif_image_handle_release(handle);
-            std::cerr << "Could not get type of auxiliary image: " << err.message << "\n";
-            return 1;
-          }
-
-          std::string auxType = std::string(auxTypeC);
-
-          heif_image_handle_free_auxiliary_types(aux_handle, &auxTypeC);
-
-          std::ostringstream s;
-          s << output_filename.substr(0, output_filename.find('.'));
-          s << "-" + auxType;
-          s << output_filename.substr(output_filename.find('.'));
-
-          written = encoder->Encode(aux_handle, aux_image, s.str());
-          if (!written) {
-            fprintf(stderr, "could not write auxiliary image\n");
-          }
-          else {
-            printf("Auxiliary image written to %s\n", s.str().c_str());
-          }
-
-          heif_image_release(aux_image);
-          heif_image_handle_release(aux_handle);
-        }
-      }
-
-
-      heif_image_handle_release(handle);
-    }
-
-    image_index++;
-  }
-
-  return 0;
-}
diff --git a/examples/heif_dec.cc b/examples/heif_dec.cc
new file mode 100644
index 0000000000..14cbaa3c05
--- /dev/null
+++ b/examples/heif_dec.cc
@@ -0,0 +1,1090 @@
+/*
+  libheif example application.
+
+  MIT License
+
+  Copyright (c) 2017-2024 Dirk Farin <dirk.farin@gmail.com>
+  Copyright (c) 2017 struktur AG, Joachim Bauch <bauch@struktur.de>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#include <cstring>
+#include <getopt.h>
+#include <unordered_set>
+#include <filesystem>
+#include "libheif/heif_items.h"
+#include "libheif/heif_experimental.h"
+#include "libheif/heif_sequences.h"
+
+#if defined(HAVE_UNISTD_H)
+
+#include <unistd.h>
+
+#endif
+
+#include <fstream>
+#include <iostream>
+#include <iomanip>
+#include <sstream>
+#include <cassert>
+#include <algorithm>
+#include <vector>
+#include <array>
+#include <cctype>
+
+#include <libheif/heif.h>
+#include <libheif/heif_tai_timestamps.h>
+
+#include "heifio/encoder.h"
+
+#if HAVE_LIBJPEG
+#include "heifio/encoder_jpeg.h"
+#endif
+
+#if HAVE_LIBPNG
+#include "heifio/encoder_png.h"
+#endif
+
+#if HAVE_LIBTIFF
+#include "heifio/encoder_tiff.h"
+#endif
+
+#include "../heifio/encoder_y4m.h"
+#include "common.h"
+#include "common_utils.h"
+
+#if defined(_MSC_VER)
+#include "getopt.h"
+#endif
+
+#define UNUSED(x) (void)x
+
+
+static void show_help(const char* argv0)
+{
+  std::filesystem::path p(argv0);
+  std::string filename = p.filename().string();
+
+  std::stringstream sstr;
+  sstr << " " << filename << "  libheif version: " << heif_get_version();
+
+  std::string title = sstr.str();
+
+  std::cerr << title << "\n"
+            << std::string(title.length() + 1, '-') << "\n"
+            << "Usage: " << filename << " [options]  <input-image> [output-image]\n"
+            << "\n"
+               "The program determines the output file format from the output filename suffix.\n"
+               "These suffixes are recognized: jpg, jpeg, png, tif, tiff, y4m. If no output filename is specified, 'jpg' is used.\n"
+               "\n"
+               "Options:\n"
+               "  -h, --help                     show help\n"
+               "  -v, --version                  show version\n"
+               "  -q, --quality                  quality (for JPEG output)\n"
+               "  -o, --output FILENAME          write output to FILENAME (optional)\n"
+               "  -d, --decoder ID               use a specific decoder (see --list-decoders)\n"
+               "      --with-aux                 also write auxiliary images (e.g. depth images)\n"
+               "      --with-xmp                 write XMP metadata to file (output filename with .xmp suffix)\n"
+               "      --with-exif                write EXIF metadata to file (output filename with .exif suffix)\n"
+               "      --skip-exif-offset         skip EXIF metadata offset bytes\n"
+               "      --no-colons                replace ':' characters in auxiliary image filenames with '_'\n"
+               "      --list-decoders            list all available decoders (built-in and plugins)\n"
+               "      --tiles                    output all image tiles as separate images\n"
+               "      --quiet                    do not output status messages to console\n"
+               "  -S, --sequence                 decode image sequence instead of still image\n"
+               "      --ignore-editlist          show the raw media sequence timeline without repetitions\n"
+               "  -C, --chroma-upsampling ALGO   Force chroma upsampling algorithm (nn = nearest-neighbor / bilinear)\n"
+               "      --png-compression-level #  Set to integer between 0 (fastest) and 9 (best). Use -1 for default.\n"
+               "      --transparency-composition-mode MODE  Controls how transparent images are rendered when the output format\n"
+               "                                            support transparency. MODE must be one of: white, black, checkerboard.\n"
+               "      --disable-limits           disable all security limits (do not use in production environment)\n"
+               "      --codec-threads #          number of threads to use in the codec plugin (0 = default)\n"
+               "      --extract-mime-item TYPE   extract the MIME item with the given content type into a file (mime-item.data)\n";
+}
+
+
+class ContextReleaser
+{
+public:
+  ContextReleaser(heif_context* ctx) : ctx_(ctx)
+  {}
+
+  ~ContextReleaser()
+  {
+    heif_context_free(ctx_);
+  }
+
+private:
+  heif_context* ctx_;
+};
+
+
+int option_quiet = 0;
+int option_aux = 0;
+int option_no_colons = 0;
+int option_with_xmp = 0;
+int option_with_exif = 0;
+int option_skip_exif_offset = 0;
+int option_list_decoders = 0;
+int option_png_compression_level = -1; // use zlib default
+int option_output_tiles = 0;
+int option_disable_limits = 0;
+int option_sequence = 0;
+int option_ignore_editlist = 0;
+int option_num_codec_threads = 0;
+std::string option_extract_mime_item_type;
+std::string output_filename;
+
+std::string chroma_upsampling;
+std::string transparency_composition_mode = "checkerboard";
+
+#define OPTION_PNG_COMPRESSION_LEVEL 1000
+#define OPTION_TRANSPARENCY_COMPOSITION_MODE 1001
+#define OPTION_CODEC_THREADS 1002
+#define OPTION_EXTRACT_MIME_ITEM 1003
+
+static option long_options[] = {
+    {(char* const) "quality",          required_argument, 0,                        'q'},
+    {(char* const) "strict",           no_argument,       0,                        's'},
+    {(char* const) "decoder",          required_argument, 0,                        'd'},
+    {(char* const) "output",           required_argument, 0,                        'o'},
+    {(char* const) "quiet",            no_argument,       &option_quiet,            1},
+    {(char* const) "with-aux",         no_argument,       &option_aux,              1},
+    {(char* const) "with-xmp",         no_argument,       &option_with_xmp,         1},
+    {(char* const) "with-exif",        no_argument,       &option_with_exif,        1},
+    {(char* const) "skip-exif-offset", no_argument,       &option_skip_exif_offset, 1},
+    {(char* const) "no-colons",        no_argument,       &option_no_colons,        1},
+    {(char* const) "list-decoders",    no_argument,       &option_list_decoders,    1},
+    {(char* const) "tiles",            no_argument,       &option_output_tiles,     1},
+    {(char* const) "sequence",            no_argument,       &option_sequence,     1},
+    {(char* const) "help",             no_argument,       0,                        'h'},
+    {(char* const) "chroma-upsampling", required_argument, 0,                     'C'},
+    {(char* const) "png-compression-level", required_argument, 0,  OPTION_PNG_COMPRESSION_LEVEL},
+    {(char* const) "transparency-composition-mode", required_argument, 0,  OPTION_TRANSPARENCY_COMPOSITION_MODE},
+    {(char* const) "version",          no_argument,       0,                        'v'},
+    {(char* const) "disable-limits", no_argument, &option_disable_limits, 1},
+    {(char* const) "ignore-editlist", no_argument, &option_ignore_editlist, 1},
+    {(char* const) "codec-threads", required_argument, 0,                     OPTION_CODEC_THREADS},
+    {(char* const) "extract-mime-item", required_argument, 0, OPTION_EXTRACT_MIME_ITEM},
+    {nullptr, no_argument, nullptr, 0}
+};
+
+
+#define MAX_DECODERS 20
+
+bool is_integer_string(const char* s)
+{
+  if (strlen(s)==0) {
+    return false;
+  }
+
+  if (!(isdigit(s[0]) || s[0]=='-')) {
+    return false;
+  }
+
+  for (size_t i=strlen(s)-1; i>=1 ; i--) {
+    if (!isdigit(s[i])) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+
+void show_png_compression_level_usage_warning()
+{
+  fprintf(stderr, "Invalid PNG compression level. Has to be between 0 (fastest) and 9 (best).\n"
+                  "You can also use -1 to use the default compression level.\n");
+}
+
+std::string sanitizeFilename(const std::string& filename) {
+  static const std::unordered_set<char> invalidChars = {'\\','/','*','?','"','<','>','|', ':'};
+  std::string sanitized;
+  sanitized.reserve(filename.size()); // avoid reallocations
+
+  for (char c : filename) {
+    if (invalidChars.find(c) != invalidChars.end()) {
+      sanitized += '_';
+    } else {
+      sanitized += c;
+    }
+  }
+  return sanitized;
+}
+
+
+int decode_single_image(heif_image_handle* handle,
+                        std::string filename_stem,
+                        std::string filename_suffix,
+                        heif_decoding_options* decode_options,
+                        std::unique_ptr<Encoder>& encoder)
+{
+  int bit_depth = heif_image_handle_get_luma_bits_per_pixel(handle);
+  if (bit_depth < 0) {
+    std::cerr << "Input image has undefined bit-depth\n";
+    return 1;
+  }
+
+  int has_alpha = heif_image_handle_has_alpha_channel(handle);
+
+  heif_image* image;
+  heif_error err;
+  err = heif_decode_image(handle,
+                          &image,
+                          encoder->colorspace(has_alpha),
+                          encoder->chroma(has_alpha, bit_depth),
+                          decode_options);
+  if (err.code) {
+    std::cerr << "Could not decode image: "
+              << err.message << "\n";
+    return 1;
+  }
+
+  // show decoding warnings
+
+  for (int i = 0;; i++) {
+    int n = heif_image_get_decoding_warnings(image, i, &err, 1);
+    if (n == 0) {
+      break;
+    }
+
+    std::cerr << "Warning: " << err.message << "\n";
+  }
+
+  if (image) {
+    std::string filename = filename_stem + '.' + filename_suffix;
+
+    bool written = encoder->Encode(handle, image, filename);
+    if (!written) {
+      fprintf(stderr, "could not write image\n");
+    }
+    else {
+      if (!option_quiet) {
+        std::cout << "Written to " << filename << "\n";
+      }
+    }
+    heif_image_release(image);
+
+
+    if (option_aux) {
+      int has_depth = heif_image_handle_has_depth_image(handle);
+      if (has_depth) {
+        heif_item_id depth_id;
+        int nDepthImages = heif_image_handle_get_list_of_depth_image_IDs(handle, &depth_id, 1);
+        assert(nDepthImages == 1);
+        (void) nDepthImages;
+
+        heif_image_handle* depth_handle = nullptr;
+        err = heif_image_handle_get_depth_image_handle(handle, depth_id, &depth_handle);
+        if (err.code) {
+          std::cerr << "Could not read depth channel\n";
+          return 1;
+        }
+
+        int depth_bit_depth = heif_image_handle_get_luma_bits_per_pixel(depth_handle);
+
+        heif_image* depth_image;
+        err = heif_decode_image(depth_handle,
+                                &depth_image,
+                                encoder->colorspace(false),
+                                encoder->chroma(false, depth_bit_depth),
+                                nullptr);
+        if (err.code) {
+          heif_image_handle_release(depth_handle);
+          std::cerr << "Could not decode depth image: " << err.message << "\n";
+          return 1;
+        }
+
+        std::ostringstream s;
+        s << filename_stem;
+        s << "-depth.";
+        s << filename_suffix;
+
+        written = encoder->Encode(depth_handle, depth_image, s.str());
+        if (!written) {
+          fprintf(stderr, "could not write depth image\n");
+        }
+        else {
+          if (!option_quiet) {
+            std::cout << "Depth image written to " << s.str() << "\n";
+          }
+        }
+
+        heif_image_release(depth_image);
+        heif_image_handle_release(depth_handle);
+      }
+    }
+
+
+    // --- aux images
+
+    if (option_aux) {
+      int nAuxImages = heif_image_handle_get_number_of_auxiliary_images(handle, LIBHEIF_AUX_IMAGE_FILTER_OMIT_ALPHA | LIBHEIF_AUX_IMAGE_FILTER_OMIT_DEPTH);
+      if (nAuxImages > 0) {
+
+        std::vector<heif_item_id> auxIDs(nAuxImages);
+        heif_image_handle_get_list_of_auxiliary_image_IDs(handle,
+                                                          LIBHEIF_AUX_IMAGE_FILTER_OMIT_ALPHA | LIBHEIF_AUX_IMAGE_FILTER_OMIT_DEPTH,
+                                                          auxIDs.data(), nAuxImages);
+
+        for (heif_item_id auxId : auxIDs) {
+
+          heif_image_handle* aux_handle = nullptr;
+          err = heif_image_handle_get_auxiliary_image_handle(handle, auxId, &aux_handle);
+          if (err.code) {
+            std::cerr << "Could not read auxiliary image\n";
+            return 1;
+          }
+
+          int aux_bit_depth = heif_image_handle_get_luma_bits_per_pixel(aux_handle);
+
+          heif_image* aux_image = nullptr;
+          err = heif_decode_image(aux_handle,
+                                  &aux_image,
+                                  encoder->colorspace(false),
+                                  encoder->chroma(false, aux_bit_depth),
+                                  nullptr);
+          if (err.code) {
+            heif_image_handle_release(aux_handle);
+            std::cerr << "Could not decode auxiliary image: " << err.message << "\n";
+            return 1;
+          }
+
+          const char* auxTypeC = nullptr;
+          err = heif_image_handle_get_auxiliary_type(aux_handle, &auxTypeC);
+          if (err.code) {
+            heif_image_release(aux_image);
+            heif_image_handle_release(aux_handle);
+            std::cerr << "Could not get type of auxiliary image: " << err.message << "\n";
+            return 1;
+          }
+
+          std::string auxType = std::string(auxTypeC);
+
+          heif_image_handle_release_auxiliary_type(aux_handle, &auxTypeC);
+
+          if (option_no_colons) {
+            std::replace(auxType.begin(), auxType.end(), ':', '_');
+          }
+
+          std::ostringstream s;
+          s << filename_stem;
+          s << "-" + sanitizeFilename(auxType) + ".";
+          s << filename_suffix;
+
+          std::string auxFilename = s.str();
+
+          written = encoder->Encode(aux_handle, aux_image, auxFilename);
+          if (!written) {
+            fprintf(stderr, "could not write auxiliary image\n");
+          }
+          else {
+            if (!option_quiet) {
+              std::cout << "Auxiliary image written to " << auxFilename << "\n";
+            }
+          }
+
+          heif_image_release(aux_image);
+          heif_image_handle_release(aux_handle);
+        }
+      }
+    }
+
+
+    // --- write metadata
+
+    if (option_with_xmp || option_with_exif) {
+      int numMetadata = heif_image_handle_get_number_of_metadata_blocks(handle, nullptr);
+      if (numMetadata > 0) {
+        std::vector<heif_item_id> ids(numMetadata);
+        heif_image_handle_get_list_of_metadata_block_IDs(handle, nullptr, ids.data(), numMetadata);
+
+        for (int n = 0; n < numMetadata; n++) {
+
+          // check whether metadata block is XMP
+
+          std::string itemtype = heif_image_handle_get_metadata_type(handle, ids[n]);
+          std::string contenttype = heif_image_handle_get_metadata_content_type(handle, ids[n]);
+
+          if (option_with_xmp && contenttype == "application/rdf+xml") {
+            // read XMP data to memory array
+
+            size_t xmpSize = heif_image_handle_get_metadata_size(handle, ids[n]);
+            std::vector<uint8_t> xmp(xmpSize);
+            err = heif_image_handle_get_metadata(handle, ids[n], xmp.data());
+            if (err.code) {
+              std::cerr << "Could not read XMP metadata: " << err.message << "\n";
+              return 1;
+            }
+
+            // write XMP data to file
+
+            std::string xmp_filename = filename_stem + ".xmp";
+            std::ofstream ostr(xmp_filename.c_str());
+            ostr.write((char*) xmp.data(), xmpSize);
+          }
+          else if (option_with_exif && itemtype == "Exif") {
+            // read EXIF data to memory array
+
+            size_t exifSize = heif_image_handle_get_metadata_size(handle, ids[n]);
+            std::vector<uint8_t> exif(exifSize);
+            err = heif_image_handle_get_metadata(handle, ids[n], exif.data());
+            if (err.code) {
+              std::cerr << "Could not read EXIF metadata: " << err.message << "\n";
+              return 1;
+            }
+
+            uint32_t offset = 0;
+            if (option_skip_exif_offset) {
+              if (exifSize < 4) {
+                std::cerr << "Invalid EXIF metadata, it is too small.\n";
+                return 1;
+              }
+
+              offset = four_bytes_to_uint32(exif[0], exif[1], exif[2], exif[3]);
+              offset += 4;
+
+              if (offset >= exifSize) {
+                std::cerr << "Invalid EXIF metadata, offset out of range.\n";
+                return 1;
+              }
+            }
+
+            // write EXIF data to file
+
+            std::string exif_filename = filename_stem + ".exif";
+            std::ofstream ostr(exif_filename.c_str());
+            ostr.write((char*) exif.data() + offset, exifSize - offset);
+          }
+        }
+      }
+    }
+  }
+
+  return 0;
+}
+
+
+int digits_for_integer(uint32_t v)
+{
+  int digits=1;
+
+  while (v>=10) {
+    digits++;
+    v /= 10;
+  }
+
+  return digits;
+}
+
+
+int decode_image_tiles(heif_image_handle* handle,
+                       std::string filename_stem,
+                       std::string filename_suffix,
+                       heif_decoding_options* decode_options,
+                       std::unique_ptr<Encoder>& encoder)
+{
+  heif_image_tiling tiling;
+
+  heif_image_handle_get_image_tiling(handle, !decode_options->ignore_transformations, &tiling);
+  if (tiling.num_columns == 1 && tiling.num_rows == 1) {
+    return decode_single_image(handle, filename_stem, filename_suffix, decode_options, encoder);
+  }
+
+
+  int bit_depth = heif_image_handle_get_luma_bits_per_pixel(handle);
+  if (bit_depth < 0) {
+    std::cerr << "Input image has undefined bit-depth\n";
+    return 1;
+  }
+
+  int has_alpha = heif_image_handle_has_alpha_channel(handle);
+
+  int digits_tx = digits_for_integer(tiling.num_columns-1);
+  int digits_ty = digits_for_integer(tiling.num_rows-1);
+
+  for (uint32_t ty = 0; ty < tiling.num_rows; ty++)
+    for (uint32_t tx = 0; tx < tiling.num_columns; tx++) {
+      heif_image* image;
+      heif_error err;
+      err = heif_image_handle_decode_image_tile(handle,
+                                                &image,
+                                                encoder->colorspace(has_alpha),
+                                                encoder->chroma(has_alpha, bit_depth),
+                                                decode_options, tx, ty);
+      if (err.code) {
+        std::cerr << "Could not decode image tile: "
+                  << err.message << "\n";
+        return 1;
+      }
+
+      // show decoding warnings
+
+      for (int i = 0;; i++) {
+        int n = heif_image_get_decoding_warnings(image, i, &err, 1);
+        if (n == 0) {
+          break;
+        }
+
+        std::cerr << "Warning: " << err.message << "\n";
+      }
+
+      if (image) {
+        std::stringstream filename_str;
+        filename_str << filename_stem << "-"
+                     << std::setfill('0') << std::setw(digits_ty) << ty << '-'
+                     << std::setfill('0') << std::setw(digits_tx) << tx << "." << filename_suffix;
+
+        std::string filename = filename_str.str();
+
+        bool written = encoder->Encode(handle, image, filename);
+        if (!written) {
+          fprintf(stderr, "could not write image\n");
+        }
+        else {
+          if (!option_quiet) {
+            std::cout << "Written to " << filename << "\n";
+          }
+        }
+        heif_image_release(image);
+      }
+    }
+
+  return 0;
+}
+
+static int max_value_progress = 0;
+
+void start_progress(enum heif_progress_step step, int max_progress, void* progress_user_data)
+{
+  max_value_progress = max_progress;
+}
+
+void on_progress(enum heif_progress_step step, int progress, void* progress_user_data)
+{
+  std::cout << "decoding image... " << progress * 100 / max_value_progress << "%\r";
+  std::cout.flush();
+}
+
+void end_progress(enum heif_progress_step step, void* progress_user_data)
+{
+  std::cout << "\n";
+}
+
+
+class LibHeifInitializer {
+public:
+  LibHeifInitializer() { heif_init(nullptr); }
+  ~LibHeifInitializer() { heif_deinit(); }
+};
+
+
+int main(int argc, char** argv)
+{
+  // This takes care of initializing libheif and also deinitializing it at the end to free all resources.
+  LibHeifInitializer initializer;
+
+  int quality = -1;  // Use default quality.
+  bool strict_decoding = false;
+  const char* decoder_id = nullptr;
+
+  UNUSED(quality);  // The quality will only be used by encoders that support it.
+  //while ((opt = getopt(argc, argv, "q:s")) != -1) {
+  while (true) {
+    int option_index = 0;
+    int c = getopt_long(argc, argv, "hq:sd:C:vo:S", long_options, &option_index);
+    if (c == -1) {
+      break;
+    }
+
+    switch (c) {
+      case 'q':
+        quality = atoi(optarg);
+        break;
+      case 'd':
+        decoder_id = optarg;
+        break;
+      case 's':
+        strict_decoding = true;
+        break;
+      case '?':
+        std::cerr << "\n";
+        [[fallthrough]];
+      case 'h':
+        show_help(argv[0]);
+        return 0;
+      case 'C':
+        chroma_upsampling = optarg;
+        if (chroma_upsampling != "nn" &&
+            chroma_upsampling != "nearest-neighbor" &&
+            chroma_upsampling != "bilinear") {
+          fprintf(stderr, "Undefined chroma upsampling algorithm.\n");
+          exit(5);
+        }
+        if (chroma_upsampling == "nn") { // abbreviation
+          chroma_upsampling = "nearest-neighbor";
+        }
+        break;
+      case OPTION_PNG_COMPRESSION_LEVEL:
+        if (!is_integer_string(optarg)) {
+          show_png_compression_level_usage_warning();
+          exit(5);
+        }
+        option_png_compression_level = std::stoi(optarg);
+        if (option_png_compression_level < -1 || option_png_compression_level > 9) {
+          show_png_compression_level_usage_warning();
+          exit(5);
+        }
+        break;
+      case OPTION_TRANSPARENCY_COMPOSITION_MODE:
+        if (strcmp(optarg, "white") == 0 ||
+            strcmp(optarg, "black") == 0 ||
+            strcmp(optarg, "checkerboard") == 0) {
+            transparency_composition_mode = optarg;
+          }
+        else {
+          fprintf(stderr, "Unknown transparency composition mode. Must be one of: white, black, checkerboard.\n");
+          exit(5);
+        }
+        break;
+      case 'v':
+        heif_examples::show_version();
+        return 0;
+      case 'o':
+        output_filename = optarg;
+        break;
+      case 'S':
+        option_sequence = 1;
+        break;
+      case OPTION_CODEC_THREADS:
+        option_num_codec_threads = atoi(optarg);
+        break;
+      case OPTION_EXTRACT_MIME_ITEM:
+        option_extract_mime_item_type = optarg;
+        break;
+    }
+  }
+
+  if (option_list_decoders) {
+    heif_examples::list_all_decoders();
+    return 0;
+  }
+
+  if (optind >= argc || optind + 2 < argc) {
+    // Need at least input filename as additional argument, but not more as two filenames.
+    show_help(argv[0]);
+    return 5;
+  }
+
+  std::string input_filename(argv[optind++]);
+  std::string output_filename_stem;
+  std::string output_filename_suffix;
+
+  if (output_filename.empty()) {
+    if (optind == argc) {
+      std::string input_stem;
+      size_t dot_pos = input_filename.rfind('.');
+      if (dot_pos != std::string::npos) {
+        input_stem = input_filename.substr(0, dot_pos);
+      }
+      else {
+        input_stem = input_filename;
+      }
+
+      output_filename = input_stem + ".jpg";
+    }
+    else if (optind == argc-1) {
+      output_filename = argv[optind];
+    }
+    else {
+      assert(false);
+    }
+  }
+
+  std::unique_ptr<Encoder> encoder;
+
+  size_t dot_pos = output_filename.rfind('.');
+  if (dot_pos != std::string::npos) {
+    output_filename_stem = output_filename.substr(0,dot_pos);
+    std::string suffix_lowercase = output_filename.substr(dot_pos + 1);
+
+    std::transform(suffix_lowercase.begin(), suffix_lowercase.end(),
+                   suffix_lowercase.begin(), ::tolower);
+
+    output_filename_suffix = suffix_lowercase;
+
+    if (suffix_lowercase == "jpg" || suffix_lowercase == "jpeg") {
+#if HAVE_LIBJPEG
+      static const int kDefaultJpegQuality = 90;
+      if (quality == -1) {
+        quality = kDefaultJpegQuality;
+      }
+      encoder.reset(new JpegEncoder(quality));
+#else
+      fprintf(stderr, "JPEG support has not been compiled in.\n");
+      return 1;
+#endif  // HAVE_LIBJPEG
+    }
+
+    if (suffix_lowercase == "png") {
+#if HAVE_LIBPNG
+      auto pngEncoder = new PngEncoder();
+      pngEncoder->set_compression_level(option_png_compression_level);
+      encoder.reset(pngEncoder);
+#else
+      fprintf(stderr, "PNG support has not been compiled in.\n");
+      return 1;
+#endif  // HAVE_LIBPNG
+    }
+
+    if (suffix_lowercase == "tif" || suffix_lowercase == "tiff") {
+#if HAVE_LIBTIFF
+      encoder.reset(new TiffEncoder());
+#else
+      fprintf(stderr, "TIFF support has not been compiled in.\n");
+      return 1;
+#endif  // HAVE_LIBTIFF
+    }
+
+    if (suffix_lowercase == "y4m") {
+      encoder.reset(new Y4MEncoder());
+    }
+  }
+  else {
+    output_filename_stem = output_filename;
+    output_filename_suffix = "jpg";
+  }
+
+  if (!encoder) {
+    fprintf(stderr, "Unknown file type in %s\n", output_filename.c_str());
+    return 1;
+  }
+
+
+  // --- check whether input is a supported HEIF file
+
+  if (int ret = heif_examples::check_for_valid_input_HEIF_file(input_filename)) {
+    return ret;
+  }
+
+  // --- read the HEIF file
+
+  heif_context* ctx = heif_context_alloc();
+  if (!ctx) {
+    fprintf(stderr, "Could not create context object\n");
+    return 1;
+  }
+
+  if (option_disable_limits) {
+    heif_context_set_security_limits(ctx, heif_get_disabled_security_limits());
+  }
+
+  ContextReleaser cr(ctx);
+  heif_error err;
+  err = heif_context_read_from_file(ctx, input_filename.c_str(), nullptr);
+  if (err.code != 0) {
+    std::cerr << "Could not read HEIF/AVIF file: " << err.message << "\n";
+    return 1;
+  }
+
+
+  if (option_sequence) {
+    if (!heif_context_has_sequence(ctx)) {
+      std::cerr << "File contains no image sequence\n";
+      return 1;
+    }
+
+    int nTracks = heif_context_number_of_sequence_tracks(ctx);
+    std::cout << "number of tracks: " << nTracks << "\n";
+
+    std::vector<uint32_t> track_ids(nTracks);
+    heif_context_get_track_ids(ctx, track_ids.data());
+
+    for (uint32_t id : track_ids) {
+      heif_track* track = heif_context_get_track(ctx, id);
+      std::cout << "#" << id << " : " << heif_examples::fourcc_to_string(heif_track_get_track_handler_type(track));
+
+      if (heif_track_get_track_handler_type(track) == heif_track_type_image_sequence ||
+          heif_track_get_track_handler_type(track) == heif_track_type_video ||
+          heif_track_get_track_handler_type(track) == heif_track_type_auxiliary) {
+        uint16_t w,h;
+        heif_track_get_image_resolution(track, &w, &h);
+        std::cout << " " << w << "x" << h;
+      }
+      else {
+        uint32_t sample_entry_type = heif_track_get_sample_entry_type_of_first_cluster(track);
+        std::cout << "\n  sample entry type: " << heif_examples::fourcc_to_string(sample_entry_type);
+        if (sample_entry_type == heif_fourcc('u', 'r', 'i', 'm')) {
+          const char* uri;
+          err = heif_track_get_urim_sample_entry_uri_of_first_cluster(track, &uri);
+          if (err.code) {
+            std::cerr << "Cannot read 'urim'-track URI: " << err.message << "\n";
+          }
+          std::cout << "\n  URI: " << uri;
+          heif_string_release(uri);
+        }
+
+        // get metadata track samples
+
+        for (;;) {
+          heif_raw_sequence_sample* sample;
+          err = heif_track_get_next_raw_sequence_sample(track, &sample);
+          if (err.code != 0) {
+            break;
+          }
+
+          size_t dataSize;
+          const uint8_t* data = heif_raw_sequence_sample_get_data(sample, &dataSize);
+
+          std::cout << "\n  raw sample: ";
+          for (uint32_t i = 0; i < dataSize; i++) {
+            std::cout << " " << std::hex << (int)data[i];
+          }
+
+          heif_raw_sequence_sample_release(sample);
+        }
+      }
+
+      std::cout << "\n";
+
+      heif_track_release(track);
+    }
+
+    std::unique_ptr<heif_decoding_options, void(*)(heif_decoding_options*)> decode_options(heif_decoding_options_alloc(), heif_decoding_options_free);
+    encoder->UpdateDecodingOptions(nullptr, decode_options.get());
+    decode_options->ignore_sequence_editlist = option_ignore_editlist;
+    decode_options->strict_decoding = strict_decoding;
+    decode_options->decoder_id = decoder_id;
+    decode_options->num_codec_threads = option_num_codec_threads;
+
+    heif_track* track = heif_context_get_track(ctx, 0);
+
+    const char* track_contentId = heif_track_get_gimi_track_content_id(track);
+    if (track_contentId) {
+      std::cout << "track content ID: " << track_contentId << "\n";
+      heif_string_release(track_contentId);
+    }
+
+    const heif_tai_clock_info* taic = heif_track_get_tai_clock_info_of_first_cluster(track);
+    if (taic) {
+      std::cout << "taic: " << taic->time_uncertainty << " / " << taic->clock_resolution << " / "
+                << taic->clock_drift_rate << " / " << int(taic->clock_type) << "\n";
+    }
+
+    int with_alpha = heif_track_has_alpha_channel(track);
+
+    for (int i=0; ;i++) {
+      heif_image* out_image = nullptr;
+      int bit_depth = 8; // TODO
+      err = heif_track_decode_next_image(track, &out_image,
+                                         encoder->colorspace(false),
+                                         encoder->chroma(with_alpha, bit_depth),
+                                         decode_options.get());
+      if (err.code == heif_error_End_of_sequence) {
+        break;
+      }
+      else if (err.code) {
+        std::cerr << err.message << "\n";
+        return 1;
+      }
+
+      std::cout << "sample duration " << heif_image_get_duration(out_image) << "\n";
+
+      const char* contentID = heif_image_get_gimi_sample_content_id(out_image);
+      if (contentID) {
+        std::cout << "content ID " << contentID << "\n";
+        heif_string_release(contentID);
+      }
+
+      heif_tai_timestamp_packet* timestamp;
+      err = heif_image_get_tai_timestamp(out_image, &timestamp);
+      if (err.code) {
+        std::cerr << err.message << "\n";
+        return 10;
+      }
+      else if (timestamp) {
+        std::cout << "TAI timestamp: " << timestamp->tai_timestamp << "\n";
+        heif_tai_timestamp_packet_release(timestamp);
+      }
+
+      std::ostringstream s;
+      s << output_filename_stem;
+      s << "-" << i+1;
+      s << "." << output_filename_suffix;
+      std::string numbered_filename = s.str();
+
+      bool written = encoder->Encode(nullptr, out_image, numbered_filename);
+      if (!written) {
+        fprintf(stderr, "could not write image\n");
+      }
+      else {
+        if (!option_quiet) {
+          std::cout << "Written to " << numbered_filename << "\n";
+        }
+      }
+      heif_image_release(out_image);
+    }
+
+    heif_track_release(track);
+
+    return 0;
+  }
+
+
+  int num_images = heif_context_get_number_of_top_level_images(ctx);
+  if (num_images == 0) {
+    fprintf(stderr, "File doesn't contain any images\n");
+    return 1;
+  }
+
+  if (!option_quiet) {
+    std::cout << "File contains " << num_images << " image" << (num_images>1 ? "s" : "") << "\n";
+  }
+
+  std::vector<heif_item_id> image_IDs(num_images);
+  num_images = heif_context_get_list_of_top_level_image_IDs(ctx, image_IDs.data(), num_images);
+
+
+  std::string filename;
+  size_t image_index = 1;  // Image filenames are "1" based.
+
+  for (int idx = 0; idx < num_images; ++idx) {
+
+    std::string numbered_output_filename_stem;
+
+    if (num_images > 1) {
+      std::ostringstream s;
+      s << output_filename_stem;
+      s << "-" << image_index;
+      numbered_output_filename_stem = s.str();
+
+      s << "." << output_filename_suffix;
+      filename = s.str();
+    }
+    else {
+      filename = output_filename;
+      numbered_output_filename_stem = output_filename_stem;
+    }
+
+    struct heif_image_handle* handle;
+    err = heif_context_get_image_handle(ctx, image_IDs[idx], &handle);
+    if (err.code) {
+      std::cerr << "Could not read HEIF/AVIF image " << idx << ": "
+                << err.message << "\n";
+      return 1;
+    }
+
+    std::unique_ptr<heif_decoding_options, void(*)(heif_decoding_options*)> decode_options(heif_decoding_options_alloc(), heif_decoding_options_free);
+    encoder->UpdateDecodingOptions(handle, decode_options.get());
+
+    decode_options->strict_decoding = strict_decoding;
+    decode_options->decoder_id = decoder_id;
+    decode_options->num_codec_threads = option_num_codec_threads;
+
+    if (!option_quiet) {
+      decode_options->start_progress = start_progress;
+      decode_options->on_progress = on_progress;
+      decode_options->end_progress = end_progress;
+    }
+
+    if (chroma_upsampling=="nearest-neighbor") {
+      decode_options->color_conversion_options.preferred_chroma_upsampling_algorithm = heif_chroma_upsampling_nearest_neighbor;
+      decode_options->color_conversion_options.only_use_preferred_chroma_algorithm = true;
+    }
+    else if (chroma_upsampling=="bilinear") {
+      decode_options->color_conversion_options.preferred_chroma_upsampling_algorithm = heif_chroma_upsampling_bilinear;
+      decode_options->color_conversion_options.only_use_preferred_chroma_algorithm = true;
+    }
+
+    int ret;
+
+    auto* color_conversion_options_ext = heif_color_conversion_options_ext_alloc();
+    decode_options->color_conversion_options_ext = color_conversion_options_ext;
+
+
+    // If output file format does not support transparency, render in the selected composition mode.
+
+    if (!encoder->supports_alpha()) {
+      if (transparency_composition_mode == "white") {
+        color_conversion_options_ext->alpha_composition_mode = heif_alpha_composition_mode_solid_color;
+        color_conversion_options_ext->background_red = 0xFFFFU;
+        color_conversion_options_ext->background_green = 0xFFFFU;
+        color_conversion_options_ext->background_blue = 0xFFFFU;
+      }
+      else if (transparency_composition_mode == "black") {
+        color_conversion_options_ext->alpha_composition_mode = heif_alpha_composition_mode_solid_color;
+        color_conversion_options_ext->background_red = 0;
+        color_conversion_options_ext->background_green = 0;
+        color_conversion_options_ext->background_blue = 0;
+      }
+      else if (transparency_composition_mode == "checkerboard") {
+        color_conversion_options_ext->alpha_composition_mode = heif_alpha_composition_mode_checkerboard;
+      }
+    }
+
+    if (option_output_tiles) {
+      ret = decode_image_tiles(handle, numbered_output_filename_stem, output_filename_suffix, decode_options.get(), encoder);
+    }
+    else {
+      ret = decode_single_image(handle, numbered_output_filename_stem, output_filename_suffix, decode_options.get(), encoder);
+    }
+
+    heif_color_conversion_options_ext_free(color_conversion_options_ext);
+
+    if (ret) {
+      heif_image_handle_release(handle);
+      return ret;
+    }
+
+    heif_image_handle_release(handle);
+
+    image_index++;
+  }
+
+
+  // --- extract MIME item data
+
+  if (!option_extract_mime_item_type.empty()) {
+    int nItems = heif_context_get_number_of_items(ctx);
+    if (nItems > 0) {
+      std::vector<heif_item_id> item_ids(nItems);
+      heif_context_get_list_of_item_IDs(ctx, item_ids.data(), nItems);
+
+      for (auto id : item_ids) {
+        uint32_t type = heif_item_get_item_type(ctx, id);
+        if (type == heif_item_type_mime) {
+          const char* mimeType = heif_item_get_mime_item_content_type(ctx, id);
+          if (option_extract_mime_item_type == mimeType) {
+            uint8_t* data = nullptr;
+            size_t data_size;
+            heif_item_get_item_data(ctx, id, nullptr, &data, &data_size);
+            std::ofstream ostr("mime-item.data");
+            ostr.write((const char*)data, data_size);
+            heif_release_item_data(ctx, &data);
+          }
+        }
+      }
+    }
+
+  }
+
+  return 0;
+}
diff --git a/examples/heif_enc.cc b/examples/heif_enc.cc
index 7ba18f1f64..6beacbafae 100644
--- a/examples/heif_enc.cc
+++ b/examples/heif_enc.cc
@@ -3,7 +3,7 @@
 
   MIT License
 
-  Copyright (c) 2017 struktur AG, Dirk Farin <farin@struktur.de>
+  Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
 
   Permission is hereby granted, free of charge, to any person obtaining a copy
   of this software and associated documentation files (the "Software"), to deal
@@ -23,1007 +23,1469 @@
   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
   SOFTWARE.
 */
-#if defined(HAVE_CONFIG_H)
-#include "config.h"
-#endif
 
-#include <errno.h>
-#include <string.h>
+#include <cassert>
+#include <cerrno>
+#include <cstring>
 #include <getopt.h>
 
 #include <fstream>
 #include <iostream>
+#include <iomanip>
 #include <memory>
 #include <algorithm>
 #include <vector>
 #include <string>
+#include <sstream>
+#include <filesystem>
+#include <regex>
+#include <optional>
+#include <map>
+#include <tuple>
+#include <random>
 
 #include <libheif/heif.h>
-
-#if HAVE_LIBJPEG
-extern "C" {
-// Prevent duplicate definition for libjpeg-turbo v2.0
-// Note: these 'undef's are only a workaround for a libjpeg-turbo-v2.0 bug and
-// should be removed again later. Bug has been fixed in libjpeg-turbo-v2.0.1.
-#include <jconfig.h>
-#if defined(LIBJPEG_TURBO_VERSION_NUMBER) && LIBJPEG_TURBO_VERSION_NUMBER == 2000000
-#undef HAVE_STDDEF_H
-#undef HAVE_STDLIB_H
-#endif
-#include <jpeglib.h>
-}
+#include <libheif/heif_properties.h>
+#include "libheif/heif_items.h"
+
+#include "heifio/decoder_jpeg.h"
+#include "heifio/decoder_png.h"
+#include "heifio/decoder_tiff.h"
+#include "heifio/decoder_raw.h"
+#include "heifio/decoder_y4m.h"
+
+#include "benchmark.h"
+#include "common.h"
+#include "SAI_datafile.h"
+#include "libheif/api_structs.h"
+#include "libheif/heif_experimental.h"
+#include "libheif/heif_sequences.h"
+#include "libheif/heif_uncompressed.h"
+
+#if HEIF_ENABLE_EXPERIMENTAL_FEATURES
+#include "vmt.h"
 #endif
 
-#if HAVE_LIBPNG
-extern "C" {
-#include <png.h>
-}
-#endif
-
-#include <assert.h>
-
-#define JPEG_ICC_MARKER  (JPEG_APP0+2)  /* JPEG marker code for ICC */
-#define JPEG_ICC_OVERHEAD_LEN  14        /* size of non-profile data in APP2 */
+// --- command line parameters
 
 int master_alpha = 1;
 int thumb_alpha = 1;
 int list_encoders = 0;
 int two_colr_boxes = 0;
 int premultiplied_alpha = 0;
+int run_benchmark = 0;
+heif_metadata_compression metadata_compression_method = heif_metadata_compression_off;
+int tiled_input_x_y = 0;
 const char* encoderId = nullptr;
-
-int nclx_matrix_coefficients = 6;
-int nclx_colour_primaries = 2;
-int nclx_transfer_characteristic = 2;
+std::string chroma_downsampling;
+int cut_tiles = 0;
+int tiled_image_width = 0;
+int tiled_image_height = 0;
+std::string tiling_method = "grid";
+heif_unci_compression unci_compression = heif_unci_compression_zlib;
+int add_pyramid_group = 0;
+
+uint16_t nclx_colour_primaries = 1;
+uint16_t nclx_transfer_characteristic = 13;
+uint16_t nclx_matrix_coefficients = 6;
 int nclx_full_range = true;
 
-const int OPTION_NCLX_MATRIX_COEFFICIENTS = 1000;
-const int OPTION_NCLX_COLOUR_PRIMARIES = 1001;
-const int OPTION_NCLX_TRANSFER_CHARACTERISTIC = 1002;
-const int OPTION_NCLX_FULL_RANGE_FLAG = 1003;
-
-static struct option long_options[] = {
-    {(char* const) "help",                    no_argument,       0,              'h'},
-    {(char* const) "quality",                 required_argument, 0,              'q'},
-    {(char* const) "output",                  required_argument, 0,              'o'},
-    {(char* const) "lossless",                no_argument,       0,              'L'},
-    {(char* const) "thumb",                   required_argument, 0,              't'},
-    {(char* const) "verbose",                 no_argument,       0,              'v'},
-    {(char* const) "params",                  no_argument,       0,              'P'},
-    {(char* const) "no-alpha",                no_argument,       &master_alpha,  0},
-    {(char* const) "no-thumb-alpha",          no_argument,       &thumb_alpha,   0},
-    {(char* const) "list-encoders",           no_argument,       &list_encoders, 1},
-    {(char* const) "encoder",                 no_argument,       0,              'e'},
-    {(char* const) "bit-depth",               required_argument, 0,              'b'},
-    {(char* const) "even-size",               no_argument,       0,              'E'},
-    {(char* const) "avif",                    no_argument,       0,              'A'},
-    {(char* const) "matrix_coefficients",     required_argument, 0,              OPTION_NCLX_MATRIX_COEFFICIENTS},
-    {(char* const) "colour_primaries",        required_argument, 0,              OPTION_NCLX_COLOUR_PRIMARIES},
-    {(char* const) "transfer_characteristic", required_argument, 0,              OPTION_NCLX_TRANSFER_CHARACTERISTIC},
-    {(char* const) "full_range_flag",         required_argument, 0,              OPTION_NCLX_FULL_RANGE_FLAG},
-    {(char* const) "enable-two-colr-boxes",   no_argument,       &two_colr_boxes, 1},
-    {(char* const) "premultiplied-alpha",     no_argument,       &premultiplied_alpha, 1},
-    {0, 0,                                                       0,              0}
+std::optional<heif_content_light_level> clli;
+struct pixel_aspect_ratio
+{
+  uint32_t h,v;
 };
+std::optional<pixel_aspect_ratio> pasp;
+
+// default to 30 fps
+uint32_t sequence_timebase = 30;
+uint32_t sequence_durations = 1;
+uint32_t sequence_repetitions = 1;
+std::string vmt_metadata_file;
+bool binary_metadata_track = false;
+std::string metadata_track_uri = "vmt:metadata";
+
+int quality = 50;
+bool lossless = false;
+std::string output_filename;
+int logging_level = 0;
+bool option_show_parameters = false;
+int thumbnail_bbox_size = 0;
+int output_bit_depth = 10;
+bool force_enc_av1f = false;
+bool force_enc_avc = false;
+bool force_enc_hevc = false;
+bool force_enc_vvc = false;
+bool force_enc_uncompressed = false;
+bool force_enc_jpeg = false;
+bool force_enc_jpeg2000 = false;
+bool force_enc_htj2k = false;
+bool use_tiling = false;
+bool encode_sequence = false;
+bool option_unif = false;
+bool use_video_handler = false;
+bool option_component_content_ids = false;
+heif_orientation transform = heif_orientation_normal;
+std::string option_mime_item_type;
+std::string option_mime_item_file;
+std::string option_mime_item_name;
+#if HEIF_ENABLE_EXPERIMENTAL_FEATURES
+std::string option_turtle_file;
+bool option_embed_turtle = false;
+#endif
 
-void show_help(const char* argv0)
+enum heif_sequence_gop_structure sequence_gop_structure = heif_sequence_gop_structure_lowdelay;
+int sequence_keyframe_distance_min = 0;
+int sequence_keyframe_distance_max = 0;
+int sequence_max_frames = 0; // 0 -> no maximum
+std::string option_gimi_track_id;
+std::string option_sai_data_file;
+
+#if HEIF_WITH_OMAF
+std::optional<heif_omaf_image_projection> omaf_image_projection;
+#endif
+std::vector<heif_brand2> additional_compatible_brands;
+
+enum heif_output_nclx_color_profile_preset
 {
-  std::cerr << " heif-enc  libheif version: " << heif_get_version() << "\n"
-            << "----------------------------------------\n"
-            << "Usage: heif-enc [options] image.jpeg ...\n"
-            << "\n"
-            << "When specifying multiple source images, they will all be saved into the same HEIF/AVIF file.\n"
-            << "\n"
-            << "When using the x265 encoder, you may pass it any of its parameters by\n"
-            << "prefixing the parameter name with 'x265:'. Hence, to set the 'ctu' parameter,\n"
-            << "you will have to set 'x265:ctu' in libheif (e.g.: -p x265:ctu=64).\n"
-            << "Note that there is no checking for valid parameters when using the prefix.\n"
-            << "\n"
-            << "Options:\n"
-            << "  -h, --help        show help\n"
-            << "  -q, --quality     set output quality (0-100) for lossy compression\n"
-            << "  -L, --lossless    generate lossless output (-q has no effect)\n"
-            << "  -t, --thumb #     generate thumbnail with maximum size # (default: off)\n"
-            << "      --no-alpha    do not save alpha channel\n"
-            << "      --no-thumb-alpha  do not save alpha channel in thumbnail image\n"
-            << "  -o, --output      output filename (optional)\n"
-            << "  -v, --verbose     enable logging output (more -v will increase logging level)\n"
-            << "  -P, --params      show all encoder parameters\n"
-            << "  -b, --bit-depth # bit-depth of generated HEIF/AVIF file when using 16-bit PNG input (default: 10 bit)\n"
-            << "  -p                set encoder parameter (NAME=VALUE)\n"
-            << "  -A, --avif        encode as AVIF\n"
-            << "      --list-encoders   list all available encoders for the selected output format\n"
-            << "  -e, --encoder     ID select encoder to use (the IDs can be listed with --list-encoders)\n"
-            << "  -E, --even-size   [deprecated] crop images to even width and height (odd sizes are not decoded correctly by some software)\n"
-            << "  --matrix_coefficients     nclx profile: color conversion matrix coefficients, default=6 (see h.273)\n"
-            << "  --colour_primaries        nclx profile: color primaries (see h.273)\n"
-            << "  --transfer_characteristic nclx profile: transfer characteristics (see h.273)\n"
-            << "  --full_range_flag         nclx profile: full range flag, default: 1\n"
-            << "  --enable-two-colr-boxes   will write both an ICC and an nclx color profile if both a present\n"
-            << "  --premultiplied-alpha     input image has premultiplied alpha\n"
-            << "\n"
-            << "Note: to get lossless encoding, you need this set of options:\n"
-            << "  -L                       switch encoder to lossless mode\n"
-            << "  -p chroma=444            switch off color subsampling\n"
-            << "  --matrix_coefficients=0  encode in RGB color-space\n";
-}
+  heif_output_nclx_color_profile_preset_custom,  // Default. Use the values provided by the user.
+  heif_output_nclx_color_profile_preset_automatic,  // Choose the profile depending on the input.
+  heif_output_nclx_color_profile_preset_compatible, // Choose a profile that is decoded correctly by most systems.
+  heif_output_nclx_color_profile_preset_Rec_601,  // SD / JPEG / MPEG
+  heif_output_nclx_color_profile_preset_Rec_709,  // HDTV / (sRGB)
+  heif_output_nclx_color_profile_preset_Rec_2020  // UHDTV
+};
 
+heif_output_nclx_color_profile_preset output_color_profile_preset = heif_output_nclx_color_profile_preset_custom;
 
-#if HAVE_LIBJPEG
 
-static bool JPEGMarkerIsIcc(jpeg_saved_marker_ptr marker)
-{
-  return
-      marker->marker == JPEG_ICC_MARKER &&
-      marker->data_length >= JPEG_ICC_OVERHEAD_LEN &&
-      /* verify the identifying string */
-      GETJOCTET(marker->data[0]) == 0x49 &&
-      GETJOCTET(marker->data[1]) == 0x43 &&
-      GETJOCTET(marker->data[2]) == 0x43 &&
-      GETJOCTET(marker->data[3]) == 0x5F &&
-      GETJOCTET(marker->data[4]) == 0x50 &&
-      GETJOCTET(marker->data[5]) == 0x52 &&
-      GETJOCTET(marker->data[6]) == 0x4F &&
-      GETJOCTET(marker->data[7]) == 0x46 &&
-      GETJOCTET(marker->data[8]) == 0x49 &&
-      GETJOCTET(marker->data[9]) == 0x4C &&
-      GETJOCTET(marker->data[10]) == 0x45 &&
-      GETJOCTET(marker->data[11]) == 0x0;
-}
+std::string property_pitm_description;
 
-boolean ReadICCProfileFromJPEG(j_decompress_ptr cinfo,
-                               JOCTET** icc_data_ptr,
-                               unsigned int* icc_data_len)
+RawImageParameters raw_input_params;
+bool force_raw_input = false;
+
+std::optional<long> parse_int(const char* s)
 {
-  jpeg_saved_marker_ptr marker;
-  int num_markers = 0;
-  int seq_no;
-  JOCTET* icc_data;
-  unsigned int total_length;
-#define MAX_SEQ_NO  255        /* sufficient since marker numbers are bytes */
-  char marker_present[MAX_SEQ_NO + 1];      /* 1 if marker found */
-  unsigned int data_length[MAX_SEQ_NO + 1]; /* size of profile data in marker */
-  unsigned int data_offset[MAX_SEQ_NO + 1]; /* offset for data in marker */
-
-  *icc_data_ptr = NULL;        /* avoid confusion if FALSE return */
-  *icc_data_len = 0;
-
-  /* This first pass over the saved markers discovers whether there are
-   * any ICC markers and verifies the consistency of the marker numbering.
-   */
-
-  for (seq_no = 1; seq_no <= MAX_SEQ_NO; seq_no++)
-    marker_present[seq_no] = 0;
-
-  for (marker = cinfo->marker_list; marker != NULL; marker = marker->next) {
-    if (JPEGMarkerIsIcc(marker)) {
-      if (num_markers == 0)
-        num_markers = GETJOCTET(marker->data[13]);
-      else if (num_markers != GETJOCTET(marker->data[13]))
-        return FALSE;        /* inconsistent num_markers fields */
-      seq_no = GETJOCTET(marker->data[12]);
-      if (seq_no <= 0 || seq_no > num_markers)
-        return FALSE;        /* bogus sequence number */
-      if (marker_present[seq_no])
-        return FALSE;        /* duplicate sequence numbers */
-      marker_present[seq_no] = 1;
-      data_length[seq_no] = marker->data_length - JPEG_ICC_OVERHEAD_LEN;
-    }
-  }
-
-  if (num_markers == 0)
-    return FALSE;
-
-  /* Check for missing markers, count total space needed,
-   * compute offset of each marker's part of the data.
-   */
-
-  total_length = 0;
-  for (seq_no = 1; seq_no <= num_markers; seq_no++) {
-    if (marker_present[seq_no] == 0)
-      return FALSE;        /* missing sequence number */
-    data_offset[seq_no] = total_length;
-    total_length += data_length[seq_no];
-  }
-
-  if (total_length <= 0)
-    return FALSE;        /* found only empty markers? */
-
-  /* Allocate space for assembled data */
-  icc_data = (JOCTET*) malloc(total_length * sizeof(JOCTET));
-  if (icc_data == NULL)
-    return FALSE;        /* oops, out of memory */
-
-  /* and fill it in */
-  for (marker = cinfo->marker_list; marker != NULL; marker = marker->next) {
-    if (JPEGMarkerIsIcc(marker)) {
-      JOCTET FAR* src_ptr;
-      JOCTET* dst_ptr;
-      unsigned int length;
-      seq_no = GETJOCTET(marker->data[12]);
-      dst_ptr = icc_data + data_offset[seq_no];
-      src_ptr = marker->data + JPEG_ICC_OVERHEAD_LEN;
-      length = data_length[seq_no];
-      while (length--) {
-        *dst_ptr++ = *src_ptr++;
-      }
-    }
+  char* end;
+  long val = strtol(s, &end, 10);
+  if (*end != '\0' || end == s) {
+    return {};
   }
-
-  *icc_data_ptr = icc_data;
-  *icc_data_len = total_length;
-
-  return TRUE;
+  return val;
 }
 
 
-std::shared_ptr<heif_image> loadJPEG(const char* filename)
-{
-  struct heif_image* image = nullptr;
+// for benchmarking
 
+#if !defined(_MSC_VER)
+#define HAVE_GETTIMEOFDAY 1  // TODO: should be set by CMake
+#endif
+
+#if HAVE_GETTIMEOFDAY
+#include <sys/time.h>
+timeval time_encoding_start;
+timeval time_encoding_end;
+#endif
 
-  // ### Code copied from LibVideoGfx and slightly modified to use HeifPixelImage
+const int OPTION_NCLX_MATRIX_COEFFICIENTS = 1000;
+const int OPTION_NCLX_COLOUR_PRIMARIES = 1001;
+const int OPTION_NCLX_TRANSFER_CHARACTERISTIC = 1002;
+const int OPTION_NCLX_FULL_RANGE_FLAG = 1003;
+const int OPTION_PLUGIN_DIRECTORY = 1004;
+const int OPTION_PITM_DESCRIPTION = 1005;
+const int OPTION_USE_JPEG_COMPRESSION = 1006;
+const int OPTION_USE_JPEG2000_COMPRESSION = 1007;
+const int OPTION_VERBOSE = 1008;
+const int OPTION_USE_HTJ2K_COMPRESSION = 1009;
+const int OPTION_USE_VVC_COMPRESSION = 1010;
+const int OPTION_TILED_IMAGE_WIDTH = 1011;
+const int OPTION_TILED_IMAGE_HEIGHT = 1012;
+const int OPTION_TILING_METHOD = 1013;
+const int OPTION_UNCI_COMPRESSION = 1014;
+const int OPTION_CUT_TILES = 1015;
+const int OPTION_SEQUENCES_TIMEBASE = 1016;
+const int OPTION_SEQUENCES_DURATIONS = 1017;
+const int OPTION_SEQUENCES_FPS = 1018;
+const int OPTION_VMT_METADATA_FILE = 1019;
+const int OPTION_SEQUENCES_REPETITIONS = 1020;
+const int OPTION_COLOR_PROFILE_PRESET = 1021;
+const int OPTION_SET_CLLI = 1022;
+const int OPTION_SET_PASP = 1023;
+const int OPTION_SEQUENCES_GOP_STRUCTURE = 1024;
+const int OPTION_SEQUENCES_MIN_KEYFRAME_DISTANCE = 1025;
+const int OPTION_SEQUENCES_MAX_KEYFRAME_DISTANCE = 1026;
+const int OPTION_SEQUENCES_MAX_FRAMES = 1027;
+const int OPTION_USE_AVC_COMPRESSION = 1028;
+const int OPTION_BINARY_METADATA_TRACK = 1029;
+const int OPTION_METADATA_TRACK_URI = 1030;
+const int OPTION_ADD_MIME_ITEM = 1031;
+const int OPTION_MIME_ITEM_FILE = 1032;
+const int OPTION_MIME_ITEM_NAME = 1033;
+const int OPTION_METADATA_COMPRESSION = 1034;
+const int OPTION_SEQUENCES_GIMI_TRACK_ID = 1035;
+const int OPTION_SEQUENCES_SAI_DATA_FILE = 1036;
+const int OPTION_USE_HEVC_COMPRESSION = 1037;
+#if HEIF_WITH_OMAF
+const int OPTION_SET_OMAF_IMAGE_PROJECTION = 1038;
+#endif
+const int OPTION_ADD_COMPATIBLE_BRAND = 1039;
+const int OPTION_UNIF = 1040;
+const int OPTION_RAW_WIDTH = 1041;
+const int OPTION_RAW_HEIGHT = 1042;
+const int OPTION_RAW_TYPE = 1043;
+const int OPTION_RAW_ENDIAN = 1044;
+const int OPTION_RAW = 1045;
+const int OPTION_DO_ROTATE = 1046;
+const int OPTION_DO_FLIP_H = 1047;
+const int OPTION_DO_FLIP_V = 1048;
+
+
+#if HEIF_ENABLE_EXPERIMENTAL_FEATURES
+const int OPTION_TURTLE = 2000;
+const int OPTION_EMBED_TURTLE = 2001;
+#endif
 
-  struct jpeg_decompress_struct cinfo;
-  struct jpeg_error_mgr jerr;
+const int OPTION_COMPONENT_CONTENT_IDS = 2002;
 
-  // to store embedded icc profile
-  uint32_t iccLen;
-  uint8_t* iccBuffer = NULL;
 
-  // open input file
+static std::string generate_random_uuid_urn()
+{
+  std::random_device rd;
+  std::mt19937 gen(rd());
+  std::uniform_int_distribution<uint32_t> dist(0, 0xFFFFFFFF);
 
-  FILE* infile;
-  if ((infile = fopen(filename, "rb")) == NULL) {
-    std::cerr << "Can't open " << filename << "\n";
-    exit(1);
+  uint32_t data[4];
+  for (auto& d : data) {
+    d = dist(gen);
   }
 
+  auto* bytes = reinterpret_cast<uint8_t*>(data);
+
+  // Set version 4 (random) and variant 1 (RFC 4122)
+  bytes[6] = (bytes[6] & 0x0F) | 0x40;
+  bytes[8] = (bytes[8] & 0x3F) | 0x80;
+
+  char buf[64];
+  snprintf(buf, sizeof(buf),
+           "urn:uuid:%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
+           bytes[0], bytes[1], bytes[2], bytes[3],
+           bytes[4], bytes[5],
+           bytes[6], bytes[7],
+           bytes[8], bytes[9],
+           bytes[10], bytes[11], bytes[12], bytes[13], bytes[14], bytes[15]);
+  return buf;
+}
 
-  // initialize decompressor
-
-  jpeg_create_decompress(&cinfo);
 
-  cinfo.err = jpeg_std_error(&jerr);
-  jpeg_stdio_src(&cinfo, infile);
+#if HEIF_ENABLE_EXPERIMENTAL_FEATURES
+struct TurtleContentIDs {
+  std::string image_content_id;
+  // key: {layer, tx, ty}
+  std::map<std::tuple<int, int, int>, std::string> tile_content_ids;
+};
 
-  /* Adding this part to prepare for icc profile reading. */
-  jpeg_save_markers(&cinfo, JPEG_APP0 + 2, 0xFFFF);
 
-  jpeg_read_header(&cinfo, TRUE);
+enum class TurtlePendingType {
+  none,
+  image,
+  tile
+};
 
-  boolean embeddedIccFlag = ReadICCProfileFromJPEG(&cinfo, &iccBuffer, &iccLen);
 
-  if (cinfo.jpeg_color_space == JCS_GRAYSCALE) {
-    cinfo.out_color_space = JCS_GRAYSCALE;
+TurtleContentIDs parse_turtle_content_ids(const std::string& filename)
+{
+  TurtleContentIDs result;
 
-    jpeg_start_decompress(&cinfo);
+  std::ifstream file(filename);
+  if (!file) {
+    std::cerr << "Warning: could not open turtle file: " << filename << "\n";
+    return result;
+  }
 
-    JSAMPARRAY buffer;
-    buffer = (*cinfo.mem->alloc_sarray)
-        ((j_common_ptr) &cinfo, JPOOL_IMAGE, cinfo.output_width * cinfo.output_components, 1);
+  std::string line;
+  TurtlePendingType pending_type = TurtlePendingType::none;
+  int pending_layer = 0, pending_tx = 0, pending_ty = 0;
 
+  while (std::getline(file, line)) {
+    // trim leading whitespace
+    size_t start = line.find_first_not_of(" \t");
+    if (start == std::string::npos) {
+      continue; // empty line
+    }
+    line = line.substr(start);
 
-    // create destination image
+    if (line.rfind("# image", 0) == 0) {
+      pending_type = TurtlePendingType::image;
+    }
+    else if (line.rfind("# tile ", 0) == 0) {
+      if (sscanf(line.c_str(), "# tile %d %d %d", &pending_layer, &pending_tx, &pending_ty) == 3) {
+        pending_type = TurtlePendingType::tile;
+      }
+    }
+    else if (pending_type != TurtlePendingType::none && line[0] == '<') {
+      // extract URI between < and >
+      auto close = line.find('>');
+      if (close != std::string::npos) {
+        std::string uri = line.substr(1, close - 1);
+        if (pending_type == TurtlePendingType::image) {
+          result.image_content_id = uri;
+        }
+        else if (pending_type == TurtlePendingType::tile) {
+          result.tile_content_ids[{pending_layer, pending_tx, pending_ty}] = uri;
+        }
+      }
+      pending_type = TurtlePendingType::none;
+    }
+  }
 
-    struct heif_error err = heif_image_create(cinfo.output_width, cinfo.output_height,
-                                              heif_colorspace_monochrome,
-                                              heif_chroma_monochrome,
-                                              &image);
-    (void) err;
-    // TODO: handle error
+  return result;
+}
+#endif
 
-    heif_image_add_plane(image, heif_channel_Y, cinfo.output_width, cinfo.output_height, 8);
+static option long_options[] = {
+    {(char* const) "help",                    no_argument,       0,              'h'},
+    {(char* const) "version",                 no_argument,       0,              'v'},
+    {(char* const) "quality",                 required_argument, 0,              'q'},
+    {(char* const) "output",                  required_argument, 0,              'o'},
+    {(char* const) "lossless",                no_argument,       0,              'L'},
+    {(char* const) "thumb",                   required_argument, 0,              't'},
+    {(char* const) "verbose",                 no_argument,       0,              OPTION_VERBOSE},
+    {(char* const) "params",                  no_argument,       0,              'P'},
+    {(char* const) "no-alpha",                no_argument,       &master_alpha,  0},
+    {(char* const) "no-thumb-alpha",          no_argument,       &thumb_alpha,   0},
+    {(char* const) "list-encoders",           no_argument,       &list_encoders, 1},
+    {(char* const) "encoder",                 required_argument, 0,              'e'},
+    {(char* const) "bit-depth",               required_argument, 0,              'b'},
+    {(char* const) "even-size",               no_argument,       0,              'E'},
+    {(char* const) "avif",                    no_argument,       0,              'A'},
+    {(char* const) "hevc",                    no_argument,       0,              OPTION_USE_HEVC_COMPRESSION},
+    {(char* const) "vvc",                     no_argument,       0,              OPTION_USE_VVC_COMPRESSION},
+    {(char* const) "avc",                     no_argument,       0,              OPTION_USE_AVC_COMPRESSION},
+    {(char* const) "jpeg",                    no_argument,       0,              OPTION_USE_JPEG_COMPRESSION},
+    {(char* const) "jpeg2000",                no_argument,       0,              OPTION_USE_JPEG2000_COMPRESSION},
+    {(char* const) "htj2k",                   no_argument,       0,              OPTION_USE_HTJ2K_COMPRESSION},
+#if WITH_UNCOMPRESSED_CODEC
+    {(char* const) "uncompressed",                no_argument,       0,                     'U'},
+    {(char* const) "unci-compression-method",     required_argument, nullptr, OPTION_UNCI_COMPRESSION},
+#if HEIF_ENABLE_EXPERIMENTAL_FEATURES
+    {(char* const) "component-content-ids",       no_argument,       nullptr, OPTION_COMPONENT_CONTENT_IDS},
+#endif
+#endif
+    {(char* const) "color-profile",               required_argument, 0,                     OPTION_COLOR_PROFILE_PRESET},
+    {(char* const) "matrix_coefficients",         required_argument, 0,                     OPTION_NCLX_MATRIX_COEFFICIENTS},
+    {(char* const) "colour_primaries",            required_argument, 0,                     OPTION_NCLX_COLOUR_PRIMARIES},
+    {(char* const) "transfer_characteristic",     required_argument, 0,                     OPTION_NCLX_TRANSFER_CHARACTERISTIC},
+    {(char* const) "full_range_flag",             required_argument, 0,                     OPTION_NCLX_FULL_RANGE_FLAG},
+    {(char* const) "enable-two-colr-boxes",       no_argument,       &two_colr_boxes,       1},
+    {(char* const) "clli",                        required_argument, 0,                     OPTION_SET_CLLI},
+    {(char* const) "pasp",                        required_argument, 0,                     OPTION_SET_PASP},
+    {(char* const) "premultiplied-alpha",         no_argument,       &premultiplied_alpha,  1},
+    {(char* const) "rotate-cw",                   required_argument, 0,                     OPTION_DO_ROTATE},
+    {(char* const) "flip-h",                      no_argument,       0,                     OPTION_DO_FLIP_H},
+    {(char* const) "flip-v",                      no_argument,       0,                     OPTION_DO_FLIP_V},
+    {(char* const) "plugin-directory",            required_argument, 0,                     OPTION_PLUGIN_DIRECTORY},
+    {(char* const) "benchmark",                   no_argument,       &run_benchmark,        1},
+    {(char* const) "enable-metadata-compression", required_argument, 0, OPTION_METADATA_COMPRESSION},
+    {(char* const) "pitm-description",            required_argument, 0,                     OPTION_PITM_DESCRIPTION},
+    {(char* const) "chroma-downsampling",         required_argument, 0, 'C'},
+    {(char* const) "cut-tiles",                   required_argument, nullptr, OPTION_CUT_TILES},
+    {(char* const) "tiled-input",                 no_argument, 0, 'T'},
+    {(char* const) "tiled-image-width",           required_argument, nullptr, OPTION_TILED_IMAGE_WIDTH},
+    {(char* const) "tiled-image-height",          required_argument, nullptr, OPTION_TILED_IMAGE_HEIGHT},
+    {(char* const) "tiled-input-x-y",             no_argument,       &tiled_input_x_y, 1},
+    {(char* const) "tiling-method",               required_argument, nullptr, OPTION_TILING_METHOD},
+    {(char* const) "add-pyramid-group",           no_argument,       &add_pyramid_group, 1},
+    {(char* const) "sequence",                    no_argument, 0, 'S'},
+    {(char* const) "video",                       no_argument, 0, 'V'},
+    {(char* const) "timebase",                    required_argument,       nullptr, OPTION_SEQUENCES_TIMEBASE},
+    {(char* const) "duration",                    required_argument,       nullptr, OPTION_SEQUENCES_DURATIONS},
+    {(char* const) "fps",                         required_argument,       nullptr, OPTION_SEQUENCES_FPS},
+    {(char* const) "repetitions",                 required_argument,       nullptr, OPTION_SEQUENCES_REPETITIONS},
+    {(char* const) "max-frames",                  required_argument,       nullptr, OPTION_SEQUENCES_MAX_FRAMES},
+#if HEIF_ENABLE_EXPERIMENTAL_FEATURES
+    {(char* const) "vmt-metadata",                required_argument,       nullptr, OPTION_VMT_METADATA_FILE},
+    {(char* const) "binary-metadata-track",       no_argument,             nullptr, OPTION_BINARY_METADATA_TRACK},
+    {(char* const) "metadata-track-uri",          required_argument,       nullptr, OPTION_METADATA_TRACK_URI},
+    {(char* const) "add-mime-item",               required_argument,       nullptr, OPTION_ADD_MIME_ITEM},
+    {(char* const) "mime-item-file",              required_argument,       nullptr, OPTION_MIME_ITEM_FILE},
+    {(char* const) "mime-item-name",              required_argument,       nullptr, OPTION_MIME_ITEM_NAME},
+    {(char* const) "turtle",                      required_argument,       nullptr, OPTION_TURTLE},
+    {(char* const) "embed-turtle",               no_argument,             nullptr, OPTION_EMBED_TURTLE},
+#endif
+    {(char* const) "gop-structure",               required_argument,       nullptr, OPTION_SEQUENCES_GOP_STRUCTURE},
+    {(char* const) "min-keyframe-distance",       required_argument,       nullptr, OPTION_SEQUENCES_MIN_KEYFRAME_DISTANCE},
+    {(char* const) "max-keyframe-distance",       required_argument,       nullptr, OPTION_SEQUENCES_MAX_KEYFRAME_DISTANCE},
+    {(char* const) "set-gimi-track-id",           required_argument,       nullptr, OPTION_SEQUENCES_GIMI_TRACK_ID},
+    {(char* const) "sai-data-file",               required_argument,       nullptr, OPTION_SEQUENCES_SAI_DATA_FILE},
+#if HEIF_WITH_OMAF
+    {(char* const) "omaf-image-projection",       required_argument,       nullptr, OPTION_SET_OMAF_IMAGE_PROJECTION},
+#endif
+    {(char* const) "add-compatible-brand",        required_argument,       nullptr, OPTION_ADD_COMPATIBLE_BRAND},
+    {(char* const) "unif",                      no_argument,             nullptr, OPTION_UNIF},
+    {(char* const) "raw",                    no_argument,             nullptr, OPTION_RAW},
+    {(char* const) "raw-width",               required_argument,       nullptr, OPTION_RAW_WIDTH},
+    {(char* const) "raw-height",              required_argument,       nullptr, OPTION_RAW_HEIGHT},
+    {(char* const) "raw-type",                required_argument,       nullptr, OPTION_RAW_TYPE},
+    {(char* const) "raw-endian",              required_argument,       nullptr, OPTION_RAW_ENDIAN},
+    {0, 0,                                                           0,  0}
+};
 
-    int y_stride;
-    uint8_t* py = heif_image_get_plane(image, heif_channel_Y, &y_stride);
 
+void show_help(const char* argv0)
+{
+  std::filesystem::path p(argv0);
+  std::string filename = p.filename().string();
 
-    // read the image
+  std::stringstream sstr;
+  sstr << " " << filename << "  libheif version: " << heif_get_version();
 
-    while (cinfo.output_scanline < cinfo.output_height) {
-      (void) jpeg_read_scanlines(&cinfo, buffer, 1);
+  std::string title = sstr.str();
 
-      memcpy(py + (cinfo.output_scanline - 1) * y_stride, *buffer, cinfo.output_width);
-    }
+  std::cerr << title << "\n"
+            << std::string(title.length() + 1, '-') << "\n"
+            << "Usage: " << filename << " [options] <input-image> ...\n"
+            << "\n"
+            << "When specifying multiple source images, they will all be saved into the same HEIF/AVIF file.\n"
+            << "\n"
+            << "Some encoders (x265, aom) let you pass-through any parameters by prefixing them with the encoder name.\n"
+            << "For example, you may pass any x265 parameter by prefixing it with 'x265:'. For example, to set\n"
+            << "the 'ctu' parameter, you will have to set 'x265:ctu' in libheif (e.g.: -p x265:ctu=64).\n"
+            << "Note that when using the prefix, libheif cannot tell you which parameters and values are supported.\n"
+            << "\n"
+            << "Options:\n"
+            << "  -h, --help                     show help\n"
+            << "  -v, --version                  show version\n"
+            << "  -o, --output                   output filename (optional)\n"
+            << "  -q, --quality                  set output quality (0-100) for lossy compression\n"
+            << "  -L, --lossless                 generate lossless output (-q has no effect). Image will be encoded as RGB (matrix_coefficients=0).\n"
+            << "  -t, --thumb #                  generate thumbnail with maximum size # (default: off)\n"
+            << "      --no-alpha                 do not save alpha channel\n"
+            << "      --no-thumb-alpha           do not save alpha channel in thumbnail image\n"
+            << "      --verbose                  enable logging output (more will increase logging level)\n"
+            << "  -b, --bit-depth #              number of bits to use from an 16-bit PNG input, valid range: 9-16 (default: 10 bit)\n"
+            << "      --premultiplied-alpha      input image has premultiplied alpha\n"
+#if WITH_HEADER_COMPRESSION
+            << "      --enable-metadata-compression ALGO  enable metadata item compression (experimental)\n"
+            << "                                          Choose algorithm from {off"; // TODO: add 'auto', but it currently equals 'off'
+  if (heif_metadata_compression_method_supported(heif_metadata_compression_deflate)) {
+    std::cerr << ",deflate,zlib";
   }
-  else {
-    cinfo.out_color_space = JCS_YCbCr;
+  if (heif_metadata_compression_method_supported(heif_metadata_compression_brotli)) {
+    std::cerr << ",brotli";
+  }
+  std::cerr << "}.\n"
+#endif
+            << "  -C, --chroma-downsampling ALGO    force chroma downsampling algorithm (nn = nearest-neighbor / average / sharp-yuv)\n"
+            << "                                    (sharp-yuv makes edges look sharper when using YUV420 with bilinear chroma upsampling)\n"
+            << "      --benchmark                   measure encoding time, PSNR, and output file size\n"
+            << "      --pitm-description TEXT       set user description for primary image (experimental)\n"
+#if HEIF_ENABLE_EXPERIMENTAL_FEATURES
+            << "      --add-mime-item TYPE       add a mime item of the specified content type (experimental)\n"
+            << "      --mime-item-file FILE      use the specified FILE as the data to put into the mime item (experimental)\n"
+            << "      --mime-item-name NAME      assign the name to the embedded item (experimental)\n"
+            << "      --turtle FILENAME          read Turtle (RDF) file and assign GIMI content IDs to tiles (experimental)\n"
+            << "      --embed-turtle             also embed the Turtle file as metadata item in the HEIF (experimental)\n"
+#endif
+            << "      --add-compatible-brand BRAND  add a compatible brand to the output file (4 characters)\n"
+            << "      --unif                        use unified ID namespace (adds 'unif' compatible brand)\n"
+            << "\n"
+            << "codecs:\n"
+            << "  -A, --avif                     encode as AVIF (not needed if output filename with .avif suffix is provided)\n"
+            << "      --hevc                     encode as HEVC (default)\n"
+            << "      --vvc                      encode as VVC (experimental)\n"
+            << "      --avc                      encode as AVC (experimental)\n"
+            << "      --jpeg                     encode as JPEG\n"
+            << "      --jpeg2000                 encode as JPEG 2000 (experimental)\n"
+            << "      --htj2k                    encode as High Throughput JPEG 2000 (experimental)\n"
+#if WITH_UNCOMPRESSED_CODEC
+            << "  -U, --uncompressed             encode as uncompressed image (according to ISO 23001-17) (EXPERIMENTAL)\n"
+            << "      --unci-compression METHOD  choose one of these methods: none, deflate, zlib, brotli.\n"
+#endif
+            << "      --list-encoders            list all available encoders for all compression formats\n"
+            << "  -e, --encoder ID               select encoder to use (the IDs can be listed with --list-encoders)\n"
+            << "      --plugin-directory DIR     load all codec plugins in the directory\n"
+            << "  -P, --params                   show all encoder parameters and exit, input file not required or used.\n"
+            << "  -p NAME=VALUE                  set encoder parameter\n"
+            << "\n"
+            << "raw input:\n"
+            << "      --raw                      force raw pixel data input (for files without .raw/.img suffix)\n"
+            << "      --raw-width #              width of raw input image (computed from file size if omitted)\n"
+            << "      --raw-height #             height of raw input image (computed from file size if omitted)\n"
+            << "      --raw-type TYPE            pixel data type: uint8, sint8, uint16, sint16, uint32, sint32, float32, float64\n"
+            << "      --raw-endian ENDIAN        byte order of input data: little (default), big\n"
+            << "\n"
+            << "color profile:\n"
+            << "      --color-profile NAME       use a color profile preset for the output. Valid values are:\n"
+            << "                                    custom:     (default) use the provided matrix_coefficients, colour_primaries, transfer_characteristic\n"
+            << "                                    auto:       automatically guess suitable values from the input image characteristics\n"
+            << "                                    compatible: use a profile that is decoded correctly by most applications by avoiding incomplete implementations\n"
+            << "                                    601:        use Rec.601 (SD), close to JPEG\n"
+            << "                                    709:        use Rec.709 (HDTV), close to sRGB\n"
+            << "                                    2020:       use Rec.2020 (UHDTV), transfer curve will be selected based on bits per pixel\n"
+            << "      --matrix_coefficients     nclx profile: color conversion matrix coefficients, default=6 (see h.273)\n"
+            << "      --colour_primaries        nclx profile: color primaries (see h.273)\n"
+            << "      --transfer_characteristic nclx profile: transfer characteristics (see h.273)\n"
+            << "      --full_range_flag         nclx profile: full range flag, default: 1\n"
+            << "      --enable-two-colr-boxes   will write both an ICC and an nclx color profile if both are present\n"
+            << "      --clli MaxCLL,MaxPALL     add 'content light level information' property to all encoded images\n"
+            << "      --pasp h,v                set pixel aspect ratio property to all encoded images\n"
+            << "      --rotate-cw #             rotate input image by 0, 90, 180, 270 degrees (clock-wise)\n"
+            << "      --flip-h / --flip-v       flip input image horizontally or vertically\n"
+            << "\n"
+            << "tiling:\n"
+            << "      --cut-tiles #             cuts the input image into square tiles of the given width\n"
+            << "  -T, --tiled-input             input is a set of tile images (only provide one filename with two tile position numbers).\n"
+            << "                                For example, 'tile-01-05.jpg' would be a valid input filename.\n"
+            << "                                You only have to provide the filename of one tile as input, heif-enc will scan the directory\n"
+            << "                                for the other tiles and determine the range of tiles automatically.\n"
+            << "      --tiled-image-width #     override image width of tiled image\n"
+            << "      --tiled-image-height #    override image height of tiled image\n"
+            << "      --tiled-input-x-y         usually, the first number in the input tile filename should be the y position.\n"
+            << "                                With this option, this can be swapped so that the first number is x, the second number y.\n"
+#if HEIF_ENABLE_EXPERIMENTAL_FEATURES || WITH_UNCOMPRESSED_CODEC
+            << "      --tiling-method METHOD    choose one of these methods: grid"
+#if HEIF_ENABLE_EXPERIMENTAL_FEATURES
+               ", tili (experimental)"
+#endif
+#if WITH_UNCOMPRESSED_CODEC
+               ", unci"
+#endif
+               ". The default is 'grid'.\n"
+#endif
+#if HEIF_ENABLE_EXPERIMENTAL_FEATURES
+            << "      --add-pyramid-group       when several images are given, put them into a multi-resolution pyramid group. (experimental)\n"
+#endif
+            << "\n"
+            << "sequences:\n"
+            << "  -S, --sequence                 encode input images as sequence (input filenames with a number will pull in all files with this pattern).\n"
+            << "  -V, --video                    encode as video instead of image sequence\n"
+            << "      --timebase #               set clock ticks/second for sequence\n"
+            << "      --duration #               set frame duration (default: 1)\n"
+            << "      --fps #                    set timebase and duration based on fps\n"
+            << "      --repetitions #            set how often the sequence should be played back (default=1), special value: 'infinite'\n"
+            << "      --gop-structure GOP        frame types to use in GOP (intra-only, low-delay, unrestricted)\n"
+            << "      --min-keyframe-distance #  minimum distance of keyframes in sequence (0 = undefined)\n"
+            << "      --max-keyframe-distance #  maximum distance of keyframes in sequence (0 = undefined)\n"
+            << "      --max-frames #             limit sequence length to maximum number of frames\n"
+#if HEIF_ENABLE_EXPERIMENTAL_FEATURES
+            << "      --vmt-metadata FILE        encode metadata track from VMT file (experimental)\n"
+            << "      --binary-metadata-track    parses VMT data as hex values that are written as raw binary (experimental)\n"
+            << "      --metadata-track-uri URI   uses the URI identifier for the metadata track (experimental)\n"
+            << "      --set-gimi-track-id ID     set the GIMI track ID for the visual track (experimental)\n"
+            << "      --sai-data-file FILE       use the specified FILE as input data for the video frames SAI data\n"
+#endif
+#if HEIF_WITH_OMAF
+            << "omnidirectional imagery:\n"
+            << "      --omaf-image-projection PROJ    set the image projection (equirectangular, cube-map)\n"
+#endif
+            ;
+}
+
+
+void list_encoder_parameters(heif_encoder* encoder)
+{
+  std::cerr << "Parameters for encoder `" << heif_encoder_get_name(encoder) << "`:\n";
 
-    jpeg_start_decompress(&cinfo);
+  const heif_encoder_parameter* const* params = heif_encoder_list_parameters(encoder);
+  for (int i = 0; params[i]; i++) {
+    const char* name = heif_encoder_parameter_get_name(params[i]);
 
-    JSAMPARRAY buffer;
-    buffer = (*cinfo.mem->alloc_sarray)
-        ((j_common_ptr) &cinfo, JPOOL_IMAGE, cinfo.output_width * cinfo.output_components, 1);
+    switch (heif_encoder_parameter_get_type(params[i])) {
+      case heif_encoder_parameter_type_integer: {
+        heif_error error;
 
+        std::cerr << "  " << name;
 
-    // create destination image
+        if (heif_encoder_has_default(encoder, name)) {
+          int value;
+          error = heif_encoder_get_parameter_integer(encoder, name, &value);
+          (void) error;
 
-    struct heif_error err = heif_image_create(cinfo.output_width, cinfo.output_height,
-                                              heif_colorspace_YCbCr,
-                                              heif_chroma_420,
-                                              &image);
-    (void) err;
+          std::cerr << ", default=" << value;
+        }
 
-    heif_image_add_plane(image, heif_channel_Y, cinfo.output_width, cinfo.output_height, 8);
-    heif_image_add_plane(image, heif_channel_Cb, (cinfo.output_width + 1) / 2, (cinfo.output_height + 1) / 2, 8);
-    heif_image_add_plane(image, heif_channel_Cr, (cinfo.output_width + 1) / 2, (cinfo.output_height + 1) / 2, 8);
+        int have_minimum, have_maximum, minimum, maximum, num_valid_values;
+        const int* valid_values = nullptr;
+        error = heif_encoder_parameter_integer_valid_values(encoder, name,
+                                                            &have_minimum, &have_maximum,
+                                                            &minimum, &maximum,
+                                                            &num_valid_values,
+                                                            &valid_values);
 
-    int y_stride;
-    int cb_stride;
-    int cr_stride;
-    uint8_t* py = heif_image_get_plane(image, heif_channel_Y, &y_stride);
-    uint8_t* pcb = heif_image_get_plane(image, heif_channel_Cb, &cb_stride);
-    uint8_t* pcr = heif_image_get_plane(image, heif_channel_Cr, &cr_stride);
+        if (have_minimum || have_maximum) {  // TODO: only one is set
+          std::cerr << ", [" << minimum << ";" << maximum << "]";
+        }
 
-    // read the image
+        if (num_valid_values > 0) {
+          std::cerr << ", {";
 
-    //printf("jpeg size: %d %d\n",cinfo.output_width, cinfo.output_height);
+          for (int p = 0; p < num_valid_values; p++) {
+            if (p > 0) {
+              std::cerr << ", ";
+            }
 
-    while (cinfo.output_scanline < cinfo.output_height) {
-      JOCTET* bufp;
+            std::cerr << valid_values[p];
+          }
 
-      (void) jpeg_read_scanlines(&cinfo, buffer, 1);
+          std::cerr << "}";
+        }
 
-      bufp = buffer[0];
+        std::cerr << "\n";
+      }
+        break;
 
-      int y = cinfo.output_scanline - 1;
+      case heif_encoder_parameter_type_boolean: {
+        heif_error error;
+        std::cerr << "  " << name;
 
-      for (unsigned int x = 0; x < cinfo.output_width; x += 2) {
-        py[y * y_stride + x] = *bufp++;
-        pcb[y / 2 * cb_stride + x / 2] = *bufp++;
-        pcr[y / 2 * cr_stride + x / 2] = *bufp++;
+        if (heif_encoder_has_default(encoder, name)) {
+          int value;
+          error = heif_encoder_get_parameter_boolean(encoder, name, &value);
+          (void) error;
 
-        if (x + 1 < cinfo.output_width) {
-          py[y * y_stride + x + 1] = *bufp++;
+          std::cerr << ", default=" << (value ? "true" : "false");
         }
 
-        bufp += 2;
+        std::cerr << "\n";
       }
+        break;
 
+      case heif_encoder_parameter_type_string: {
+        heif_error error;
+        std::cerr << "  " << name;
 
-      if (cinfo.output_scanline < cinfo.output_height) {
-        (void) jpeg_read_scanlines(&cinfo, buffer, 1);
+        if (heif_encoder_has_default(encoder, name)) {
+          const int value_size = 50;
+          char value[value_size];
+          error = heif_encoder_get_parameter_string(encoder, name, value, value_size);
+          (void) error;
 
-        bufp = buffer[0];
+          std::cerr << ", default=" << value;
+        }
 
-        y = cinfo.output_scanline - 1;
+        const char* const* valid_options;
+        error = heif_encoder_parameter_string_valid_values(encoder, name, &valid_options);
 
-        for (unsigned int x = 0; x < cinfo.output_width; x++) {
-          py[y * y_stride + x] = *bufp++;
-          bufp += 2;
+        if (valid_options) {
+          std::cerr << ", { ";
+          for (int k = 0; valid_options[k]; k++) {
+            if (k > 0) { std::cerr << ","; }
+            std::cerr << valid_options[k];
+          }
+          std::cerr << " }";
         }
+
+        std::cerr << "\n";
       }
+        break;
     }
   }
+}
 
-  if (embeddedIccFlag && iccLen > 0) {
-    heif_image_set_raw_color_profile(image, "prof", iccBuffer, (size_t) iccLen);
-  }
 
-  // cleanup
-  free(iccBuffer);
-  jpeg_finish_decompress(&cinfo);
-  jpeg_destroy_decompress(&cinfo);
+void set_params(heif_encoder* encoder, const std::vector<std::string>& params)
+{
+  for (const std::string& p : params) {
+    auto pos = p.find_first_of('=');
+    if (pos == std::string::npos || pos == 0 || pos == p.size() - 1) {
+      std::cerr << "Encoder parameter must be in the format 'name=value'\n";
+      exit(5);
+    }
 
-  fclose(infile);
+    std::string name = p.substr(0, pos);
+    std::string value = p.substr(pos + 1);
 
-  return std::shared_ptr<heif_image>(image,
-                                     [](heif_image* img) { heif_image_release(img); });
+    struct heif_error error = heif_encoder_set_parameter(encoder, name.c_str(), value.c_str());
+    if (error.code) {
+      std::cerr << "Error: " << error.message << "\n";
+      exit(5);
+    }
+  }
 }
 
-#else
-std::shared_ptr<heif_image> loadJPEG(const char* filename)
-{
-  std::cerr << "Cannot load JPEG because libjpeg support was not compiled.\n";
-  exit(1);
-
-  return nullptr;
-}
-#endif
 
+static void show_list_of_encoders(const heif_encoder_descriptor* const* encoder_descriptors,
+                                  int count)
+{
+  for (int i = 0; i < count; i++) {
+    std::cout << "- " << heif_encoder_descriptor_get_id_name(encoder_descriptors[i])
+              << " = "
+              << heif_encoder_descriptor_get_name(encoder_descriptors[i]);
 
-#if HAVE_LIBPNG
+    if (i == 0) {
+      std::cout << " [default]";
+    }
 
-static void
-user_read_fn(png_structp png_ptr, png_bytep data, png_size_t length)
-{
-  FILE* fh = (FILE*) png_get_io_ptr(png_ptr);
-  size_t n = fread((char*) data, length, 1, fh);
-  (void) n;
-} // user_read_data
+    std::cout << "\n";
+  }
+}
 
 
-std::shared_ptr<heif_image> loadPNG(const char* filename, int output_bit_depth)
+static const char* get_compression_format_name(heif_compression_format format)
 {
-  FILE* fh = fopen(filename, "rb");
-  if (!fh) {
-    std::cerr << "Can't open " << filename << "\n";
-    exit(1);
+  switch (format) {
+    case heif_compression_AV1:
+      return "AV1";
+      break;
+    case heif_compression_AVC:
+      return "AVC";
+      break;
+    case heif_compression_VVC:
+      return "VVC";
+      break;
+    case heif_compression_HEVC:
+      return "HEVC";
+      break;
+    case heif_compression_JPEG:
+      return "JPEG";
+      break;
+    case heif_compression_JPEG2000:
+      return "JPEG 2000";
+      break;
+    case heif_compression_HTJ2K:
+      return "HT-J2K";
+      break;
+    case heif_compression_uncompressed:
+      return "Uncompressed";
+      break;
+    default:
+      assert(false);
+      return "unknown";
   }
+}
 
+static void show_list_of_all_encoders()
+{
+  for (auto compression_format: {heif_compression_AVC, heif_compression_AV1, heif_compression_HEVC,
+                                 heif_compression_JPEG, heif_compression_JPEG2000, heif_compression_HTJ2K,
+                                 heif_compression_uncompressed, heif_compression_VVC
+  }) {
+
+    switch (compression_format) {
+      case heif_compression_AVC:
+        std::cout << "AVC";
+        break;
+      case heif_compression_AV1:
+        std::cout << "AVIF";
+        break;
+      case heif_compression_HEVC:
+        std::cout << "HEIC";
+        break;
+      case heif_compression_JPEG:
+        std::cout << "JPEG";
+        break;
+      case heif_compression_JPEG2000:
+        std::cout << "JPEG 2000";
+        break;
+      case heif_compression_HTJ2K:
+        std::cout << "JPEG 2000 (HT)";
+        break;
+      case heif_compression_uncompressed:
+        std::cout << "Uncompressed";
+        break;
+      case heif_compression_VVC:
+        std::cout << "VVIC";
+        break;
+      default:
+        assert(false);
+    }
 
-  // ### Code copied from LibVideoGfx and slightly modified to use HeifPixelImage
+    std::cout << " encoders:\n";
 
-  struct heif_image* image = nullptr;
+#define MAX_ENCODERS 10
+    const heif_encoder_descriptor* encoder_descriptors[MAX_ENCODERS];
+    int count = heif_get_encoder_descriptors(compression_format,
+                                             nullptr,
+                                             encoder_descriptors, MAX_ENCODERS);
+#undef MAX_ENCODERS
 
-  png_structp png_ptr;
-  png_infop info_ptr;
-  png_uint_32 width, height;
-  int bit_depth, color_type, interlace_type;
-  int compression_type;
-  png_charp name;
-#if (PNG_LIBPNG_VER < 10500)
-  png_charp png_profile_data;
-#else
-  png_bytep png_profile_data;
-#endif
-  uint8_t* profile_data = nullptr;
-  png_uint_32 profile_length = 5;
-
-  /* Create and initialize the png_struct with the desired error handler
-   * functions.  If you want to use the default stderr and longjump method,
-   * you can supply NULL for the last three parameters.  We also supply the
-   * the compiler header file version, so that we know if the application
-   * was compiled with a compatible version of the library.  REQUIRED
-   */
-  png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
-  assert(png_ptr != NULL);
-
-  /* Allocate/initialize the memory for image information.  REQUIRED. */
-  info_ptr = png_create_info_struct(png_ptr);
-  if (info_ptr == NULL) {
-    png_destroy_read_struct(&png_ptr, (png_infopp) NULL, (png_infopp) NULL);
-    assert(false); // , "could not create info_ptr");
-  } // if
-
-  /* Set error handling if you are using the setjmp/longjmp method (this is
-   * the normal method of doing things with libpng).  REQUIRED unless you
-   * set up your own error handlers in the png_create_read_struct() earlier.
-   */
-  if (setjmp(png_jmpbuf(png_ptr))) {
-    /* Free all of the memory associated with the png_ptr and info_ptr */
-    png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp) NULL);
-    /* If we get here, we had a problem reading the file */
-    assert(false); // , "fatal error in png library");
-  } // if
-
-  /* If you are using replacement read functions, instead of calling
-   * png_init_io() here you would call: */
-  png_set_read_fn(png_ptr, (void*) fh, user_read_fn);
-  /* where user_io_ptr is a structure you want available to the callbacks */
-
-  /* The call to png_read_info() gives us all of the information from the
-   * PNG file before the first IDAT (image data chunk).  REQUIRED
-   */
-  png_read_info(png_ptr, info_ptr);
-
-  png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
-               &interlace_type, NULL, NULL);
-
-  if (png_get_valid(png_ptr, info_ptr, PNG_INFO_iCCP)) {
-    if (PNG_INFO_iCCP ==
-        png_get_iCCP(png_ptr, info_ptr, &name, &compression_type, &png_profile_data, &profile_length) &&
-        profile_length > 0) {
-      profile_data = (uint8_t*) malloc(profile_length);
-      if (profile_data) {
-        memcpy(profile_data, png_profile_data, profile_length);
-      }
-    }
+    show_list_of_encoders(encoder_descriptors, count);
   }
-  /**** Set up the data transformations you want.  Note that these are all
-   **** optional.  Only call them if you want/need them.  Many of the
-   **** transformations only work on specific types of images, and many
-   **** are mutually exclusive.
-   ****/
-
-  // \TODO
-  //      /* Strip alpha bytes from the input data without combining with the
-  //       * background (not recommended).
-  //       */
-  //      png_set_strip_alpha(png_ptr);
-
-  /* Extract multiple pixels with bit depths of 1, 2, and 4 from a single
-   * byte into separate bytes (useful for paletted and grayscale images).
-   */
-  png_set_packing(png_ptr);
-
-
-  /* Expand paletted colors into true RGB triplets */
-  if (color_type == PNG_COLOR_TYPE_PALETTE)
-    png_set_expand(png_ptr);
-
-  /* Expand grayscale images to the full 8 bits from 1, 2, or 4 bits/pixel */
-  if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)
-    png_set_expand(png_ptr);
-
-  /* Set the background color to draw transparent and alpha images over.
-   * It is possible to set the red, green, and blue components directly
-   * for paletted images instead of supplying a palette index.  Note that
-   * even if the PNG file supplies a background, you are not required to
-   * use it - you should use the (solid) application background if it has one.
-   */
-
-#if 0
-  // \TODO 0 is index in color lookup table - correct? used already?
-  png_color_16 my_background = {0, 255, 255, 255, 255};
-  png_color_16 *image_background;
-
-  if (png_get_bKGD(png_ptr, info_ptr, &image_background))
-    png_set_background(png_ptr, image_background, PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);
-  else
-    png_set_background(png_ptr, &my_background, PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0);
-#endif
-
+}
 
-  /* Optional call to gamma correct and add the background to the palette
-   * and update info structure.  REQUIRED if you are expecting libpng to
-   * update the palette for you (ie you selected such a transform above).
-   */
-  png_read_update_info(png_ptr, info_ptr);
 
-  /* Allocate the memory to hold the image using the fields of info_ptr. */
+bool ends_with(const std::string& str, const std::string& end)
+{
+  if (str.length() < end.length()) {
+    return false;
+  }
+  else {
+    return str.compare(str.length() - end.length(), end.length(), end) == 0;
+  }
+}
 
-  /* The easiest way to read the image: */
-  uint8_t** row_pointers = new png_bytep[height];
-  assert(row_pointers != NULL);
 
-  for (uint32_t y = 0; y < height; y++) {
-    row_pointers[y] = (png_bytep) malloc(png_get_rowbytes(png_ptr, info_ptr));
-    assert(row_pointers[y] != NULL);
-  } // for
-
-  /* Now it's time to read the image.  One of these methods is REQUIRED */
-  png_read_image(png_ptr, row_pointers);
-
-  /* read rest of file, and get additional chunks in info_ptr - REQUIRED */
-  png_read_end(png_ptr, info_ptr);
-
-  /* clean up after the read, and free any memory allocated - REQUIRED */
-  png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp) NULL);
-
-
-  // OK, now we should have the png image in some way in
-  // row_pointers, have fun with it
-
-  int band = 0;
-  switch (color_type) {
-    case PNG_COLOR_TYPE_GRAY:
-    case PNG_COLOR_TYPE_GRAY_ALPHA:
-      band = 1;
-      break;
-    case PNG_COLOR_TYPE_PALETTE:
-    case PNG_COLOR_TYPE_RGB:
-    case PNG_COLOR_TYPE_RGB_ALPHA:
-      band = 3;
-      break;
-    default:
-      assert(false); // , "unknown color type in png image.");
-  } // switch
+heif_compression_format guess_compression_format_from_filename(const std::string& filename)
+{
+  std::string filename_lowercase = filename;
+  std::transform(filename_lowercase.begin(), filename_lowercase.end(), filename_lowercase.begin(), ::tolower);
 
+  if (ends_with(filename_lowercase, ".avif")) {
+    return heif_compression_AV1;
+  }
+  else if (ends_with(filename_lowercase, ".vvic")) {
+    return heif_compression_VVC;
+  }
+  else if (ends_with(filename_lowercase, ".avci")) {
+    return heif_compression_AVC;
+  }
+  else if (ends_with(filename_lowercase, ".heic")) {
+    return heif_compression_HEVC;
+  }
+  else if (ends_with(filename_lowercase, ".hej2")) {
+    return heif_compression_JPEG2000;
+  }
+  else {
+    return heif_compression_undefined;
+  }
+}
 
 
+std::string suffix_for_compression_format(heif_compression_format format)
+{
+  switch (format) {
+    case heif_compression_AV1: return "avif";
+    case heif_compression_VVC: return "vvic";
+    case heif_compression_AVC: return "avci";
+    case heif_compression_HEVC: return "heic";
+    case heif_compression_JPEG2000: return "hej2";
+    default: return "data";
+  }
+}
 
-  struct heif_error err;
 
-  bool has_alpha = (color_type & PNG_COLOR_MASK_ALPHA);
+InputImage load_image(const std::string& input_filename, int output_bit_depth)
+{
+  InputImage input_image;
 
-  if (band == 1 && bit_depth==8) {
-    err = heif_image_create((int) width, (int) height,
-                            heif_colorspace_monochrome,
-                            heif_chroma_monochrome,
-                            &image);
-    (void) err;
+  // get file type from file name
 
-    heif_image_add_plane(image, heif_channel_Y, (int) width, (int) height, 8);
+  std::string suffix;
+  auto suffix_pos = input_filename.find_last_of('.');
+  if (suffix_pos != std::string::npos) {
+    suffix = input_filename.substr(suffix_pos + 1);
+    std::transform(suffix.begin(), suffix.end(), suffix.begin(), ::tolower);
+  }
 
-    int y_stride;
-    int a_stride;
-    uint8_t* py = heif_image_get_plane(image, heif_channel_Y, &y_stride);
-    uint8_t* pa = nullptr;
+  enum
+  {
+    PNG, JPEG, Y4M, TIFF, RAW
+  } filetype = JPEG;
+  if (suffix == "png") {
+    filetype = PNG;
+  }
+  else if (suffix == "y4m") {
+    filetype = Y4M;
+  }
+  else if (suffix == "tif" || suffix == "tiff") {
+    filetype = TIFF;
+  }
+  else if (suffix == "raw" || suffix == "img") {
+    filetype = RAW;
+  }
 
-    if (has_alpha) {
-      heif_image_add_plane(image, heif_channel_Alpha, (int) width, (int) height, 8);
+  if (force_raw_input) {
+    filetype = RAW;
+  }
 
-      pa = heif_image_get_plane(image, heif_channel_Alpha, &a_stride);
+  if (filetype == PNG) {
+    heif_error err = loadPNG(input_filename.c_str(), output_bit_depth, &input_image);
+    if (err.code != heif_error_Ok) {
+      std::cerr << "Can not load PNG input image: " << err.message << '\n';
+      exit(1);
+    }
+  }
+  else if (filetype == Y4M) {
+    heif_error err = loadY4M(input_filename.c_str(), &input_image);
+    if (err.code != heif_error_Ok) {
+      std::cerr << "Can not load Y4M input image: " << err.message << '\n';
+      exit(1);
+    }
+  }
+#if HAVE_LIBTIFF
+  else if (filetype == TIFF) {
+    heif_error err = loadTIFF(input_filename.c_str(), output_bit_depth, &input_image);
+    if (err.code != heif_error_Ok) {
+      std::cerr << "Can not load TIFF input image: " << err.message << '\n';
+      exit(1);
+    }
+  }
+#endif
+  else if (filetype == RAW) {
+    heif_error err = loadRAW(input_filename.c_str(), raw_input_params, &input_image);
+    if (err.code != heif_error_Ok) {
+      std::cerr << "Can not load raw input image: " << err.message << '\n';
+      exit(1);
+    }
+  }
+  else {
+    heif_error err = loadJPEG(input_filename.c_str(), &input_image);
+    if (err.code != heif_error_Ok) {
+      std::cerr << "Can not load JPEG input image: " << err.message << '\n';
+      exit(1);
     }
+  }
 
+  return input_image;
+}
 
-    for (uint32_t y = 0; y < height; y++) {
-      uint8_t* p = row_pointers[y];
 
-      if (has_alpha) {
-        for (uint32_t x = 0; x < width; x++) {
-          py[y * y_stride + x] = *p++;
-          pa[y * a_stride + x] = *p++;
-        }
-      }
-      else {
-        memcpy(&py[y * y_stride], p, width);
-      }
-    }
+heif_error create_output_nclx_profile_and_configure_encoder(heif_encoder* encoder,
+                                                            heif_color_profile_nclx** out_nclx,
+                                                            std::shared_ptr<heif_image> input_image,
+                                                            bool lossless,
+                                                            heif_output_nclx_color_profile_preset profile_preset)
+{
+  *out_nclx = heif_nclx_color_profile_alloc();
+  if (!*out_nclx) {
+    return {heif_error_Encoding_error, heif_suberror_Unspecified, "Cannot allocate NCLX color profile."};
   }
-  else if (band == 1) {
-    assert(bit_depth>8);
 
-    err = heif_image_create((int) width, (int) height,
-                            heif_colorspace_monochrome,
-                            heif_chroma_monochrome,
-                            &image);
-    (void) err;
+  heif_color_profile_nclx* nclx = *out_nclx; // abbreviation;
 
-    int bdShift = 16 - output_bit_depth;
 
-    heif_image_add_plane(image, heif_channel_Y, (int) width, (int) height, output_bit_depth);
+  // set NCLX based on preset
+
+  switch (profile_preset) {
+    case heif_output_nclx_color_profile_preset_custom: {
+      heif_error error = heif_nclx_color_profile_set_matrix_coefficients(nclx, nclx_matrix_coefficients);
+      if (error.code) {
+        std::cerr << "Invalid matrix coefficients specified.\n";
+        exit(5);
+      }
 
-    int y_stride;
-    int a_stride = 0;
-    uint16_t* py = (uint16_t*)heif_image_get_plane(image, heif_channel_Y, &y_stride);
-    uint16_t* pa = nullptr;
+      error = heif_nclx_color_profile_set_transfer_characteristics(nclx, nclx_transfer_characteristic);
+      if (error.code) {
+        std::cerr << "Invalid transfer characteristics specified.\n";
+        exit(5);
+      }
 
-    if (has_alpha) {
-      heif_image_add_plane(image, heif_channel_Alpha, (int) width, (int) height, output_bit_depth);
+      error = heif_nclx_color_profile_set_color_primaries(nclx, nclx_colour_primaries);
+      if (error.code) {
+        std::cerr << "Invalid color primaries specified.\n";
+        exit(5);
+      }
 
-      pa = (uint16_t*)heif_image_get_plane(image, heif_channel_Alpha, &a_stride);
+      nclx->full_range_flag = (uint8_t) nclx_full_range;
+      break;
     }
 
-    y_stride /= 2;
-    a_stride /= 2;
+    case heif_output_nclx_color_profile_preset_automatic: {
+      heif_color_profile_nclx* input_nclx = nullptr;
 
-    for (uint32_t y = 0; y < height; y++) {
-      uint8_t* p = row_pointers[y];
+      // --- use input image color profile, if it exists
 
-      if (has_alpha) {
-        for (uint32_t x = 0; x < width; x++) {
-          uint16_t vp = (uint16_t) (((p[0] << 8) | p[1]) >> bdShift);
-          uint16_t va = (uint16_t) (((p[2] << 8) | p[3]) >> bdShift);
+      heif_error error = heif_image_get_nclx_color_profile(input_image.get(), &input_nclx);
+      if (error.code == heif_error_Color_profile_does_not_exist) {
 
-          py[x + y * y_stride] = vp;
-          pa[x + y * y_stride] = va;
+        // input image has not color profile, guess one
 
-          p += 4;
+        if (heif_image_get_colorspace(input_image.get()) == heif_colorspace_RGB) {
+          // sRGB
+          nclx->matrix_coefficients = heif_matrix_coefficients_ITU_R_BT_709_5; // will be overwritten below if lossless
+          nclx->color_primaries = heif_color_primaries_ITU_R_BT_709_5;
+          nclx->transfer_characteristics = heif_transfer_characteristic_IEC_61966_2_1;
         }
+        else {
+          // BT.709
+          nclx->matrix_coefficients = heif_matrix_coefficients_ITU_R_BT_709_5; // will be overwritten below if lossless
+          nclx->color_primaries = heif_color_primaries_ITU_R_BT_709_5;
+          nclx->transfer_characteristics = heif_transfer_characteristic_ITU_R_BT_709_5;
+        }
+      }
+      else if (error.code) {
+        std::cerr << "Cannot get input NCLX color profile.\n";
+        return error;
       }
       else {
-        for (uint32_t x = 0; x < width; x++) {
-          uint16_t vp = (uint16_t) (((p[0] << 8) | p[1]) >> bdShift);
+        // no error, we have an input color profile that we can use for output too
 
-          py[x + y * y_stride] = vp;
+        nclx->matrix_coefficients = input_nclx->matrix_coefficients;
+        nclx->transfer_characteristics = input_nclx->transfer_characteristics;
+        nclx->color_primaries = input_nclx->color_primaries;
+        nclx->full_range_flag = input_nclx->full_range_flag;
 
-          p += 2;
-        }
+        heif_nclx_color_profile_free(input_nclx);
+        input_nclx = nullptr;
       }
+
+      assert(!input_nclx);
+      break;
     }
-  }
-  else if (bit_depth == 8) {
-    err = heif_image_create((int) width, (int) height,
-                            heif_colorspace_RGB,
-                            has_alpha ? heif_chroma_interleaved_RGBA : heif_chroma_interleaved_RGB,
-                            &image);
-    (void) err;
 
-    heif_image_add_plane(image, heif_channel_interleaved, (int) width, (int) height,
-                         has_alpha ? 32 : 24);
+    case heif_output_nclx_color_profile_preset_Rec_601:
+      nclx->matrix_coefficients = heif_matrix_coefficients_ITU_R_BT_601_6;
+      nclx->color_primaries = heif_color_primaries_ITU_R_BT_601_6;
+      nclx->transfer_characteristics = heif_transfer_characteristic_ITU_R_BT_601_6;
+      break;
+
+    case heif_output_nclx_color_profile_preset_compatible:
+    case heif_output_nclx_color_profile_preset_Rec_709:
+      nclx->matrix_coefficients = heif_matrix_coefficients_ITU_R_BT_709_5;
+      nclx->color_primaries = heif_color_primaries_ITU_R_BT_709_5;
+      nclx->transfer_characteristics = heif_transfer_characteristic_ITU_R_BT_709_5;
+      break;
 
-    int stride;
-    uint8_t* p = heif_image_get_plane(image, heif_channel_interleaved, &stride);
+    case heif_output_nclx_color_profile_preset_Rec_2020:
+      nclx->matrix_coefficients = heif_matrix_coefficients_ITU_R_BT_2020_2_constant_luminance;
+      nclx->color_primaries = heif_color_primaries_ITU_R_BT_2020_2_and_2100_0;
 
-    for (uint32_t y = 0; y < height; y++) {
-      if (has_alpha) {
-        memcpy(p + y * stride, row_pointers[y], width * 4);
+      if (heif_image_has_channel(input_image.get(), heif_channel_Y) &&
+          heif_image_get_bits_per_pixel(input_image.get(), heif_channel_Y) <= 10) {
+        nclx->transfer_characteristics = heif_transfer_characteristic_ITU_R_BT_2020_2_10bit;
       }
       else {
-        memcpy(p + y * stride, row_pointers[y], width * 3);
+        nclx->transfer_characteristics = heif_transfer_characteristic_ITU_R_BT_2020_2_12bit;
       }
-    }
+      break;
   }
-  else {
-    err = heif_image_create((int) width, (int) height,
-                            heif_colorspace_RGB,
-                            has_alpha ?
-                            heif_chroma_interleaved_RRGGBBAA_LE :
-                            heif_chroma_interleaved_RRGGBB_LE,
-                            &image);
-    (void) err;
 
-    int bdShift = 16 - output_bit_depth;
+  // modify NCLX depending on input image
 
-    heif_image_add_plane(image, heif_channel_interleaved, (int) width, (int) height, output_bit_depth);
+  if (lossless) {
+      heif_encoder_set_lossless(encoder, true);
 
-    int stride;
-    uint8_t* p_out = (uint8_t*) heif_image_get_plane(image, heif_channel_interleaved, &stride);
+      if (heif_image_get_colorspace(input_image.get()) == heif_colorspace_RGB) {
+        nclx->matrix_coefficients = heif_matrix_coefficients_RGB_GBR;
+        nclx->full_range_flag = true;
 
-    for (uint32_t y = 0; y < height; y++) {
-      uint8_t* p = row_pointers[y];
+        heif_error error = heif_encoder_set_parameter(encoder, "chroma", "444");
+        if (error.code) {
+          return error;
+        }
+      }
+      else {
+        heif_error error;
 
-      uint32_t nVal = (has_alpha ? 4 : 3) * width;
+        // TODO: this assumes that the encoder plugin has a 'chroma' parameter. Currently, they do, but there should be a better way to set this.
+        switch (heif_image_get_chroma_format(input_image.get())) {
+          case heif_chroma_420:
+          case heif_chroma_monochrome:
+            error = heif_encoder_set_parameter(encoder, "chroma", "420");
+            break;
+          case heif_chroma_422:
+            error = heif_encoder_set_parameter(encoder, "chroma", "422");
+            break;
+          case heif_chroma_444:
+            error = heif_encoder_set_parameter(encoder, "chroma", "444");
+            break;
+          default:
+            assert(false);
+            exit(5);
+        }
 
-      for (uint32_t x = 0; x < nVal; x++) {
-        uint16_t v = (uint16_t) (((p[0] << 8) | p[1]) >> bdShift);
-        p_out[2 * x + y * stride + 1] = (uint8_t) (v >> 8);
-        p_out[2 * x + y * stride + 0] = (uint8_t) (v & 0xFF);
-        p += 2;
+        if (error.code) {
+          return error;
+        }
       }
-    }
-  }
-
-  if (profile_data && profile_length > 0) {
-    heif_image_set_raw_color_profile(image, "prof", profile_data, (size_t) profile_length);
   }
 
-  free(profile_data);
-  for (uint32_t y = 0; y < height; y++) {
-    free(row_pointers[y]);
-  } // for
-
-  delete[] row_pointers;
-
-  return std::shared_ptr<heif_image>(image,
-                                     [](heif_image* img) { heif_image_release(img); });
+  return {heif_error_Ok};
 }
 
-#else
-std::shared_ptr<heif_image> loadPNG(const char* filename, int output_bit_depth)
+
+struct input_tiles_generator
 {
-  std::cerr << "Cannot load PNG because libpng support was not compiled.\n";
-  exit(1);
+  virtual ~input_tiles_generator() = default;
 
-  return nullptr;
-}
-#endif
+  virtual uint32_t nColumns() const = 0;
+  virtual uint32_t nRows() const = 0;
+
+  virtual uint32_t nTiles() const { return nColumns() * nRows(); }
 
+  virtual InputImage get_image(uint32_t tx, uint32_t ty, int output_bit_depth) = 0;
+};
 
-std::shared_ptr<heif_image> loadY4M(const char* filename)
+struct input_tiles_generator_separate_files : public input_tiles_generator
 {
-  struct heif_image* image = nullptr;
+  uint32_t first_start;
+  uint32_t first_end;
+  uint32_t first_digits;
+  uint32_t second_start;
+  uint32_t second_end;
+  uint32_t second_digits;
 
+  std::filesystem::path directory;
+  std::string prefix;
+  std::string separator;
+  std::string suffix;
 
-  // open input file
+  bool first_is_x = false;
 
-  std::ifstream istr(filename, std::ios_base::binary);
-  if (istr.fail()) {
-    std::cerr << "Can't open " << filename << "\n";
-    exit(1);
-  }
+  uint32_t nColumns() const override { return first_is_x ? (first_end - first_start + 1) : (second_end - second_start + 1); }
+  uint32_t nRows() const override { return first_is_x ? (second_end - second_start + 1) : (first_end - first_start + 1); }
 
+  uint32_t nTiles() const override { return (first_end - first_start + 1) * (second_end - second_start + 1); }
 
-  std::string header;
-  getline(istr, header);
+  std::filesystem::path filename(uint32_t tx, uint32_t ty) const
+  {
+    std::stringstream sstr;
 
-  if (header.find("YUV4MPEG2 ") != 0) {
-    std::cerr << "Input is not a Y4M file.\n";
-    exit(1);
+    sstr << prefix << std::setw(first_digits) << std::setfill('0') << (first_is_x ? tx : ty) + first_start;
+    sstr << separator << std::setw(second_digits) << std::setfill('0') << (first_is_x ? ty : tx) + second_start;
+    sstr << suffix;
+
+    std::filesystem::path p = directory / sstr.str();
+    return p;
   }
 
-  int w = -1;
-  int h = -1;
+  InputImage get_image(uint32_t tx, uint32_t ty, int output_bit_depth) override
+  {
+    std::string input_filename = filename(tx, ty).string();
+    InputImage image = load_image(input_filename, output_bit_depth);
+    return image;
+  }
+};
 
-  size_t pos = 0;
-  for (;;) {
-    pos = header.find(' ', pos + 1) + 1;
-    if (pos == std::string::npos) {
-      break;
-    }
+std::shared_ptr<input_tiles_generator> determine_input_images_tiling(const std::string& filename, bool first_is_x)
+{
+  std::regex pattern(R"((.*\D)?(\d+)(\D+?)(\d+)(\..+)$)");
+  std::smatch match;
 
-    size_t end = header.find_first_of(" \n", pos + 1);
-    if (end == std::string::npos) {
-      break;
-    }
+  auto generator = std::make_shared<input_tiles_generator_separate_files>();
 
-    if (end - pos <= 1) {
-      std::cerr << "Header format error in Y4M file.\n";
-      exit(1);
-    }
+  if (std::regex_match(filename, match, pattern)) {
+    std::string prefix = match[1];
 
-    char tag = header[pos];
-    std::string value = header.substr(pos + 1, end - pos - 1);
-    if (tag == 'W') {
-      w = atoi(value.c_str());
-    }
-    else if (tag == 'H') {
-      h = atoi(value.c_str());
-    }
-  }
+    auto p = std::filesystem::absolute(std::filesystem::path(prefix));
+    generator->directory = p.parent_path();
+    generator->prefix = p.filename().string(); // TODO: we could also use u8string(), but it is not well supported in C++20
 
-  std::string frameheader;
-  getline(istr, frameheader);
+    generator->separator = match[3];
+    generator->suffix = match[5];
 
-  if (frameheader != "FRAME") {
-    std::cerr << "Y4M misses the frame header.\n";
-    exit(1);
-  }
+    generator->first_start = 9999;
+    generator->first_end = 0;
+    generator->first_digits = 9;
 
-  if (w < 0 || h < 0) {
-    std::cerr << "Y4M has invalid frame size.\n";
-    exit(1);
+    generator->second_start = 9999;
+    generator->second_end = 0;
+    generator->second_digits = 9;
+  }
+  else {
+    return nullptr;
   }
 
-  struct heif_error err = heif_image_create(w, h,
-                                            heif_colorspace_YCbCr,
-                                            heif_chroma_420,
-                                            &image);
-  (void) err;
-  // TODO: handle error
+  std::string patternString = generator->prefix + "(\\d+)" + generator->separator + "(\\d+)" + generator->suffix + "$";
+  pattern = patternString;
 
-  heif_image_add_plane(image, heif_channel_Y, w, h, 8);
-  heif_image_add_plane(image, heif_channel_Cb, (w + 1) / 2, (h + 1) / 2, 8);
-  heif_image_add_plane(image, heif_channel_Cr, (w + 1) / 2, (h + 1) / 2, 8);
+  for (const auto& dirEntry : std::filesystem::directory_iterator(generator->directory))
+  {
+    if (dirEntry.is_regular_file()) {
+      std::string s{dirEntry.path().filename().string()};
 
-  int y_stride, cb_stride, cr_stride;
-  uint8_t* py = heif_image_get_plane(image, heif_channel_Y, &y_stride);
-  uint8_t* pcb = heif_image_get_plane(image, heif_channel_Cb, &cb_stride);
-  uint8_t* pcr = heif_image_get_plane(image, heif_channel_Cr, &cr_stride);
+      if (std::regex_match(s, match, pattern)) {
+        uint32_t first = std::stoi(match[1]);
+        uint32_t second = std::stoi(match[2]);
 
-  for (int y = 0; y < h; y++) {
-    istr.read((char*) (py + y * y_stride), w);
-  }
+        generator->first_digits = std::min(generator->first_digits, (uint32_t)match[1].length());
+        generator->second_digits = std::min(generator->second_digits, (uint32_t)match[2].length());
 
-  for (int y = 0; y < (h + 1) / 2; y++) {
-    istr.read((char*) (pcb + y * cb_stride), (w + 1) / 2);
+        generator->first_start = std::min(generator->first_start, first);
+        generator->first_end = std::max(generator->first_end, first);
+        generator->second_start = std::min(generator->second_start, second);
+        generator->second_end = std::max(generator->second_end, second);
+      }
+    }
   }
 
-  for (int y = 0; y < (h + 1) / 2; y++) {
-    istr.read((char*) (pcr + y * cr_stride), (w + 1) / 2);
-  }
+  generator->first_is_x = first_is_x;
 
-  return std::shared_ptr<heif_image>(image,
-                                     [](heif_image* img) { heif_image_release(img); });
+  return generator;
 }
 
 
-void list_encoder_parameters(heif_encoder* encoder)
+class input_tiles_generator_cut_image : public input_tiles_generator
 {
-  std::cerr << "Parameters for encoder `" << heif_encoder_get_name(encoder) << "`:\n";
+public:
+  input_tiles_generator_cut_image(const char* filename, int tile_size, int output_bit_depth)
+  {
+    mImage = load_image(filename, output_bit_depth);
 
-  const struct heif_encoder_parameter* const* params = heif_encoder_list_parameters(encoder);
-  for (int i = 0; params[i]; i++) {
-    const char* name = heif_encoder_parameter_get_name(params[i]);
+    mWidth = heif_image_get_primary_width(mImage.image.get());
+    mHeight = heif_image_get_primary_height(mImage.image.get());
 
-    switch (heif_encoder_parameter_get_type(params[i])) {
-      case heif_encoder_parameter_type_integer: {
-        heif_error error;
+    mTileSize = tile_size;
+  }
 
-        std::cerr << "  " << name;
+  uint32_t nColumns() const override { return (mWidth + mTileSize - 1)/mTileSize; }
+  uint32_t nRows() const override { return (mHeight + mTileSize - 1)/mTileSize; }
+
+  InputImage get_image(uint32_t tx, uint32_t ty, int output_bit_depth) override
+  {
+    heif_image* tileImage;
+    heif_error err = heif_image_extract_area(mImage.image.get(), tx * mTileSize, ty * mTileSize, mTileSize, mTileSize,
+                                             heif_get_global_security_limits(),
+                                             &tileImage);
+    if (err.code) {
+      std::cerr << "error extracting tile " << tx << ";" << ty << std::endl;
+      exit(1);
+    }
 
-        if (heif_encoder_has_default(encoder, name)) {
-          int value;
-          error = heif_encoder_get_parameter_integer(encoder, name, &value);
-          (void) error;
+    InputImage tile;
+    tile.image = std::shared_ptr<heif_image>(tileImage,
+                                             [](heif_image* img) { heif_image_release(img); });
+    return tile;
+  }
 
-          std::cerr << ", default=" << value;
-        }
+  uint32_t get_image_width() const { return heif_image_get_primary_width(mImage.image.get()); }
+  uint32_t get_image_height() const { return heif_image_get_primary_height(mImage.image.get()); }
 
-        int have_minimum, have_maximum, minimum, maximum, num_valid_values;
-        const int* valid_values = nullptr;
-        error = heif_encoder_parameter_integer_valid_values(encoder, name,
-                                                            &have_minimum, &have_maximum,
-                                                            &minimum, &maximum,
-                                                            &num_valid_values,
-                                                            &valid_values);
+private:
+  InputImage mImage;
+  uint32_t mWidth, mHeight;
+  int mTileSize;
+};
 
-        if (have_minimum || have_maximum) {  // TODO: only one is set
-          std::cerr << ", [" << minimum << ";" << maximum << "]";
-        }
 
-        if (num_valid_values > 0) {
-          std::cerr << ", {";
+#if HAVE_LIBTIFF
+class input_tiles_generator_tiff : public input_tiles_generator
+{
+public:
+  input_tiles_generator_tiff(std::shared_ptr<TiledTiffReader> reader)
+    : m_reader(std::move(reader))
+  {
+  }
 
-          for (int p=0;p<num_valid_values;p++) {
-            if (p>0) {
-              std::cerr << ", ";
-            }
+  uint32_t nColumns() const override { return m_reader->nColumns(); }
+  uint32_t nRows() const override { return m_reader->nRows(); }
 
-            std::cerr << valid_values[p];
-          }
+  InputImage get_image(uint32_t tx, uint32_t ty, int output_bit_depth) override
+  {
+    heif_image* tile_image = nullptr;
+    heif_error err = m_reader->readTile(tx, ty, output_bit_depth, &tile_image);
+    if (err.code != heif_error_Ok) {
+      std::cerr << "Error reading TIFF tile " << tx << "," << ty << ": " << err.message << "\n";
+      exit(1);
+    }
 
-          std::cerr << "}";
-        }
+    InputImage input;
+    input.image = std::shared_ptr<heif_image>(tile_image,
+                                               [](heif_image* img) { heif_image_release(img); });
+    return input;
+  }
 
-        std::cerr << "\n";
-      }
-        break;
+  uint32_t imageWidth() const { return m_reader->imageWidth(); }
+  uint32_t imageHeight() const { return m_reader->imageHeight(); }
+  uint32_t tileWidth() const { return m_reader->tileWidth(); }
+  uint32_t tileHeight() const { return m_reader->tileHeight(); }
 
-      case heif_encoder_parameter_type_boolean: {
-        heif_error error;
-        std::cerr << "  " << name;
+  void readExif(InputImage* input_image) { m_reader->readExif(input_image); }
 
-        if (heif_encoder_has_default(encoder, name)) {
-          int value;
-          error = heif_encoder_get_parameter_boolean(encoder, name, &value);
-          (void) error;
+private:
+  std::shared_ptr<TiledTiffReader> m_reader;
+};
+#endif
 
-          std::cerr << ", default=" << (value ? "true" : "false");
-        }
 
-        std::cerr << "\n";
-      }
-        break;
+// TODO: we have to attach the input image Exif and XMP to the tiled image
+heif_image_handle* encode_tiled(heif_context* ctx, heif_encoder* encoder, heif_encoding_options* options,
+                                int output_bit_depth,
+                                const std::shared_ptr<input_tiles_generator>& tile_generator,
+                                const heif_image_tiling& tiling,
+                                [[maybe_unused]] const std::map<std::tuple<int,int,int>, std::string>* tile_content_ids = nullptr,
+                                [[maybe_unused]] int layer_index = 0)
+{
+  heif_image_handle* tiled_image = nullptr;
 
-      case heif_encoder_parameter_type_string: {
-        heif_error error;
-        std::cerr << "  " << name;
 
-        if (heif_encoder_has_default(encoder, name)) {
-          const int value_size = 50;
-          char value[value_size];
-          error = heif_encoder_get_parameter_string(encoder, name, value, value_size);
-          (void) error;
+  // --- create the main grid image
 
-          std::cerr << ", default=" << value;
-        }
+  if (tiling_method == "grid") {
+    heif_error error = heif_context_add_grid_image(ctx, tiling.image_width, tiling.image_height,
+                                                   tiling.num_columns, tiling.num_rows,
+                                                   options,
+                                                   &tiled_image);
+    if (error.code != 0) {
+      std::cerr << "Could not generate grid image: " << error.message << "\n";
+      return nullptr;
+    }
+  }
+#if HEIF_ENABLE_EXPERIMENTAL_FEATURES
+  else if (tiling_method == "tili") {
+    heif_tiled_image_parameters tiled_params{};
+    tiled_params.version = 1;
+    tiled_params.image_width = tiling.image_width;
+    tiled_params.image_height = tiling.image_height;
+    tiled_params.tile_width = tiling.tile_width;
+    tiled_params.tile_height = tiling.tile_height;
+    tiled_params.offset_field_length = 32;
+    tiled_params.size_field_length = 24;
+    tiled_params.tiles_are_sequential = 1;
+
+    heif_error error = heif_context_add_tiled_image(ctx, &tiled_params, options, encoder, &tiled_image);
+    if (error.code != 0) {
+      std::cerr << "Could not generate tili image: " << error.message << "\n";
+      return nullptr;
+    }
+  }
+#endif
+#if WITH_UNCOMPRESSED_CODEC
+  else if (tiling_method == "unci") {
+    heif_unci_image_parameters params{};
+    params.version = 1;
+    params.image_width = tiling.image_width;
+    params.image_height = tiling.image_height;
+    params.tile_width = tiling.tile_width;
+    params.tile_height = tiling.tile_height;
+    params.compression = unci_compression;
+
+    InputImage prototype_image = tile_generator->get_image(0,0, output_bit_depth);
+
+    heif_error error = heif_context_add_empty_unci_image(ctx, &params, options, prototype_image.image.get(), &tiled_image);
+    if (error.code != 0) {
+      std::cerr << "Could not generate unci image: " << error.message << "\n";
+      return nullptr;
+    }
+  }
+#endif
+  else {
+    assert(false);
+    exit(10);
+  }
 
-        const char* const* valid_options;
-        error = heif_encoder_parameter_string_valid_values(encoder, name, &valid_options);
 
-        if (valid_options) {
-          std::cerr << ", { ";
-          for (int i = 0; valid_options[i]; i++) {
-            if (i > 0) { std::cerr << ","; }
-            std::cerr << valid_options[i];
-          }
-          std::cerr << " }";
+  // --- add all the image tiles
+
+  std::cout << "encoding tiled image, tile size: " << tiling.tile_width << "x" << tiling.tile_height
+            << " image size: " << tiling.image_width << "x" << tiling.image_height << "\n";
+
+  int tile_width = tiling.tile_width;
+  int tile_height = tiling.tile_height;
+
+  for (uint32_t ty = 0; ty < tile_generator->nRows(); ty++)
+    for (uint32_t tx = 0; tx < tile_generator->nColumns(); tx++) {
+      InputImage input_image = tile_generator->get_image(tx,ty, output_bit_depth);
+
+      heif_error error;
+      error = heif_image_extend_to_size_fill_with_zero(input_image.image.get(), tile_width, tile_height);
+      if (error.code) {
+        std::cerr << error.message << "\n";
+      }
+
+      std::cout << "encoding tile " << ty+1 << " " << tx+1
+                << " (of " << tile_generator->nRows() << "x" << tile_generator->nColumns() << ")  \r";
+      std::cout.flush();
+
+#if HEIF_ENABLE_EXPERIMENTAL_FEATURES
+      if (tile_content_ids) {
+        auto it = tile_content_ids->find({layer_index, static_cast<int>(tx), static_cast<int>(ty)});
+        if (it != tile_content_ids->end()) {
+          heif_image_set_gimi_sample_content_id(input_image.image.get(), it->second.c_str());
         }
+      }
+#endif
 
-        std::cerr << "\n";
+      error = heif_context_add_image_tile(ctx, tiled_image, tx, ty,
+                                          input_image.image.get(),
+                                          encoder);
+      if (error.code != 0) {
+        std::cerr << "Could not encode HEIF/AVIF file: " << error.message << "\n";
+        return nullptr;
       }
-        break;
     }
-  }
+
+  std::cout << "\n";
+
+  return tiled_image;
 }
 
 
-void set_params(struct heif_encoder* encoder, std::vector<std::string> params)
+template <typename T>
+std::vector<T> parse_comma_separated_numeric_arguments(std::string arg,
+                                                       std::vector<T> max_val)
 {
-  for (std::string p : params) {
-    auto pos = p.find_first_of('=');
-    if (pos == std::string::npos || pos == 0 || pos == p.size() - 1) {
-      std::cerr << "Encoder parameter must be in the format 'name=value'\n";
-      exit(5);
+  std::istringstream ss(arg);
+  std::string token;
+
+  std::vector<T> results;
+
+  for (size_t i = 0 ; i<max_val.size(); i++) {
+
+    if (!std::getline(ss, token, ',')) return {};
+    try {
+      size_t pos;
+      unsigned long val = std::stoul(token, &pos);
+      if (pos != token.size()) return {}; // extra non-numeric characters
+      if (val > max_val[i]) return {};
+      results.push_back(static_cast<T>(val));
+    } catch (...) {
+      return {};
     }
+  }
 
-    std::string name = p.substr(0, pos);
-    std::string value = p.substr(pos + 1);
+  // There should be no extra tokens
+  if (ss.rdbuf()->in_avail() != 0) return {};
 
-    struct heif_error error = heif_encoder_set_parameter(encoder, name.c_str(), value.c_str());
-    if (error.code) {
-      std::cerr << "Error: " << error.message << "\n";
-      exit(5);
-    }
-  }
+  return results;
+}
+
+bool prefix_compare(const char* a, const char* b)
+{
+  auto minLen = std::min(strlen(a), strlen(b));
+  return strncmp(a,b,minLen) == 0;
 }
 
 
-static void show_list_of_encoders(const heif_encoder_descriptor*const* encoder_descriptors,
-                                  int count)
+bool set_metadata_compression_method(const std::string& arg)
 {
-  std::cout << "Encoders (first is default):\n";
-  for (int i = 0; i < count; i++) {
-    std::cout << "- " << heif_encoder_descriptor_get_id_name(encoder_descriptors[i])
-              << " = "
-              << heif_encoder_descriptor_get_name(encoder_descriptors[i])
-              << "\n";
+  if (arg == "auto") {
+    metadata_compression_method = heif_metadata_compression_auto;
+    return true;
+  }
+  else if (arg == "off") {
+    metadata_compression_method = heif_metadata_compression_off;
+    return true;
+  }
+  else if (arg == "brotli") {
+    metadata_compression_method = heif_metadata_compression_brotli;
+    return true;
+  }
+  else if (arg == "deflate") {
+    metadata_compression_method = heif_metadata_compression_deflate;
+    return true;
+  }
+  else if (arg == "zlib") {
+    metadata_compression_method = heif_metadata_compression_zlib;
+    return true;
+  }
+  else {
+    std::cerr << "Unknown metadata compression method '" << arg << "'. Choose between {auto,off,deflate,zlib,brotli}\n";
+    return false;
   }
 }
 
 
+
+class LibHeifInitializer
+{
+public:
+  LibHeifInitializer() { heif_init(nullptr); }
+
+  ~LibHeifInitializer() { heif_deinit(); }
+};
+
+
+int do_encode_images(heif_context*, heif_encoder*, heif_encoding_options* options, const std::vector<std::string>& args);
+int do_encode_sequence(heif_context*, heif_encoder*, heif_encoding_options* options, std::vector<std::string> args);
+int add_mime_item(heif_context* context);
+
+
 int main(int argc, char** argv)
 {
-  int quality = 50;
-  bool lossless = false;
-  std::string output_filename;
-  int logging_level = 0;
-  bool option_show_parameters = false;
-  int thumbnail_bbox_size = 0;
-  int output_bit_depth = 10;
-  bool enc_av1f = false;
-  bool crop_to_even_size = false;
+  // This takes care of initializing libheif and also deinitializing it at the end to free all resources.
+  LibHeifInitializer initializer;
 
   std::vector<std::string> raw_params;
 
 
   while (true) {
     int option_index = 0;
-    int c = getopt_long(argc, argv, "hq:Lo:vPp:t:b:AEe:", long_options, &option_index);
+    int c = getopt_long(argc, argv, "hq:Lo:vPp:t:b:Ae:C:TSV"
+#if WITH_UNCOMPRESSED_CODEC
+        "U"
+#endif
+        , long_options, &option_index);
     if (c == -1)
       break;
 
@@ -1031,6 +1493,9 @@ int main(int argc, char** argv)
       case 'h':
         show_help(argv[0]);
         return 0;
+      case 'v':
+        heif_examples::show_version();
+        return 0;
       case 'q':
         quality = atoi(optarg);
         break;
@@ -1040,7 +1505,7 @@ int main(int argc, char** argv)
       case 'o':
         output_filename = optarg;
         break;
-      case 'v':
+      case OPTION_VERBOSE:
         logging_level++;
         break;
       case 'P':
@@ -1054,36 +1519,403 @@ int main(int argc, char** argv)
         break;
       case 'b':
         output_bit_depth = atoi(optarg);
+        if (output_bit_depth < 9 || output_bit_depth > 16) {
+          std::cerr << "Bit depth for input HDR images must be 9-16 bits.\n";
+          return 5;
+        }
         break;
       case 'A':
-        enc_av1f = true;
+        force_enc_av1f = true;
         break;
-      case 'E':
-        crop_to_even_size = true;
+#if WITH_UNCOMPRESSED_CODEC
+        case 'U':
+        force_enc_uncompressed = true;
         break;
+#endif
       case 'e':
         encoderId = optarg;
         break;
       case OPTION_NCLX_MATRIX_COEFFICIENTS:
-        nclx_matrix_coefficients = atoi(optarg);
+        nclx_matrix_coefficients = (uint16_t) strtoul(optarg, nullptr, 0);
         break;
       case OPTION_NCLX_COLOUR_PRIMARIES:
-        nclx_colour_primaries = atoi(optarg);
+        nclx_colour_primaries = (uint16_t) strtoul(optarg, nullptr, 0);
         break;
       case OPTION_NCLX_TRANSFER_CHARACTERISTIC:
-        nclx_transfer_characteristic = atoi(optarg);
+        nclx_transfer_characteristic = (uint16_t) strtoul(optarg, nullptr, 0);
         break;
       case OPTION_NCLX_FULL_RANGE_FLAG:
         nclx_full_range = atoi(optarg);
         break;
-    }
-  }
+      case OPTION_PITM_DESCRIPTION:
+        property_pitm_description = optarg;
+        break;
+      case OPTION_USE_HEVC_COMPRESSION:
+        force_enc_hevc = true;
+        break;
+      case OPTION_USE_VVC_COMPRESSION:
+        force_enc_vvc = true;
+        break;
+      case OPTION_USE_AVC_COMPRESSION:
+        force_enc_avc = true;
+        break;
+      case OPTION_USE_JPEG_COMPRESSION:
+        force_enc_jpeg = true;
+        break;
+      case OPTION_USE_JPEG2000_COMPRESSION:
+        force_enc_jpeg2000 = true;
+        break;
+      case OPTION_USE_HTJ2K_COMPRESSION:
+        force_enc_htj2k = true;
+        break;
+      case OPTION_PLUGIN_DIRECTORY: {
+        int nPlugins;
+        heif_error error = heif_load_plugins(optarg, nullptr, &nPlugins, 0);
+        if (error.code) {
+          std::cerr << "Error loading libheif plugins: " << error.message << "\n";
+          return 1;
+        }
+
+        // Note: since we process the option within the loop, we can only consider the '-v' flags coming before the plugin loading option.
+        if (logging_level > 0) {
+          std::cout << nPlugins << " plugins loaded from directory " << optarg << "\n";
+        }
+        break;
+      }
+      case OPTION_TILED_IMAGE_WIDTH:
+        tiled_image_width = (int) strtol(optarg, nullptr, 0);
+        break;
+      case OPTION_TILED_IMAGE_HEIGHT:
+        tiled_image_height = (int) strtol(optarg, nullptr, 0);
+        break;
+      case OPTION_TILING_METHOD:
+        tiling_method = optarg;
+        if (tiling_method != "grid"
+#if WITH_UNCOMPRESSED_CODEC
+            && tiling_method != "unci"
+#endif
+#if HEIF_ENABLE_EXPERIMENTAL_FEATURES
+            && tiling_method != "tili"
+#endif
+          ) {
+          std::cerr << "Invalid tiling method '" << tiling_method << "'\n";
+          exit(5);
+        }
+        break;
+      case OPTION_CUT_TILES:
+        cut_tiles = atoi(optarg);
+        break;
+      case OPTION_UNCI_COMPRESSION: {
+        std::string option(optarg);
+        if (option == "none") {
+          unci_compression = heif_unci_compression_off;
+        }
+        else if (option == "brotli") {
+          unci_compression = heif_unci_compression_brotli;
+        }
+        else if (option == "deflate") {
+          unci_compression = heif_unci_compression_deflate;
+        }
+        else if (option == "zlib") {
+          unci_compression = heif_unci_compression_zlib;
+        }
+        else {
+          std::cerr << "Invalid unci compression method '" << option << "'\n";
+          exit(5);
+        }
+        break;
+      }
+      case OPTION_COMPONENT_CONTENT_IDS:
+        option_component_content_ids = true;
+        break;
+      case 'C':
+        chroma_downsampling = optarg;
+        if (chroma_downsampling != "nn" &&
+            chroma_downsampling != "nearest-neighbor" &&
+            chroma_downsampling != "average" &&
+            chroma_downsampling != "sharp-yuv") {
+          fprintf(stderr, "Undefined chroma downsampling algorithm.\n");
+          exit(5);
+        }
+        if (chroma_downsampling == "nn") { // abbreviation
+          chroma_downsampling = "nearest-neighbor";
+        }
+#if !HAVE_LIBSHARPYUV
+        if (chroma_downsampling == "sharp-yuv") {
+          std::cerr << "Error: sharp-yuv chroma downsampling method has not been compiled into libheif.\n";
+          return 5;
+        }
+#endif
+        break;
+      case 'T':
+        use_tiling = true;
+        break;
+      case 'S':
+        encode_sequence = true;
+        break;
+      case 'V':
+        use_video_handler = true;
+        break;
+      case OPTION_SEQUENCES_TIMEBASE:
+        sequence_timebase = atoi(optarg);
+        break;
+      case OPTION_SEQUENCES_DURATIONS:
+        sequence_durations = atoi(optarg);
+        break;
+      case OPTION_SEQUENCES_FPS:
+        if (strcmp(optarg,"29.97")==0) {
+          sequence_durations = 1001;
+          sequence_timebase = 30000;
+        }
+        else {
+          double fps = std::atof(optarg);
+          sequence_timebase = 90000;
+          sequence_durations = (uint32_t)(90000 / fps + 0.5);
+        }
+        break;
+      case OPTION_SEQUENCES_REPETITIONS:
+        if (strcmp(optarg, "infinite")==0) {
+          sequence_repetitions = heif_sequence_maximum_number_of_repetitions;
+        }
+        else {
+          sequence_repetitions = atoi(optarg);
+          if (sequence_repetitions == 0) {
+            std::cerr << "Sequence repetitions may not be 0.\n";
+            return 5;
+          }
+        }
+        break;
+      case OPTION_SEQUENCES_GOP_STRUCTURE:
+        if (prefix_compare(optarg, "intra-only")) {
+          sequence_gop_structure = heif_sequence_gop_structure_intra_only;
+        }
+        else if (prefix_compare(optarg, "low-delay") || prefix_compare(optarg, "p")) {
+          sequence_gop_structure = heif_sequence_gop_structure_lowdelay;
+        }
+        else if (prefix_compare(optarg, "unrestricted") || prefix_compare(optarg, "b")) {
+          sequence_gop_structure = heif_sequence_gop_structure_unrestricted;
+        }
+        else {
+          std::cerr << "Invalid GOP structure argument\n";
+          return 5;
+        }
+        break;
+      case OPTION_SEQUENCES_MIN_KEYFRAME_DISTANCE:
+        sequence_keyframe_distance_min = atoi(optarg);
+        if (sequence_keyframe_distance_min < 0) {
+          std::cerr << "Keyframe distance must be >= 0\n";
+          return 5;
+        }
+        break;
+      case OPTION_SEQUENCES_MAX_KEYFRAME_DISTANCE:
+        sequence_keyframe_distance_max = atoi(optarg);
+        if (sequence_keyframe_distance_max < 0) {
+          std::cerr << "Keyframe distance must be >= 0\n";
+          return 5;
+        }
+        break;
+      case OPTION_SEQUENCES_MAX_FRAMES:
+        sequence_max_frames = atoi(optarg);
+        if (sequence_max_frames <= 0) {
+          std::cerr << "Maximum number of frames must be >= 1\n";
+          return 5;
+        }
+        break;
+      case OPTION_COLOR_PROFILE_PRESET:
+        if (strcmp(optarg, "auto")==0) {
+          output_color_profile_preset = heif_output_nclx_color_profile_preset_automatic;
+        }
+        else if (strcmp(optarg, "custom")==0) {
+          output_color_profile_preset = heif_output_nclx_color_profile_preset_custom;
+        }
+        else if (strcmp(optarg, "compatible")==0) {
+          output_color_profile_preset = heif_output_nclx_color_profile_preset_compatible;
+        }
+        else if (strcmp(optarg, "601")==0) {
+          output_color_profile_preset = heif_output_nclx_color_profile_preset_Rec_601;
+        }
+        else if (strcmp(optarg, "709")==0) {
+          output_color_profile_preset = heif_output_nclx_color_profile_preset_Rec_709;
+        }
+        else if (strcmp(optarg, "2020")==0) {
+          output_color_profile_preset = heif_output_nclx_color_profile_preset_Rec_2020;
+        }
+        else {
+          std::cerr << "Invalid color-profile preset.\n";
+          return 5;
+        }
+        break;
+      case OPTION_VMT_METADATA_FILE:
+        vmt_metadata_file = optarg;
+        break;
+      case OPTION_BINARY_METADATA_TRACK:
+        binary_metadata_track = true;
+        break;
+      case OPTION_METADATA_TRACK_URI:
+        metadata_track_uri = optarg;
+        break;
+      case OPTION_SET_CLLI: {
+        auto clli_args = parse_comma_separated_numeric_arguments<uint16_t>(optarg,
+                                                                           {
+                                                                             std::numeric_limits<uint16_t>::max(),
+                                                                             std::numeric_limits<uint16_t>::max()
+                                                                           });
+        if (clli_args.empty()) {
+          std::cerr << "Invalid arguments for --clli option.\n";
+        }
+        else {
+          heif_content_light_level clliVal;
+          clliVal.max_content_light_level = clli_args[0];
+          clliVal.max_pic_average_light_level = clli_args[1];
+          clli = clliVal;
+        }
+        break;
+      }
+      case OPTION_SET_PASP: {
+        auto pasp_args = parse_comma_separated_numeric_arguments<uint32_t>(optarg,
+                                                                           {
+                                                                             std::numeric_limits<uint32_t>::max(),
+                                                                             std::numeric_limits<uint32_t>::max()
+                                                                           });
+        if (pasp_args.empty()) {
+          std::cerr << "Invalid arguments for --pasp option.\n";
+        }
+        else {
+          pixel_aspect_ratio aspect_ratio;
+          aspect_ratio.h = pasp_args[0];
+          aspect_ratio.v = pasp_args[1];
+          pasp = aspect_ratio;
+        }
+        break;
+      }
+      case OPTION_DO_ROTATE: {
+        auto angle = parse_int(optarg);
+        if (!angle || (*angle != 0 && *angle != 90 && *angle != 180 && *angle != 270)) {
+          std::cerr << "Invalid rotation angle. Must be 0, 90, 180, or 270.\n";
+          return 5;
+        }
+        if (*angle == 90) {
+          transform = heif_orientation_concat(transform, heif_orientation_rotate_90_cw);
+        }
+        else if (*angle == 180) {
+          transform = heif_orientation_concat(transform, heif_orientation_rotate_180);
+        }
+        else if (*angle == 270) {
+          transform = heif_orientation_concat(transform, heif_orientation_rotate_270_cw);
+        }
+        break;
+      }
+      case OPTION_DO_FLIP_H:
+        transform = heif_orientation_concat(transform, heif_orientation_flip_horizontally);
+        break;
+      case OPTION_DO_FLIP_V:
+        transform = heif_orientation_concat(transform, heif_orientation_flip_vertically);
+        break;
+      case OPTION_ADD_MIME_ITEM:
+        option_mime_item_type = optarg;
+        break;
+      case OPTION_MIME_ITEM_FILE:
+        option_mime_item_file = optarg;
+        break;
+      case OPTION_MIME_ITEM_NAME:
+        option_mime_item_name = optarg;
+        break;
+#if HEIF_ENABLE_EXPERIMENTAL_FEATURES
+      case OPTION_TURTLE:
+        option_turtle_file = optarg;
+        break;
+      case OPTION_EMBED_TURTLE:
+        option_embed_turtle = true;
+        break;
+#endif
+      case OPTION_METADATA_COMPRESSION: {
+        bool success = set_metadata_compression_method(optarg);
+        if (!success) {
+          exit(5);
+        }
+        break;
+      }
+      case OPTION_SEQUENCES_GIMI_TRACK_ID:
+        option_gimi_track_id = optarg;
+        break;
+      case OPTION_SEQUENCES_SAI_DATA_FILE:
+        option_sai_data_file = optarg;
+        break;
+#if HEIF_WITH_OMAF
+      case OPTION_SET_OMAF_IMAGE_PROJECTION:
+        if (strcmp(optarg, "equirectangular") == 0) {
+          omaf_image_projection = heif_omaf_image_projection_equirectangular;
+        } else if (strcmp(optarg, "cube-map") == 0) {
+          omaf_image_projection = heif_omaf_image_projection_cube_map;
+        } else {
+          std::cerr << "image projection must be 'equirectangular' or 'cube-map'\n";
+          return 5;
+        }
+        break;
+#endif
+      case OPTION_ADD_COMPATIBLE_BRAND:
+        if (strlen(optarg) != 4) {
+          std::cerr << "Brand must be exactly 4 characters\n";
+          return 5;
+        }
+        additional_compatible_brands.push_back(heif_fourcc_to_brand(optarg));
+        break;
+      case OPTION_UNIF:
+        option_unif = true;
+        break;
+      case OPTION_RAW:
+        force_raw_input = true;
+        break;
+      case OPTION_RAW_WIDTH:
+        raw_input_params.width = atoi(optarg);
+        break;
+      case OPTION_RAW_HEIGHT:
+        raw_input_params.height = atoi(optarg);
+        break;
+      case OPTION_RAW_TYPE:
+        if (!parse_raw_pixel_type(optarg, &raw_input_params.datatype, &raw_input_params.bit_depth)) {
+          std::cerr << "Unknown raw pixel type: " << optarg << "\n";
+          exit(5);
+        }
+        break;
+      case OPTION_RAW_ENDIAN:
+        raw_input_params.big_endian = (std::string(optarg) == "big");
+        break;
+    }
+  }
 
   if (quality < 0 || quality > 100) {
     std::cerr << "Invalid quality factor. Must be between 0 and 100.\n";
     return 5;
   }
 
+  if ((force_enc_av1f ? 1 : 0) + (force_enc_vvc ? 1 : 0) + (force_enc_uncompressed ? 1 : 0) + (force_enc_jpeg ? 1 : 0) +
+      (force_enc_jpeg2000 ? 1 : 0) + (force_enc_avc ? 1 : 0) + (force_enc_hevc ? 1 : 0) > 1) {
+    std::cerr << "Choose at most one output compression format.\n";
+    return 5;
+  }
+
+  if (encode_sequence && (use_tiling || cut_tiles)) {
+    std::cerr << "Image sequences cannot be used together with tiling.\n";
+    return 5;
+  }
+
+  if (sequence_timebase <= 0) {
+    std::cerr << "Sequence clock tick rate cannot be zero.\n";
+    return 5;
+  }
+
+  if (sequence_durations <= 0) {
+    std::cerr << "Sequence frame durations cannot be zero.\n";
+    return 5;
+  }
+
+
+  if (!option_sai_data_file.empty() && !encode_sequence) {
+    std::cerr << "Image SAI data can only be used with sequences.\n";
+    return 5;
+  }
+
   if (logging_level > 0) {
     logging_level += 2;
 
@@ -1093,9 +1925,54 @@ int main(int argc, char** argv)
   }
 
 
-
   // ==============================================================================
 
+  struct heif_encoder* encoder = nullptr;
+
+  if (list_encoders) {
+    show_list_of_all_encoders();
+    return 0;
+  }
+
+  // --- determine output compression format (from output filename or command line parameter)
+
+  heif_compression_format compressionFormat;
+
+  if (force_enc_av1f) {
+    compressionFormat = heif_compression_AV1;
+  }
+  else if (force_enc_vvc) {
+    compressionFormat = heif_compression_VVC;
+  }
+  else if (force_enc_avc) {
+    compressionFormat = heif_compression_AVC;
+  }
+  else if (force_enc_uncompressed) {
+    compressionFormat = heif_compression_uncompressed;
+  }
+  else if (force_enc_jpeg) {
+    compressionFormat = heif_compression_JPEG;
+  }
+  else if (force_enc_jpeg2000) {
+    compressionFormat = heif_compression_JPEG2000;
+  }
+  else if (force_enc_htj2k) {
+    compressionFormat = heif_compression_HTJ2K;
+  }
+  else if (force_enc_hevc) {
+    compressionFormat = heif_compression_HEVC;
+  }
+  else {
+    compressionFormat = guess_compression_format_from_filename(output_filename);
+  }
+
+  if (compressionFormat == heif_compression_undefined) {
+    compressionFormat = heif_compression_HEVC;
+  }
+
+
+  // --- select encoder
+
   std::shared_ptr<heif_context> context(heif_context_alloc(),
                                         [](heif_context* c) { heif_context_free(c); });
   if (!context) {
@@ -1103,27 +1980,24 @@ int main(int argc, char** argv)
     return 1;
   }
 
+  if (option_unif) {
+    heif_context_set_unif(context.get(), 1);
+  }
 
-  struct heif_encoder* encoder = nullptr;
 
-#define MAX_ENCODERS 5
+#define MAX_ENCODERS 10
   const heif_encoder_descriptor* encoder_descriptors[MAX_ENCODERS];
-  int count = heif_context_get_encoder_descriptors(context.get(),
-                                                   enc_av1f ? heif_compression_AV1 : heif_compression_HEVC,
-                                                   nullptr,
-                                                   encoder_descriptors, MAX_ENCODERS);
-
-  if (list_encoders) {
-    show_list_of_encoders(encoder_descriptors, count);
-    return 0;
-  }
+  int count = heif_get_encoder_descriptors(compressionFormat,
+                                           nullptr,
+                                           encoder_descriptors, MAX_ENCODERS);
+#undef MAX_ENCODERS
 
   const heif_encoder_descriptor* active_encoder_descriptor = nullptr;
   if (count > 0) {
     int idx = 0;
     if (encoderId != nullptr) {
       for (int i = 0; i <= count; i++) {
-        if (i==count) {
+        if (i == count) {
           std::cerr << "Unknown encoder ID. Choose one from the list below.\n";
           show_list_of_encoders(encoder_descriptors, count);
           return 5;
@@ -1145,139 +2019,481 @@ int main(int argc, char** argv)
     active_encoder_descriptor = encoder_descriptors[idx];
   }
   else {
-    std::cerr << "No " << (enc_av1f ? "AV1" : "HEVC") << " encoder available.\n";
+    std::cerr << "No " << get_compression_format_name(compressionFormat) << " encoder available.\n";
     return 5;
   }
 
-
   if (option_show_parameters) {
     list_encoder_parameters(encoder);
+    heif_encoder_release(encoder);
     return 0;
   }
 
-
   if (optind > argc - 1) {
     show_help(argv[0]);
     return 0;
   }
 
 
-  struct heif_error error;
+  if (lossless && !heif_encoder_descriptor_supports_lossless_compression(active_encoder_descriptor)) {
+    std::cerr << "Warning: the selected encoder does not support lossless encoding. Encoding in lossy mode.\n";
+    lossless = false;
+  }
+
+  // If we were given a list of filenames and no '-o' option, check whether the last filename is the desired output filename.
+
+  if (output_filename.empty() && argc>1) {
+    if (guess_compression_format_from_filename(argv[argc-1]) != heif_compression_undefined) {
+      output_filename = argv[argc-1];
+      argc--;
+    }
+  }
 
+  std::vector<std::string> args;
   for (; optind < argc; optind++) {
-    std::string input_filename = argv[optind];
+    args.emplace_back(argv[optind]);
+  }
 
-    if (output_filename.empty()) {
-      std::string filename_without_suffix;
-      std::string::size_type dot_position = input_filename.find_last_of('.');
-      if (dot_position != std::string::npos) {
-        filename_without_suffix = input_filename.substr(0, dot_position);
-      }
-      else {
-        filename_without_suffix = input_filename;
-      }
 
-      output_filename = filename_without_suffix + (enc_av1f ? ".avif" : ".heic");
+  // If we get a list of image filenames, but no '-o' option, assume that the last option
+  // denotes the output filename.
+
+  if (output_filename.empty() && args.size() > 1) {
+    output_filename = args.back();
+    args.pop_back();
+  }
+
+
+  if (!lossless) {
+    heif_encoder_set_lossy_quality(encoder, quality);
+  }
+
+  heif_encoder_set_logging_level(encoder, logging_level);
+
+  set_params(encoder, raw_params);
+  struct heif_encoding_options* options = heif_encoding_options_alloc();
+  options->save_two_colr_boxes_when_ICC_and_nclx_available = (uint8_t) two_colr_boxes;
+
+  if (chroma_downsampling == "average") {
+    options->color_conversion_options.preferred_chroma_downsampling_algorithm = heif_chroma_downsampling_average;
+    options->color_conversion_options.only_use_preferred_chroma_algorithm = true;
+  }
+  else if (chroma_downsampling == "sharp-yuv") {
+    options->color_conversion_options.preferred_chroma_downsampling_algorithm = heif_chroma_downsampling_sharp_yuv;
+    options->color_conversion_options.only_use_preferred_chroma_algorithm = true;
+  }
+  else if (chroma_downsampling == "nearest-neighbor") {
+    options->color_conversion_options.preferred_chroma_downsampling_algorithm = heif_chroma_downsampling_nearest_neighbor;
+    options->color_conversion_options.only_use_preferred_chroma_algorithm = true;
+  }
+
+  options->unci_compression = unci_compression;
+
+  // --- if no output filename was given, synthesize one from the first input image filename
+
+  if (output_filename.empty()) {
+    const std::string& first_input_filename = args[0];
+
+    std::string filename_without_suffix;
+    std::string::size_type dot_position = first_input_filename.find_last_of('.');
+    if (dot_position != std::string::npos) {
+      filename_without_suffix = first_input_filename.substr(0, dot_position);
     }
+    else {
+      filename_without_suffix = first_input_filename;
+    }
+
+    std::string suffix = suffix_for_compression_format(compressionFormat);
+    output_filename = filename_without_suffix + '.' + suffix;
+  }
+
+
+  int ret;
+
+  if (!encode_sequence) {
+    ret = do_encode_images(context.get(), encoder, options, args);
+  }
+  else {
+    ret = do_encode_sequence(context.get(), encoder, options, args);
+  }
+
+  if (ret != 0) {
+    heif_encoding_options_free(options);
+    heif_encoder_release(encoder);
+    return ret;
+  }
+
+  // --- add extra MIME item with user data
 
+  ret = add_mime_item(context.get());
+  if (ret != 0) {
+    heif_encoding_options_free(options);
+    heif_encoder_release(encoder);
+    return ret;
+  }
+
+
+  // --- write HEIF file
+
+  for (heif_brand2 brand : additional_compatible_brands) {
+    heif_context_add_compatible_brand(context.get(), brand);
+  }
+
+  heif_error error = heif_context_write_to_file(context.get(), output_filename.c_str());
+  if (error.code) {
+    std::cerr << error.message << "\n";
+    return 5;
+  }
 
-    // ==============================================================================
+  heif_encoding_options_free(options);
+  heif_encoder_release(encoder);
+
+  return 0;
+}
 
-    // get file type from file name
 
-    std::string suffix;
-    auto suffix_pos = input_filename.find_last_of('.');
-    if (suffix_pos != std::string::npos) {
-      suffix = input_filename.substr(suffix_pos + 1);
-      std::transform(suffix.begin(), suffix.end(), suffix.begin(), ::tolower);
+int add_mime_item(heif_context* context)
+{
+  if (!option_mime_item_file.empty() || !option_mime_item_type.empty()) {
+    if (option_mime_item_file.empty() || option_mime_item_type.empty()) {
+      std::cerr << "Options --add-mime-item and --mime-item-file have to be used together\n";
+      return 5;
     }
 
-    enum
-    {
-      PNG, JPEG, Y4M
-    } filetype = JPEG;
-    if (suffix == "png") {
-      filetype = PNG;
+    std::ifstream istr(option_mime_item_file.c_str(), std::ios::binary | std::ios::ate);
+    if (!istr) {
+      std::cerr << "Failed to open file for MIME item: '" << option_mime_item_file << "'\n";
+      return 5;
     }
-    else if (suffix == "y4m") {
-      filetype = Y4M;
+
+    // Get size by seeking to the end (thanks to ios::ate)
+    std::streamsize size = istr.tellg();
+    if (size < 0) {
+      std::cerr << "Querying size of file '" << option_mime_item_file << "' failed.\n";
+      return 5;
     }
 
-    std::shared_ptr<heif_image> image;
-    if (filetype == PNG) {
-      image = loadPNG(input_filename.c_str(), output_bit_depth);
+    std::vector<uint8_t> buffer(size);
+
+    // Seek back to beginning and read
+    istr.seekg(0, std::ios::beg);
+    istr.read(reinterpret_cast<char*>(buffer.data()), size);
+
+    heif_item_id itemId;
+    heif_context_add_mime_item(context, option_mime_item_type.c_str(),
+                               metadata_compression_method,
+                               buffer.data(), (int)buffer.size(),
+                               &itemId);
+
+    if (!option_mime_item_name.empty()) {
+      heif_item_set_item_name(context, itemId, option_mime_item_name.c_str());
     }
-    else if (filetype == Y4M) {
-      image = loadY4M(input_filename.c_str());
+  }
+
+#if HEIF_ENABLE_EXPERIMENTAL_FEATURES
+  // --- attach Turtle (RDF) file as MIME item
+
+  if (option_embed_turtle && !option_turtle_file.empty()) {
+    std::ifstream istr(option_turtle_file.c_str(), std::ios::binary | std::ios::ate);
+    if (!istr) {
+      std::cerr << "Failed to open turtle file: '" << option_turtle_file << "'\n";
+      return 5;
     }
-    else {
-      image = loadJPEG(input_filename.c_str());
+
+    std::streamsize size = istr.tellg();
+    if (size < 0) {
+      std::cerr << "Querying size of turtle file '" << option_turtle_file << "' failed.\n";
+      return 5;
     }
 
-    heif_color_profile_nclx nclx;
-    nclx.matrix_coefficients = (heif_matrix_coefficients) nclx_matrix_coefficients;
-    nclx.transfer_characteristics = (heif_transfer_characteristics) nclx_transfer_characteristic;
-    nclx.color_primaries = (heif_color_primaries) nclx_colour_primaries;
-    nclx.full_range_flag = (uint8_t) nclx_full_range;
+    std::vector<uint8_t> buffer(size);
+    istr.seekg(0, std::ios::beg);
+    istr.read(reinterpret_cast<char*>(buffer.data()), size);
+
+    heif_item_id itemId;
+    heif_context_add_mime_item(context, "text/turtle",
+                               heif_metadata_compression_off,
+                               buffer.data(), (int)buffer.size(),
+                               &itemId);
+  }
+#endif
+
+  return 0;
+}
+
+
+int do_encode_images(heif_context* context, heif_encoder* encoder, heif_encoding_options* options, const std::vector<std::string>& args)
+{
+  std::shared_ptr<heif_image> primary_image;
+
+  bool is_primary_image = true;
+
+  std::vector<heif_item_id> encoded_image_ids;
+
+  for (std::string input_filename : args) {
 
-    //heif_image_set_nclx_color_profile(image.get(), &nclx);
+    InputImage input_image;
+    heif_image_tiling tiling{};
+    std::shared_ptr<input_tiles_generator> tile_generator;
+    std::shared_ptr<TiledTiffReader> tiff_reader_for_pyramid;
 
-    if (lossless) {
-      if (heif_encoder_descriptor_supportes_lossless_compression(active_encoder_descriptor)) {
-        heif_encoder_set_lossless(encoder, lossless);
+#if HAVE_LIBTIFF
+    // Auto-detect tiled TIFFs when not using explicit tiling options
+    if (!use_tiling && cut_tiles == 0) {
+      std::string suffix;
+      auto suffix_pos = input_filename.find_last_of('.');
+      if (suffix_pos != std::string::npos) {
+        suffix = input_filename.substr(suffix_pos + 1);
+        std::transform(suffix.begin(), suffix.end(), suffix.begin(), ::tolower);
       }
-      else {
-        std::cerr << "Warning: the selected encoder does not support lossless encoding. Encoding in lossy mode.\n";
+
+      if (suffix == "tif" || suffix == "tiff") {
+        heif_error tiff_err;
+        auto tiff_reader = TiledTiffReader::open(input_filename.c_str(), &tiff_err);
+        if (tiff_err.code != heif_error_Ok) {
+          std::cerr << "Error opening TIFF: " << tiff_err.message << "\n";
+          return 1;
+        }
+
+        if (tiff_reader) {
+          auto shared_tiff_reader = std::shared_ptr<TiledTiffReader>(std::move(tiff_reader));
+          auto tiff_gen = std::make_shared<input_tiles_generator_tiff>(shared_tiff_reader);
+
+          // Read tile (0,0) as representative for nclx profile
+          input_image = tiff_gen->get_image(0, 0, output_bit_depth);
+          tiff_gen->readExif(&input_image);
+
+          tiling.version = 1;
+          tiling.num_columns = tiff_gen->nColumns();
+          tiling.num_rows = tiff_gen->nRows();
+          tiling.tile_width = tiff_gen->tileWidth();
+          tiling.tile_height = tiff_gen->tileHeight();
+          tiling.image_width = tiff_gen->imageWidth();
+          tiling.image_height = tiff_gen->imageHeight();
+          tiling.number_of_extra_dimensions = 0;
+
+          tile_generator = tiff_gen;
+          tiff_reader_for_pyramid = shared_tiff_reader;
+        }
       }
     }
+#endif
 
-    heif_encoder_set_lossy_quality(encoder, quality);
-    heif_encoder_set_logging_level(encoder, logging_level);
+    // If no tiled TIFF was detected, load the image normally
+    if (!input_image.image) {
+      input_image = load_image(input_filename, output_bit_depth);
+    }
 
-    set_params(encoder, raw_params);
+    std::shared_ptr<heif_image> image = input_image.image;
 
-    struct heif_encoding_options* options = heif_encoding_options_alloc();
-    options->save_alpha_channel = (uint8_t) master_alpha;
-    options->save_two_colr_boxes_when_ICC_and_nclx_available = (uint8_t)two_colr_boxes;
-    options->output_nclx_profile = &nclx;
+    if (use_tiling) {
+      tile_generator = determine_input_images_tiling(input_filename, tiled_input_x_y);
+      if (tile_generator) {
+        tiling.version = 1;
 
-    if (crop_to_even_size) {
-      if (heif_image_get_primary_width(image.get()) == 1 ||
-          heif_image_get_primary_height(image.get()) == 1) {
-        std::cerr << "Image only has a size of 1 pixel width or height. Cannot crop to even size.\n";
-        return 1;
+        tiling.num_columns = tile_generator->nColumns();
+        tiling.num_rows = tile_generator->nRows();
+        tiling.tile_width = heif_image_get_primary_width(image.get());
+        tiling.tile_height = heif_image_get_primary_height(image.get());
+        tiling.image_width = tiling.num_columns * tiling.tile_width;
+        tiling.image_height = tiling.num_rows * tiling.tile_height;
+        tiling.number_of_extra_dimensions = 0;
       }
 
-      std::cerr << "Warning: option --even-size/-E is deprecated as it is not needed anymore.\n";
-
-      int right = heif_image_get_primary_width(image.get()) % 2;
-      int bottom = heif_image_get_primary_height(image.get()) % 2;
+      if (tiled_image_width) tiling.image_width = tiled_image_width;
+      if (tiled_image_height) tiling.image_height = tiled_image_height;
 
-      error = heif_image_crop(image.get(), 0, right, 0, bottom);
-      if (error.code != 0) {
-        heif_encoding_options_free(options);
-        std::cerr << "Could not crop image: " << error.message << "\n";
-        return 1;
+      if (!tile_generator || tile_generator->nTiles()==1) {
+        std::cerr << "Cannot enumerate input tiles. Please use filenames with the two tile coordinates in the name.\n";
+        return 5;
       }
     }
+    else if (cut_tiles != 0) {
+      auto cutting_tile_generator = std::make_shared<input_tiles_generator_cut_image>(input_filename.c_str(),
+                                                                         cut_tiles, output_bit_depth);
+      tile_generator = cutting_tile_generator;
+
+      tiling.num_columns = tile_generator->nColumns();
+      tiling.num_rows = tile_generator->nRows();
+      tiling.tile_width = cut_tiles;
+      tiling.tile_height = cut_tiles;
+      tiling.image_width = cutting_tile_generator->get_image_width();
+      tiling.image_height = cutting_tile_generator->get_image_height();
+      tiling.number_of_extra_dimensions = 0;
+    }
+
+    if (!primary_image) {
+      primary_image = image;
+    }
+
+#if HAVE_GETTIMEOFDAY
+    if (run_benchmark) {
+      gettimeofday(&time_encoding_start, nullptr);
+    }
+#endif
+
+    heif_color_profile_nclx* nclx;
+    heif_error error = create_output_nclx_profile_and_configure_encoder(encoder, &nclx, primary_image,
+                                                                        lossless, output_color_profile_preset);
+    if (error.code) {
+      std::cerr << error.message << "\n";
+      return 5;
+    }
+
+    options->save_alpha_channel = (uint8_t) master_alpha;
+    options->output_nclx_profile = nclx;
+    options->image_orientation = heif_orientation_concat(input_image.orientation, transform);
 
     if (premultiplied_alpha) {
       heif_image_set_premultiplied_alpha(image.get(), premultiplied_alpha);
     }
 
+    heif_image_handle* handle;
 
-    struct heif_image_handle* handle;
-    error = heif_context_encode_image(context.get(),
-                                      image.get(),
-                                      encoder,
-                                      options,
-                                      &handle);
-    if (error.code != 0) {
-      heif_encoding_options_free(options);
-      std::cerr << "Could not encode HEIF/AVIF file: " << error.message << "\n";
+#if HEIF_ENABLE_EXPERIMENTAL_FEATURES
+    TurtleContentIDs turtle_ids;
+    if (!option_turtle_file.empty()) {
+      turtle_ids = parse_turtle_content_ids(option_turtle_file);
+    }
+#endif
+
+    if (tile_generator) {
+#if HEIF_ENABLE_EXPERIMENTAL_FEATURES
+      handle = encode_tiled(context, encoder, options, output_bit_depth, tile_generator, tiling,
+                            option_turtle_file.empty() ? nullptr : &turtle_ids.tile_content_ids, 0);
+#else
+      handle = encode_tiled(context, encoder, options, output_bit_depth, tile_generator, tiling);
+#endif
+    }
+    else {
+      error = heif_context_encode_image(context,
+                                        image.get(),
+                                        encoder,
+                                        options,
+                                        &handle);
+      if (error.code != 0) {
+        heif_nclx_color_profile_free(nclx);
+        std::cerr << "Could not encode HEIF/AVIF file: " << error.message << "\n";
+        return 1;
+      }
+    }
+
+    if (handle==nullptr) {
+      std::cerr << "Could not encode image\n";
       return 1;
     }
 
+    if (clli) {
+      heif_image_handle_set_content_light_level(handle, &*clli);
+    }
+
+    if (pasp) {
+      heif_image_handle_set_pixel_aspect_ratio(handle, pasp->h, pasp->v);
+    }
+
+
+#if HEIF_ENABLE_EXPERIMENTAL_FEATURES
+    if (!option_turtle_file.empty() && !turtle_ids.image_content_id.empty()) {
+      heif_image_handle_set_gimi_content_id(handle, turtle_ids.image_content_id.c_str());
+    }
+#endif
+      
+#if HEIF_WITH_OMAF
+    if (omaf_image_projection) {
+      heif_image_handle_set_omaf_image_projection(handle, *omaf_image_projection);
+    }
+#endif
+
+    if (option_component_content_ids && force_enc_uncompressed) {
+      uint32_t num_components = heif_image_handle_get_number_of_cmpd_components(handle);
+      for (uint32_t i = 0; i < num_components; i++) {
+        std::string uuid = generate_random_uuid_urn();
+        heif_image_handle_set_gimi_component_content_id(handle, i, uuid.c_str());
+      }
+    }
+
+    if (is_primary_image) {
+      heif_context_set_primary_image(context, handle);
+    }
+
+    encoded_image_ids.push_back(heif_image_handle_get_item_id(handle));
+
+#if HEIF_ENABLE_EXPERIMENTAL_FEATURES && HAVE_LIBTIFF
+    // Auto-encode TIFF pyramid overviews
+    if (tiff_reader_for_pyramid && !tiff_reader_for_pyramid->overviews().empty()) {
+      heif_item_id fullres_id = heif_image_handle_get_item_id(handle);
+      std::vector<heif_item_id> pyramid_ids;
+      pyramid_ids.push_back(fullres_id);
+
+      int ov_layer_index = 1;
+      for (const auto& ov : tiff_reader_for_pyramid->overviews()) {
+        if (!tiff_reader_for_pyramid->setDirectory(ov.dir_index)) {
+          std::cerr << "Warning: could not switch to TIFF overview directory " << ov.dir_index << "\n";
+          continue;
+        }
+
+        auto ov_gen = std::make_shared<input_tiles_generator_tiff>(tiff_reader_for_pyramid);
+
+        heif_image_tiling ov_tiling{};
+        ov_tiling.version = 1;
+        ov_tiling.num_columns = ov_gen->nColumns();
+        ov_tiling.num_rows = ov_gen->nRows();
+        ov_tiling.tile_width = ov_gen->tileWidth();
+        ov_tiling.tile_height = ov_gen->tileHeight();
+        ov_tiling.image_width = ov_gen->imageWidth();
+        ov_tiling.image_height = ov_gen->imageHeight();
+        ov_tiling.number_of_extra_dimensions = 0;
+
+        heif_image_handle* ov_handle = encode_tiled(context, encoder, options, output_bit_depth, ov_gen, ov_tiling,
+                                                    option_turtle_file.empty() ? nullptr : &turtle_ids.tile_content_ids,
+                                                    ov_layer_index);
+        if (ov_handle) {
+          pyramid_ids.push_back(heif_image_handle_get_item_id(ov_handle));
+          heif_image_handle_release(ov_handle);
+        }
+        ov_layer_index++;
+      }
+
+      // Restore directory 0 for any subsequent use
+      tiff_reader_for_pyramid->setDirectory(0);
+
+      if (pyramid_ids.size() > 1) {
+        error = heif_context_add_pyramid_entity_group(context, pyramid_ids.data(), pyramid_ids.size(), nullptr);
+        if (error.code) {
+          std::cerr << "Cannot create pyramid entity group: " << error.message << "\n";
+          return 5;
+        }
+        std::cout << "Created pyramid entity group with " << pyramid_ids.size() << " layers\n";
+      }
+    }
+#endif
+
+    // write EXIF to HEIC
+    if (!input_image.exif.empty()) {
+      // Note: we do not modify the EXIF Orientation here because we want it to match the HEIF transforms.
+      // TODO: is this a good choice? Or should we set it to 1 (normal) so that other, faulty software will not transform it once more?
+
+      error = heif_context_add_exif_metadata(context, handle,
+                                             input_image.exif.data(), (int) input_image.exif.size());
+      if (error.code != 0) {
+        heif_nclx_color_profile_free(nclx);
+        std::cerr << "Could not write EXIF metadata: " << error.message << "\n";
+        return 1;
+      }
+    }
+
+    // write XMP to HEIC
+    if (!input_image.xmp.empty()) {
+      error = heif_context_add_XMP_metadata2(context, handle,
+                                             input_image.xmp.data(), (int) input_image.xmp.size(),
+                                             metadata_compression_method);
+      if (error.code != 0) {
+        heif_nclx_color_profile_free(nclx);
+        std::cerr << "Could not write XMP metadata: " << error.message << "\n";
+        return 1;
+      }
+    }
+
     if (thumbnail_bbox_size > 0) {
       // encode thumbnail
 
@@ -1285,7 +2501,7 @@ int main(int argc, char** argv)
 
       options->save_alpha_channel = master_alpha && thumb_alpha;
 
-      error = heif_context_encode_thumbnail(context.get(),
+      error = heif_context_encode_thumbnail(context,
                                             image.get(),
                                             handle,
                                             encoder,
@@ -1293,7 +2509,7 @@ int main(int argc, char** argv)
                                             thumbnail_bbox_size,
                                             &thumbnail_handle);
       if (error.code) {
-        heif_encoding_options_free(options);
+        heif_nclx_color_profile_free(nclx);
         std::cerr << "Could not generate thumbnail: " << error.message << "\n";
         return 5;
       }
@@ -1303,17 +2519,299 @@ int main(int argc, char** argv)
       }
     }
 
+#if HAVE_GETTIMEOFDAY
+    if (run_benchmark) {
+      gettimeofday(&time_encoding_end, nullptr);
+    }
+#endif
+
     heif_image_handle_release(handle);
-    heif_encoding_options_free(options);
+    heif_nclx_color_profile_free(nclx);
+
+    is_primary_image = false;
   }
 
-  heif_encoder_release(encoder);
+  if (!property_pitm_description.empty()) {
+    heif_image_handle* primary_image_handle;
+    struct heif_error err = heif_context_get_primary_image_handle(context, &primary_image_handle);
+    if (err.code) {
+      std::cerr << "No primary image set, cannot set user description\n";
+      return 5;
+    }
+
+    heif_item_id pitm_id = heif_image_handle_get_item_id(primary_image_handle);
+
+    heif_property_user_description udes;
+    udes.lang = nullptr;
+    udes.name = nullptr;
+    udes.tags = nullptr;
+    udes.description = property_pitm_description.c_str();
+    err = heif_item_add_property_user_description(context, pitm_id, &udes, nullptr);
+    if (err.code) {
+      std::cerr << "Cannot set user description\n";
+      return 5;
+    }
+
+    heif_image_handle_release(primary_image_handle);
+  }
+
+#if HEIF_ENABLE_EXPERIMENTAL_FEATURES
+  if (add_pyramid_group && encoded_image_ids.size() > 1) {
+    heif_error error = heif_context_add_pyramid_entity_group(context, encoded_image_ids.data(), encoded_image_ids.size(), nullptr);
+    if (error.code) {
+      std::cerr << "Cannot set multi-resolution pyramid: " << error.message << "\n";
+      return 5;
+    }
+  }
+#endif
+
+  if (run_benchmark) {
+    double psnr = compute_psnr(primary_image.get(), output_filename);
+    std::cout << "PSNR: " << std::setprecision(2) << std::fixed << psnr << " ";
+
+#if HAVE_GETTIMEOFDAY
+    double t = (double) (time_encoding_end.tv_sec - time_encoding_start.tv_sec) + (double) (time_encoding_end.tv_usec - time_encoding_start.tv_usec) / 1000000.0;
+    std::cout << "time: " << std::setprecision(1) << std::fixed << t << " ";
+#endif
+
+    std::ifstream istr(output_filename.c_str());
+    istr.seekg(0, std::ios_base::end);
+    std::streamoff size = istr.tellg();
+    std::cout << "size: " << size << "\n";
+  }
+
+  return 0;
+}
+
+
+
+
+std::vector<std::string> deflate_input_filenames(const std::string& filename_example)
+{
+  std::regex pattern(R"((.*\D)?(\d+)(\..+)$)");
+  std::smatch match;
+
+  if (!std::regex_match(filename_example, match, pattern)) {
+    return {filename_example};
+  }
+
+  std::string prefix = match[1];
+
+  auto p = std::filesystem::absolute(std::filesystem::path(prefix));
+  std::filesystem::path directory = p.parent_path();
+  std::string filename_prefix = p.filename().string(); // TODO: we could also use u8string(), but it is not well supported in C++20
+  std::string number = match[2];
+  std::string suffix = match[3];
+
+
+  std::string patternString = filename_prefix + "(\\d+)" + suffix + "$";
+  pattern = patternString;
+
+  uint32_t digits = std::numeric_limits<uint32_t>::max();
+  uint32_t start = std::numeric_limits<uint32_t>::max();
+  uint32_t end = 0;
+
+  for (const auto& dirEntry : std::filesystem::directory_iterator(directory))
+  {
+    if (dirEntry.is_regular_file()) {
+      std::string s{dirEntry.path().filename().string()};
+
+      if (std::regex_match(s, match, pattern)) {
+        digits = std::min(digits, (uint32_t)match[1].length());
+
+        uint32_t number = std::stoi(match[1]);
+        start = std::min(start, number);
+        end = std::max(end, number);
+      }
+    }
+  }
+
+
+  std::vector<std::string> files;
+
+  for (uint32_t i=start;i<=end;i++)
+  {
+    std::stringstream sstr;
+
+    sstr << prefix << std::setw(digits) << std::setfill('0') << i << suffix;
+
+    std::filesystem::path p = directory / sstr.str();
+    files.emplace_back(p.string());
+  }
+
+  return files;
+}
+
+
+int do_encode_sequence(heif_context* context, heif_encoder* encoder, heif_encoding_options* options, std::vector<std::string> args)
+{
+  if (args.size() == 1) {
+    args = deflate_input_filenames(args[0]);
+  }
+
+  size_t currImage = 0;
+
+  size_t nImages = args.size();
+  if (sequence_max_frames && nImages > static_cast<size_t>(sequence_max_frames)) {
+    nImages = sequence_max_frames;
+  }
+
+  // --- optionally load SAI data to be used for the frames
+
+  SAI_datafile sai_data;
+  if (!option_sai_data_file.empty()) {
+    sai_data.load_sai_data_from_file(option_sai_data_file.c_str());
+  }
+
+
+  uint16_t image_width=0, image_height=0;
+
+  bool first_image = true;
+
+  heif_track* track = nullptr;
+  heif_sequence_encoding_options* encoding_options = nullptr;
+
+  for (std::string input_filename : args) {
+    currImage++;
+    if (currImage > nImages) {
+      break;
+    }
+
+    std::cout << "\rencoding sequence image " << currImage << "/" << nImages;
+    std::cout.flush();
+
+    InputImage input_image = load_image(input_filename, output_bit_depth);
+
+    std::shared_ptr<heif_image> image = input_image.image;
 
-  error = heif_context_write_to_file(context.get(), output_filename.c_str());
+    int w = heif_image_get_primary_width(image.get());
+    int h = heif_image_get_primary_height(image.get());
+
+    if (w > 0xFFFF || h > 0xFFFF) {
+      std::cerr << "maximum image size of 65535x65535 exceeded\n";
+      return 5;
+    }
+
+    if (first_image) {
+      heif_track_options* track_options = heif_track_options_alloc();
+      heif_track_options_set_timescale(track_options, sequence_timebase);
+
+      if (!option_gimi_track_id.empty()) {
+        heif_track_options_set_gimi_track_id(track_options, option_gimi_track_id.c_str());
+      }
+
+      if (sai_data.tai_clock_info) {
+        heif_track_options_enable_sample_tai_timestamps(track_options,
+                                                        sai_data.tai_clock_info,
+                                                        heif_sample_aux_info_presence_optional);
+      }
+
+      if (!sai_data.gimi_content_ids.empty()) {
+        heif_track_options_enable_sample_gimi_content_ids(track_options,
+                                                          heif_sample_aux_info_presence_optional);
+      }
+
+      heif_context_set_sequence_timescale(context, sequence_timebase);
+      heif_context_set_number_of_sequence_repetitions(context, sequence_repetitions);
+
+      encoding_options = heif_sequence_encoding_options_alloc();
+      encoding_options->gop_structure = sequence_gop_structure;
+      encoding_options->keyframe_distance_min = sequence_keyframe_distance_min;
+      encoding_options->keyframe_distance_max = sequence_keyframe_distance_max;
+      encoding_options->save_alpha_channel = master_alpha;
+
+      image_width = static_cast<uint16_t>(w);
+      image_height = static_cast<uint16_t>(h);
+
+      heif_context_add_visual_sequence_track(context,
+                                             image_width, image_height,
+                                             use_video_handler ? heif_track_type_video : heif_track_type_image_sequence,
+                                             track_options,
+                                             encoding_options,
+                                             &track);
+
+      heif_track_options_release(track_options);
+
+      first_image = false;
+    }
+
+    if (image_width != static_cast<uint16_t>(w) ||
+        image_height != static_cast<uint16_t>(h)) {
+      std::cerr << "image '" << input_filename << "' has size " << w << "x" << h
+                << " which is different from the first image size " << image_width << "x" << image_height << "\n";
+      return 5;
+    }
+
+    heif_color_profile_nclx* nclx;
+    heif_error error = create_output_nclx_profile_and_configure_encoder(encoder, &nclx, image, lossless, output_color_profile_preset);
+    if (error.code) {
+      std::cerr << error.message << "\n";
+      return 5;
+    }
+
+    //seq_options->save_alpha_channel = false; // TODO: sequences with alpha ?
+    encoding_options->output_nclx_profile = nclx;
+    //seq_options->image_orientation = heif_orientation_normal; // input_image.orientation;  TODO: sequence rotation
+
+    heif_image_set_duration(image.get(), sequence_durations);
+
+    // --- set SAI data
+
+    if (currImage-1 < sai_data.gimi_content_ids.size()) {
+      if (!sai_data.gimi_content_ids[currImage-1].empty()) {
+        heif_image_set_gimi_sample_content_id(image.get(), sai_data.gimi_content_ids[currImage-1].c_str());
+      }
+    }
+
+    if (currImage-1 < sai_data.tai_timestamps.size()) {
+      if (sai_data.tai_timestamps[currImage-1]) {
+        heif_image_set_tai_timestamp(image.get(), sai_data.tai_timestamps[currImage-1]);
+      }
+    }
+
+    // --- encode image
+
+    error = heif_track_encode_sequence_image(track, image.get(), encoder, encoding_options);
+    if (error.code) {
+      heif_nclx_color_profile_free(nclx);
+      std::cerr << "Cannot encode sequence image: " << error.message << "\n";
+      return 5;
+    }
+
+    heif_nclx_color_profile_free(nclx);
+  }
+
+  if (!track) {
+    std::cerr << "No input files could be encoded into sequence track\n";
+    return 5;
+  }
+
+  std::cout << "\n";
+
+  heif_error error = heif_track_encode_end_of_sequence(track, encoder);
   if (error.code) {
-    std::cerr << error.message << "\n";
+    std::cerr << "Cannot end sequence: " << error.message << "\n";
     return 5;
   }
 
+#if HEIF_ENABLE_EXPERIMENTAL_FEATURES
+  if (!vmt_metadata_file.empty()) {
+    int ret = encode_vmt_metadata_track(context, track, vmt_metadata_file, metadata_track_uri, binary_metadata_track);
+    if (ret) {
+      return ret;
+    }
+  }
+#endif
+
+  heif_track_release(track);
+  heif_sequence_encoding_options_release(encoding_options);
+
+
+  // --- add first image as image item
+
+  if (!use_video_handler) {
+    do_encode_images(context, encoder, options, {args[0]});
+  }
+
   return 0;
 }
diff --git a/examples/heif_gen_bayer.cc b/examples/heif_gen_bayer.cc
new file mode 100644
index 0000000000..c59f1b81c2
--- /dev/null
+++ b/examples/heif_gen_bayer.cc
@@ -0,0 +1,649 @@
+/*
+  libheif example application "heif-gen-bayer".
+
+  MIT License
+
+  Copyright (c) 2026 Dirk Farin <dirk.farin@gmail.com>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#include <cassert>
+#include <cstdlib>
+#include <cstring>
+#include <filesystem>
+#include <getopt.h>
+#include <iomanip>
+#include <iostream>
+#include <memory>
+#include <optional>
+#include <regex>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include <libheif/heif.h>
+#include <libheif/heif_sequences.h>
+#include <libheif/heif_uncompressed.h>
+
+#include "heifio/decoder_png.h"
+
+
+struct PatternDefinition
+{
+  std::string name;
+  uint16_t width;
+  uint16_t height;
+  std::vector<heif_uncompressed_component_type> cpat;
+};
+
+
+static const PatternDefinition patterns[] = {
+  // RGGB (standard Bayer)
+  //   R G
+  //   G B
+  {
+    "rggb", 2, 2,
+    {
+      heif_uncompressed_component_type_red,
+      heif_uncompressed_component_type_green,
+      heif_uncompressed_component_type_green,
+      heif_uncompressed_component_type_blue,
+    }
+  },
+
+  // RGBW (Red-Green-Blue-White) — 4×4
+  //   W G W R
+  //   G W B W
+  //   W B W G
+  //   R W G W
+  // White is an unfiltered (panchromatic) pixel → Y component type.
+  {
+    "rgbw", 4, 4,
+    {
+      heif_uncompressed_component_type_Y,
+      heif_uncompressed_component_type_green,
+      heif_uncompressed_component_type_Y,
+      heif_uncompressed_component_type_red,
+
+      heif_uncompressed_component_type_green,
+      heif_uncompressed_component_type_Y,
+      heif_uncompressed_component_type_blue,
+      heif_uncompressed_component_type_Y,
+
+      heif_uncompressed_component_type_Y,
+      heif_uncompressed_component_type_blue,
+      heif_uncompressed_component_type_Y,
+      heif_uncompressed_component_type_green,
+
+      heif_uncompressed_component_type_red,
+      heif_uncompressed_component_type_Y,
+      heif_uncompressed_component_type_green,
+      heif_uncompressed_component_type_Y,
+    }
+  },
+
+  // QBC (Quad Bayer Coding) — 4×4
+  //   G G R R
+  //   G G R R
+  //   B B G G
+  //   B B G G
+  {
+    "qbc", 4, 4,
+    {
+      heif_uncompressed_component_type_green,
+      heif_uncompressed_component_type_green,
+      heif_uncompressed_component_type_red,
+      heif_uncompressed_component_type_red,
+
+      heif_uncompressed_component_type_green,
+      heif_uncompressed_component_type_green,
+      heif_uncompressed_component_type_red,
+      heif_uncompressed_component_type_red,
+
+      heif_uncompressed_component_type_blue,
+      heif_uncompressed_component_type_blue,
+      heif_uncompressed_component_type_green,
+      heif_uncompressed_component_type_green,
+
+      heif_uncompressed_component_type_blue,
+      heif_uncompressed_component_type_blue,
+      heif_uncompressed_component_type_green,
+      heif_uncompressed_component_type_green,
+    }
+  },
+};
+
+static constexpr int num_patterns = sizeof(patterns) / sizeof(patterns[0]);
+
+
+static const PatternDefinition* find_pattern(const char* name)
+{
+  for (int i = 0; i < num_patterns; i++) {
+    if (strcasecmp(patterns[i].name.c_str(), name) == 0) {
+      return &patterns[i];
+    }
+  }
+  return nullptr;
+}
+
+
+static std::optional<PatternDefinition> parse_pattern_string(const char* str)
+{
+  std::string s(str);
+  size_t len = s.size();
+  if (len != 4 && len != 16) {
+    return {};
+  }
+
+  uint16_t dim = (len == 4) ? 2 : 4;
+  std::vector<heif_uncompressed_component_type> cpat;
+  cpat.reserve(len);
+
+  for (char c : s) {
+    switch (std::tolower(c)) {
+      case 'r': cpat.push_back(heif_uncompressed_component_type_red); break;
+      case 'g': cpat.push_back(heif_uncompressed_component_type_green); break;
+      case 'b': cpat.push_back(heif_uncompressed_component_type_blue); break;
+      default: return {};
+    }
+  }
+
+  return PatternDefinition{str, dim, dim, std::move(cpat)};
+}
+
+
+static std::vector<std::string> deflate_input_filenames(const std::string& filename_example)
+{
+  std::regex pattern(R"((.*\D)?(\d+)(\..+)$)");
+  std::smatch match;
+
+  if (!std::regex_match(filename_example, match, pattern)) {
+    return {filename_example};
+  }
+
+  std::string prefix = match[1];
+
+  auto p = std::filesystem::absolute(std::filesystem::path(prefix));
+  std::filesystem::path directory = p.parent_path();
+  std::string filename_prefix = p.filename().string();
+  std::string number = match[2];
+  std::string suffix = match[3];
+
+  std::string patternString = filename_prefix + "(\\d+)" + suffix + "$";
+  pattern = patternString;
+
+  uint32_t digits = std::numeric_limits<uint32_t>::max();
+  uint32_t start = std::numeric_limits<uint32_t>::max();
+  uint32_t end = 0;
+
+  for (const auto& dirEntry : std::filesystem::directory_iterator(directory))
+  {
+    if (dirEntry.is_regular_file()) {
+      std::string s{dirEntry.path().filename().string()};
+
+      if (std::regex_match(s, match, pattern)) {
+        digits = std::min(digits, (uint32_t)match[1].length());
+
+        uint32_t number = std::stoi(match[1]);
+        start = std::min(start, number);
+        end = std::max(end, number);
+      }
+    }
+  }
+
+  std::vector<std::string> files;
+
+  for (uint32_t i = start; i <= end; i++)
+  {
+    std::stringstream sstr;
+
+    sstr << prefix << std::setw(digits) << std::setfill('0') << i << suffix;
+
+    std::filesystem::path p = directory / sstr.str();
+    files.emplace_back(p.string());
+  }
+
+  return files;
+}
+
+
+static void print_usage()
+{
+  std::cerr << "Usage: heif-gen-bayer [options] <input.png> <output.heif>\n"
+            << "       heif-gen-bayer -S [options] <frame_NNN.png> <output.mp4>\n\n"
+            << "Options:\n"
+            << "  -h, --help              show this help\n"
+            << "  -b, --bit-depth #       output bit depth (default: 8, range: 8-16)\n"
+            << "  -p, --pattern <name>    filter array pattern (default: rggb)\n"
+            << "  -S, --sequence          sequence mode (expand numbered PNGs)\n"
+            << "  -V, --video             use video track handler (vide) instead of pict\n"
+            << "      --fps <N>           frames per second (default: 30)\n\n"
+            << "Patterns:\n";
+  for (int i = 0; i < num_patterns; i++) {
+    std::cerr << "  " << patterns[i].name
+              << " (" << patterns[i].width << "x" << patterns[i].height << ")"
+              << (i == 0 ? "  [default]" : "")
+              << "\n";
+  }
+  std::cerr << "  Or specify a custom R/G/B string of length 4 (2x2) or 16 (4x4), e.g. -p BGGR\n";
+}
+
+
+static struct option long_options[] = {
+    {(char* const) "help",      no_argument,       nullptr, 'h'},
+    {(char* const) "bit-depth", required_argument, nullptr, 'b'},
+    {(char* const) "pattern",   required_argument, nullptr, 'p'},
+    {(char* const) "sequence",  no_argument,       nullptr, 'S'},
+    {(char* const) "video",     no_argument,       nullptr, 'V'},
+    {(char* const) "fps",       required_argument, nullptr, 'f'},
+    {nullptr, 0, nullptr, 0}
+};
+
+
+// Create a bayer image from a PNG file. Returns nullptr on error.
+// If expected_width/expected_height are non-zero, the PNG must match those dimensions.
+static heif_image* create_bayer_image_from_png(const char* png_filename,
+                                               const PatternDefinition* pat,
+                                               int output_bit_depth,
+                                               int expected_width,
+                                               int expected_height)
+{
+  InputImage input_image;
+  heif_error err = loadPNG(png_filename, output_bit_depth, &input_image);
+  if (err.code != heif_error_Ok) {
+    std::cerr << "Cannot load PNG '" << png_filename << "': " << err.message << "\n";
+    return nullptr;
+  }
+
+  heif_image* src_img = input_image.image.get();
+
+  int width = heif_image_get_primary_width(src_img);
+  int height = heif_image_get_primary_height(src_img);
+
+  if (expected_width != 0 && (width != expected_width || height != expected_height)) {
+    std::cerr << "Frame '" << png_filename << "' has dimensions " << width << "x" << height
+              << " but expected " << expected_width << "x" << expected_height << "\n";
+    return nullptr;
+  }
+
+  if (width % pat->width != 0 || height % pat->height != 0) {
+    std::cerr << "Image dimensions must be multiples of the pattern size ("
+              << pat->width << "x" << pat->height << "). Got "
+              << width << "x" << height << "\n";
+    return nullptr;
+  }
+
+  // Get source RGB data
+  int src_stride;
+  const uint8_t* src_data = heif_image_get_plane_readonly(src_img, heif_channel_interleaved, &src_stride);
+  if (!src_data) {
+    std::cerr << "Failed to get interleaved RGB plane from PNG.\n";
+    return nullptr;
+  }
+
+  // Create Bayer image
+  heif_image* bayer_img = nullptr;
+  err = heif_image_create(width, height,
+                          heif_colorspace_filter_array,
+                          heif_chroma_monochrome,
+                          &bayer_img);
+  if (err.code != heif_error_Ok) {
+    std::cerr << "Cannot create image: " << err.message << "\n";
+    return nullptr;
+  }
+
+  err = heif_image_add_plane(bayer_img, heif_channel_filter_array, width, height, output_bit_depth);
+  if (err.code != heif_error_Ok) {
+    std::cerr << "Cannot add plane: " << err.message << "\n";
+    heif_image_release(bayer_img);
+    return nullptr;
+  }
+
+  // Convert RGB to filter array using the selected pattern
+  if (output_bit_depth == 8) {
+    int dst_stride;
+    uint8_t* dst_data = heif_image_get_plane(bayer_img, heif_channel_filter_array, &dst_stride);
+
+    for (int y = 0; y < height; y++) {
+      const uint8_t* src_row = src_data + y * src_stride;
+      uint8_t* dst_row = dst_data + y * dst_stride;
+
+      for (int x = 0; x < width; x++) {
+        uint8_t r = src_row[x * 3 + 0];
+        uint8_t g = src_row[x * 3 + 1];
+        uint8_t b = src_row[x * 3 + 2];
+
+        int px = x % pat->width;
+        int py = y % pat->height;
+        auto comp_type = pat->cpat[py * pat->width + px];
+
+        switch (comp_type) {
+          case heif_uncompressed_component_type_red:   dst_row[x] = r; break;
+          case heif_uncompressed_component_type_green: dst_row[x] = g; break;
+          case heif_uncompressed_component_type_blue:  dst_row[x] = b; break;
+          case heif_uncompressed_component_type_Y: dst_row[x] = static_cast<uint8_t>((r + g + b) / 3); break;
+          default:
+            assert(false);
+        }
+      }
+    }
+  }
+  else {
+    int dst_stride;
+    uint8_t* dst_raw = heif_image_get_plane(bayer_img, heif_channel_filter_array, &dst_stride);
+    auto* dst_data = reinterpret_cast<uint16_t*>(dst_raw);
+    int dst_stride16 = dst_stride / 2;
+
+    for (int y = 0; y < height; y++) {
+      const uint8_t* src_row = src_data + y * src_stride;
+      uint16_t* dst_row = dst_data + y * dst_stride16;
+
+      for (int x = 0; x < width; x++) {
+        // Source is little-endian uint16_t per component, 3 components per pixel
+        uint16_t r = src_row[x * 6 + 0] | (src_row[x * 6 + 1] << 8);
+        uint16_t g = src_row[x * 6 + 2] | (src_row[x * 6 + 3] << 8);
+        uint16_t b = src_row[x * 6 + 4] | (src_row[x * 6 + 5] << 8);
+
+        int px = x % pat->width;
+        int py = y % pat->height;
+        auto comp_type = pat->cpat[py * pat->width + px];
+
+        switch (comp_type) {
+          case heif_uncompressed_component_type_red:   dst_row[x] = r; break;
+          case heif_uncompressed_component_type_green: dst_row[x] = g; break;
+          case heif_uncompressed_component_type_blue:  dst_row[x] = b; break;
+          case heif_uncompressed_component_type_Y: dst_row[x] = static_cast<uint16_t>((r + g + b) / 3); break;
+          default:
+            assert(false);
+        }
+      }
+    }
+  }
+
+  // Build heif_bayer_pattern_pixel array from component types.
+  // The component_index values here are the component types themselves — the encoder
+  // will resolve them to proper cmpd indices when writing the cpat box.
+  std::vector<heif_bayer_pattern_pixel> bayer_pixels(pat->cpat.size());
+  for (size_t i = 0; i < pat->cpat.size(); i++) {
+    bayer_pixels[i].component_index = static_cast<uint16_t>(pat->cpat[i]);
+    bayer_pixels[i].component_gain = 1.0f;
+  }
+
+  // Set Bayer pattern metadata
+  err = heif_image_set_bayer_pattern(bayer_img,
+                                     pat->width, pat->height,
+                                     bayer_pixels.data());
+  if (err.code != heif_error_Ok) {
+    std::cerr << "Cannot set Bayer pattern: " << err.message << "\n";
+    heif_image_release(bayer_img);
+    return nullptr;
+  }
+
+  return bayer_img;
+}
+
+
+static int encode_sequence(const std::vector<std::string>& filenames,
+                           const PatternDefinition* pat,
+                           int output_bit_depth,
+                           int fps,
+                           bool use_video_handler,
+                           const char* output_filename)
+{
+  heif_context* ctx = heif_context_alloc();
+
+  heif_encoder* encoder = nullptr;
+  heif_error err = heif_context_get_encoder_for_format(ctx, heif_compression_uncompressed, &encoder);
+  if (err.code != heif_error_Ok) {
+    std::cerr << "Cannot get uncompressed encoder: " << err.message << "\n";
+    heif_context_free(ctx);
+    return 1;
+  }
+
+  heif_context_set_sequence_timescale(ctx, fps);
+
+  heif_sequence_encoding_options* enc_options = heif_sequence_encoding_options_alloc();
+  heif_track* track = nullptr;
+  int first_width = 0, first_height = 0;
+
+  for (size_t i = 0; i < filenames.size(); i++) {
+    heif_image* bayer_img = create_bayer_image_from_png(filenames[i].c_str(), pat,
+                                                        output_bit_depth,
+                                                        first_width, first_height);
+    if (!bayer_img) {
+      heif_sequence_encoding_options_release(enc_options);
+      if (track) heif_track_release(track);
+      heif_encoder_release(encoder);
+      heif_context_free(ctx);
+      return 1;
+    }
+
+    if (i == 0) {
+      first_width = heif_image_get_primary_width(bayer_img);
+      first_height = heif_image_get_primary_height(bayer_img);
+
+      heif_track_type track_type = use_video_handler ? heif_track_type_video
+                                                     : heif_track_type_image_sequence;
+
+      heif_track_options* track_options = heif_track_options_alloc();
+      heif_track_options_set_timescale(track_options, fps);
+
+      err = heif_context_add_visual_sequence_track(ctx,
+                                                   static_cast<uint16_t>(first_width),
+                                                   static_cast<uint16_t>(first_height),
+                                                   track_type,
+                                                   track_options,
+                                                   enc_options,
+                                                   &track);
+      heif_track_options_release(track_options);
+
+      if (err.code != heif_error_Ok) {
+        std::cerr << "Cannot create sequence track: " << err.message << "\n";
+        heif_image_release(bayer_img);
+        heif_sequence_encoding_options_release(enc_options);
+        heif_encoder_release(encoder);
+        heif_context_free(ctx);
+        return 1;
+      }
+    }
+
+    heif_image_set_duration(bayer_img, 1);
+
+    err = heif_track_encode_sequence_image(track, bayer_img, encoder, enc_options);
+    heif_image_release(bayer_img);
+
+    if (err.code != heif_error_Ok) {
+      std::cerr << "Cannot encode frame " << i << ": " << err.message << "\n";
+      heif_sequence_encoding_options_release(enc_options);
+      heif_track_release(track);
+      heif_encoder_release(encoder);
+      heif_context_free(ctx);
+      return 1;
+    }
+
+    std::cout << "Encoded frame " << (i + 1) << "/" << filenames.size()
+              << ": " << filenames[i] << "\n";
+  }
+
+  err = heif_track_encode_end_of_sequence(track, encoder);
+  if (err.code != heif_error_Ok) {
+    std::cerr << "Cannot end sequence: " << err.message << "\n";
+  }
+
+  heif_sequence_encoding_options_release(enc_options);
+  heif_track_release(track);
+  heif_encoder_release(encoder);
+
+  err = heif_context_write_to_file(ctx, output_filename);
+  if (err.code != heif_error_Ok) {
+    std::cerr << "Cannot write file: " << err.message << "\n";
+    heif_context_free(ctx);
+    return 1;
+  }
+
+  heif_context_free(ctx);
+
+  std::cout << "Wrote " << filenames.size() << " frame(s) to " << output_filename << "\n";
+  return 0;
+}
+
+
+int main(int argc, char* argv[])
+{
+  PatternDefinition custom_pattern;
+  const PatternDefinition* pat = &patterns[0]; // default: RGGB
+  int output_bit_depth = 8;
+  bool sequence_mode = false;
+  bool use_video_handler = false;
+  int fps = 30;
+
+  while (true) {
+    int option_index = 0;
+    int c = getopt_long(argc, argv, "hb:p:SV", long_options, &option_index);
+    if (c == -1)
+      break;
+
+    switch (c) {
+      case 'h':
+        print_usage();
+        return 0;
+
+      case 'b':
+        output_bit_depth = std::atoi(optarg);
+        if (output_bit_depth < 8 || output_bit_depth > 16) {
+          std::cerr << "Invalid bit depth: " << optarg << " (must be 8-16)\n";
+          return 1;
+        }
+        break;
+
+      case 'p':
+        pat = find_pattern(optarg);
+        if (!pat) {
+          auto custom = parse_pattern_string(optarg);
+          if (custom) {
+            custom_pattern = std::move(*custom);
+            pat = &custom_pattern;
+          }
+          else {
+            std::cerr << "Unknown pattern: " << optarg << "\n";
+            print_usage();
+            return 1;
+          }
+        }
+        break;
+
+      case 'S':
+        sequence_mode = true;
+        break;
+
+      case 'V':
+        use_video_handler = true;
+        break;
+
+      case 'f': // --fps
+        fps = std::atoi(optarg);
+        if (fps <= 0) {
+          std::cerr << "Invalid FPS value: " << optarg << "\n";
+          return 1;
+        }
+        break;
+
+      default:
+        print_usage();
+        return 1;
+    }
+  }
+
+  if (argc - optind != 2) {
+    print_usage();
+    return 1;
+  }
+
+  const char* input_filename = argv[optind];
+  const char* output_filename = argv[optind + 1];
+
+  if (sequence_mode) {
+    // --- Sequence mode: expand numbered filenames and encode as sequence
+
+    std::vector<std::string> filenames = deflate_input_filenames(input_filename);
+    if (filenames.empty()) {
+      std::cerr << "No input files found matching pattern: " << input_filename << "\n";
+      return 1;
+    }
+
+    std::cout << "Found " << filenames.size() << " frame(s), encoding at " << fps << " fps\n";
+    return encode_sequence(filenames, pat, output_bit_depth, fps, use_video_handler, output_filename);
+  }
+
+  // --- Single image mode
+
+  heif_image* bayer_img = create_bayer_image_from_png(input_filename, pat, output_bit_depth, 0, 0);
+  if (!bayer_img) {
+    return 1;
+  }
+
+  // --- Encode
+
+  heif_context* ctx = heif_context_alloc();
+
+  heif_encoder* encoder = nullptr;
+  heif_error err = heif_context_get_encoder_for_format(ctx, heif_compression_uncompressed, &encoder);
+  if (err.code != heif_error_Ok) {
+    std::cerr << "Cannot get uncompressed encoder: " << err.message << "\n";
+    heif_image_release(bayer_img);
+    heif_context_free(ctx);
+    return 1;
+  }
+
+  heif_encoding_options* options = heif_encoding_options_alloc();
+
+  heif_image_handle* handle = nullptr;
+  err = heif_context_encode_image(ctx, bayer_img, encoder, options, &handle);
+  if (err.code != heif_error_Ok) {
+    std::cerr << "Cannot encode image: " << err.message << "\n";
+    heif_encoding_options_free(options);
+    heif_encoder_release(encoder);
+    heif_image_release(bayer_img);
+    heif_context_free(ctx);
+    return 1;
+  }
+
+  heif_encoding_options_free(options);
+  heif_encoder_release(encoder);
+  heif_image_handle_release(handle);
+  heif_image_release(bayer_img);
+
+  // --- Write file
+
+  err = heif_context_write_to_file(ctx, output_filename);
+  if (err.code != heif_error_Ok) {
+    std::cerr << "Cannot write file: " << err.message << "\n";
+    heif_context_free(ctx);
+    return 1;
+  }
+
+  heif_context_free(ctx);
+
+  std::cout << "Wrote " << pat->name << " ("
+            << pat->width << "x" << pat->height
+            << ") Bayer image to " << output_filename << "\n";
+
+  return 0;
+}
diff --git a/examples/heif_info.cc b/examples/heif_info.cc
index 56c55b86fb..d893f56289 100644
--- a/examples/heif_info.cc
+++ b/examples/heif_info.cc
@@ -3,7 +3,7 @@
 
   MIT License
 
-  Copyright (c) 2017 struktur AG, Dirk Farin <farin@struktur.de>
+  Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
 
   Permission is hereby granted, free of charge, to any person obtaining a copy
   of this software and associated documentation files (the "Software"), to deal
@@ -23,9 +23,7 @@
   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
   SOFTWARE.
 */
-#if defined(HAVE_CONFIG_H)
-#include "config.h"
-#endif
+#include <cstdint>
 
 #include <errno.h>
 #include <string.h>
@@ -40,12 +38,25 @@
 #endif
 
 #include <libheif/heif.h>
+#include <libheif/heif_library.h>
+#include <libheif/heif_regions.h>
+#include <libheif/heif_properties.h>
+#include <libheif/heif_experimental.h>
+#include "libheif/heif_sequences.h"
+#include <libheif/heif_text.h>
+#include <libheif/heif_image_handle.h>
+#include <libheif/heif_uncompressed.h>
 
 #include <fstream>
 #include <iostream>
+#include <sstream>
 #include <memory>
 #include <getopt.h>
-#include <assert.h>
+#include <cassert>
+#include <cstdio>
+#include <filesystem>
+#include "common.h"
+#include "libheif/heif_items.h"
 
 
 /*
@@ -63,40 +74,57 @@ info -w 20012 -o out.265 *file
 info -d // dump
  */
 
-static struct option long_options[] = {
+int option_disable_limits = 0;
+
+static option long_options[] = {
     //{"write-raw", required_argument, 0, 'w' },
     //{"output",    required_argument, 0, 'o' },
     {(char* const) "dump-boxes", no_argument, 0, 'd'},
+    {(char* const) "disable-limits", no_argument, &option_disable_limits, 1},
     {(char* const) "help",       no_argument, 0, 'h'},
+    {(char* const) "version",    no_argument, 0, 'v'},
     {0, 0,                                    0, 0}
 };
 
-const char* fourcc_to_string(uint32_t fourcc)
-{
-  static char fcc[5];
-  fcc[0] = (char) ((fourcc >> 24) & 0xFF);
-  fcc[1] = (char) ((fourcc >> 16) & 0xFF);
-  fcc[2] = (char) ((fourcc >> 8) & 0xFF);
-  fcc[3] = (char) ((fourcc >> 0) & 0xFF);
-  fcc[4] = 0;
-  return fcc;
-}
 
 void show_help(const char* argv0)
 {
-  fprintf(stderr, " heif-info  libheif version: %s\n", heif_get_version());
-  fprintf(stderr, "------------------------------------\n");
-  fprintf(stderr, "usage: heif-info [options] image.heic\n");
-  fprintf(stderr, "\n");
-  fprintf(stderr, "options:\n");
-  //fprintf(stderr,"  -w, --write-raw ID   write raw compressed data of image 'ID'\n");
-  //fprintf(stderr,"  -o, --output NAME    output file name for image selected by -w\n");
-  fprintf(stderr, "  -d, --dump-boxes     show a low-level dump of all MP4 file boxes\n");
-  fprintf(stderr, "  -h, --help           show help\n");
+  std::filesystem::path p(argv0);
+  std::string filename = p.filename().string();
+
+  std::stringstream sstr;
+  sstr << " " << filename << "  libheif version: " << heif_get_version();
+
+  std::string title = sstr.str();
+
+  std::cerr << title << "\n"
+            << std::string(title.length() + 1, '-') << "\n"
+            << "Usage: " << filename << " [options] <HEIF-image>\n"
+            << "\n"
+               "options:\n"
+               //fprintf(stderr,"  -w, --write-raw ID   write raw compressed data of image 'ID'\n");
+               //fprintf(stderr,"  -o, --output NAME    output file name for image selected by -w\n");
+               "  -d, --dump-boxes     show a low-level dump of all MP4 file boxes\n"
+               "      --disable-limits disable all security limits (do not use in production environment)\n"
+               "  -h, --help           show help\n"
+               "  -v, --version        show version\n";
 }
 
+
+class LibHeifInitializer
+{
+public:
+  LibHeifInitializer() { heif_init(nullptr); }
+
+  ~LibHeifInitializer() { heif_deinit(); }
+};
+
+
 int main(int argc, char** argv)
 {
+  // This takes care of initializing libheif and also deinitializing it at the end to free all resources.
+  LibHeifInitializer initializer;
+
   bool dump_boxes = false;
 
   bool write_raw_image = false;
@@ -105,7 +133,7 @@ int main(int argc, char** argv)
 
   while (true) {
     int option_index = 0;
-    int c = getopt_long(argc, argv, "dh", long_options, &option_index);
+    int c = getopt_long(argc, argv, "dhv", long_options, &option_index);
     if (c == -1)
       break;
 
@@ -123,6 +151,9 @@ int main(int argc, char** argv)
       case 'o':
         output_filename = optarg;
         break;
+      case 'v':
+        heif_examples::show_version();
+        return 0;
     }
   }
 
@@ -159,33 +190,37 @@ int main(int argc, char** argv)
       fclose(fh);
 
       char fourcc[5];
-      fourcc[4]=0;
-      heif_brand_to_fourcc( heif_read_main_brand(buf,bufSize), fourcc );
+      fourcc[4] = 0;
+      heif_brand_to_fourcc(heif_read_main_brand(buf, bufSize), fourcc);
       std::cout << "main brand: " << fourcc << "\n";
 
-      heif_brand2* brands=nullptr;
-      int nBrands=0;
-      struct heif_error err=heif_list_compatible_brands(buf, n, &brands, &nBrands);
+      heif_brand2* brands = nullptr;
+      int nBrands = 0;
+      heif_error err = heif_list_compatible_brands(buf, n, &brands, &nBrands);
       if (err.code) {
-	std::cerr << "error reading brands: " << err.message << "\n";
+        std::cerr << "error reading brands: " << err.message << "\n";
       }
       else {
-	std::cout << "compatible brands: ";
-	for (int i=0;i<nBrands;i++) {
-	  heif_brand_to_fourcc(brands[i], fourcc);
-	  if (i>0) {
-	    std::cout << ", ";
-	  }
-	  std::cout << fourcc;
-	}
-	
-	std::cout << "\n";
-
-	heif_free_list_of_compatible_brands(brands);
+        std::cout << "compatible brands: ";
+        for (int i = 0; i < nBrands; i++) {
+          heif_brand_to_fourcc(brands[i], fourcc);
+          if (i > 0) {
+            std::cout << ", ";
+          }
+          std::cout << fourcc;
+        }
+
+        std::cout << "\n";
+
+        heif_free_list_of_compatible_brands(brands);
+      }
+    }
+    else {
+      if (errno == ENOENT) {
+        std::cerr << "Input file does not exist.\n";
+        exit(10);
       }
     }
-
-    std::cout << "\n";
   }
 
   // ==============================================================================
@@ -197,11 +232,21 @@ int main(int argc, char** argv)
     return 1;
   }
 
-  struct heif_error err;
+  if (option_disable_limits) {
+    heif_context_set_security_limits(ctx.get(), heif_get_disabled_security_limits());
+  }
+
+  heif_error err;
   err = heif_context_read_from_file(ctx.get(), input_filename, nullptr);
 
   if (dump_boxes) {
     heif_context_debug_dump_boxes_to_file(ctx.get(), STDOUT_FILENO); // dump to stdout
+
+    if (err.code != 0) {
+      std::cerr << "Could not read HEIF/AVIF file: " << err.message << "\n";
+      return 1;
+    }
+
     return 0;
   }
 
@@ -219,8 +264,10 @@ int main(int argc, char** argv)
   heif_context_get_list_of_top_level_image_IDs(ctx.get(), IDs.data(), numImages);
 
   for (int i = 0; i < numImages; i++) {
-    struct heif_image_handle* handle;
-    struct heif_error err = heif_context_get_image_handle(ctx.get(), IDs[i], &handle);
+    std::cout << "\n";
+
+    heif_image_handle* handle;
+    heif_error err = heif_context_get_image_handle(ctx.get(), IDs[i], &handle);
     if (err.code) {
       std::cerr << err.message << "\n";
       return 10;
@@ -233,6 +280,75 @@ int main(int argc, char** argv)
 
     printf("image: %dx%d (id=%d)%s\n", width, height, IDs[i], primary ? ", primary" : "");
 
+    heif_image_tiling tiling;
+    err = heif_image_handle_get_image_tiling(handle, true, &tiling);
+    if (err.code) {
+      std::cerr << "Error while trying to get image tiling information: " << err.message << "\n";
+    }
+    else if (tiling.num_columns != 1 || tiling.num_rows != 1) {
+      std::cout << "  tiles: " << tiling.num_columns << "x" << tiling.num_rows
+                << ", tile size: " << tiling.tile_width << "x" << tiling.tile_height << "\n";
+    }
+
+    heif_colorspace colorspace;
+    heif_chroma chroma;
+    err = heif_image_handle_get_preferred_decoding_colorspace(handle, &colorspace, &chroma);
+    if (err.code) {
+      std::cerr << err.message << "\n";
+      return 10;
+    }
+
+    printf("  colorspace: ");
+    switch (colorspace) {
+      case heif_colorspace_YCbCr:
+        printf("YCbCr, ");
+        break;
+      case heif_colorspace_RGB:
+        printf("RGB");
+        break;
+      case heif_colorspace_monochrome:
+        printf("monochrome");
+        break;
+      case heif_colorspace_nonvisual:
+        printf("non-visual");
+        break;
+      default:
+        printf("unknown");
+        break;
+    }
+
+    if (colorspace==heif_colorspace_YCbCr) {
+      switch (chroma) {
+        case heif_chroma_420:
+          printf("4:2:0");
+          break;
+        case heif_chroma_422:
+          printf("4:2:2");
+          break;
+        case heif_chroma_444:
+          printf("4:4:4");
+          break;
+        default:
+          printf("unknown");
+          break;
+      }
+    }
+
+    printf("\n");
+
+    // --- bit depth
+
+    int luma_depth = heif_image_handle_get_luma_bits_per_pixel(handle);
+    int chroma_depth = heif_image_handle_get_chroma_bits_per_pixel(handle);
+
+    printf("  bit depth: ");
+    if (chroma == heif_chroma_monochrome || luma_depth==chroma_depth) {
+      printf("%d\n", luma_depth);
+    }
+    else {
+      printf("%d,%d\n", luma_depth, chroma_depth);
+    }
+
 
     // --- thumbnails
 
@@ -261,7 +377,7 @@ int main(int argc, char** argv)
     // --- color profile
 
     uint32_t profileType = heif_image_handle_get_color_profile_type(handle);
-    printf("  color profile: %s\n", profileType ? fourcc_to_string(profileType) : "no");
+    printf("  color profile: %s\n", profileType ? heif_examples::fourcc_to_string(profileType).c_str() : "no");
 
 
     // --- depth information
@@ -285,18 +401,22 @@ int main(int argc, char** argv)
     (void) nDepthImages;
 
     if (has_depth) {
-      struct heif_image_handle* depth_handle;
+      heif_image_handle* depth_handle;
       err = heif_image_handle_get_depth_image_handle(handle, depth_id, &depth_handle);
       if (err.code) {
         fprintf(stderr, "cannot get depth image: %s\n", err.message);
         return 1;
       }
 
-      printf(" (%dx%d)\n",
+      printf("    size: %dx%d\n",
              heif_image_handle_get_width(depth_handle),
              heif_image_handle_get_height(depth_handle));
 
-      const struct heif_depth_representation_info* depth_info;
+      int depth_luma_bpp = heif_image_handle_get_luma_bits_per_pixel(depth_handle);
+      printf("    bits per pixel: %d\n", depth_luma_bpp);
+
+
+      const heif_depth_representation_info* depth_info;
       if (heif_image_handle_get_depth_image_representation_info(handle, depth_id, &depth_info)) {
 
         printf("    z-near: ");
@@ -336,20 +456,449 @@ int main(int argc, char** argv)
       heif_image_handle_release(depth_handle);
     }
 
+    // --- metadata
+
+    int numMetadata = heif_image_handle_get_number_of_metadata_blocks(handle, nullptr);
+    printf("metadata:\n");
+    if (numMetadata > 0) {
+      std::vector<heif_item_id> ids(numMetadata);
+      heif_image_handle_get_list_of_metadata_block_IDs(handle, nullptr, ids.data(), numMetadata);
+
+      for (int n = 0; n < numMetadata; n++) {
+        std::string itemtype = heif_image_handle_get_metadata_type(handle, ids[n]);
+        std::string contenttype = heif_image_handle_get_metadata_content_type(handle, ids[n]);
+        std::string item_uri_type = heif_image_handle_get_metadata_item_uri_type(handle, ids[n]);
+        std::string ID{"unknown"};
+        if (itemtype == "Exif") {
+          ID = itemtype;
+        }
+        else if (itemtype == "uri ") {
+          ID = itemtype + "/" + item_uri_type;
+        }
+        else if (contenttype == "application/rdf+xml") {
+          ID = "XMP";
+        }
+        else {
+          ID = itemtype + "/" + contenttype;
+        }
+
+        printf("  %s: %zu bytes\n", ID.c_str(), heif_image_handle_get_metadata_size(handle, ids[n]));
+      }
+    }
+    else {
+      printf("  none\n");
+    }
+
+    // --- transforms
+
+#define MAX_PROPERTIES 50
+    heif_property_id transforms[MAX_PROPERTIES];
+    int nTransforms = heif_item_get_transformation_properties(ctx.get(),
+                                                              IDs[i],
+                                                              transforms,
+                                                              MAX_PROPERTIES);
+    printf("transformations:\n");
+    int image_width = heif_image_handle_get_ispe_width(handle);
+    int image_height = heif_image_handle_get_ispe_height(handle);
+
+    if (nTransforms) {
+      for (int k = 0; k < nTransforms; k++) {
+        switch (heif_item_get_property_type(ctx.get(), IDs[i], transforms[k])) {
+          case heif_item_property_type_transform_mirror:
+            printf("  mirror: %s\n", heif_item_get_property_transform_mirror(ctx.get(), IDs[i], transforms[k]) == heif_transform_mirror_direction_horizontal ? "horizontal" : "vertical");
+            break;
+          case heif_item_property_type_transform_rotation: {
+            int angle = heif_item_get_property_transform_rotation_ccw(ctx.get(), IDs[i], transforms[k]);
+            printf("  angle (ccw): %d\n", angle);
+            if (angle==90 || angle==270) {
+              std::swap(image_width, image_height);
+            }
+            break;
+          }
+          case heif_item_property_type_transform_crop: {
+            int left,top,right,bottom;
+            heif_item_get_property_transform_crop_borders(ctx.get(), IDs[i], transforms[k], image_width, image_height,
+                                                          &left, &top, &right, &bottom);
+            printf("  crop: left=%d top=%d right=%d bottom=%d\n", left,top,right,bottom);
+            break;
+          }
+          default:
+            assert(false);
+        }
+      }
+    }
+    else {
+      printf("  none\n");
+    }
+
+    // --- regions
+
+    int numRegionItems = heif_image_handle_get_number_of_region_items(handle);
+    printf("region annotations:\n");
+    if (numRegionItems > 0) {
+      std::vector<heif_item_id> region_items(numRegionItems);
+      heif_image_handle_get_list_of_region_item_ids(handle, region_items.data(), numRegionItems);
+      for (heif_item_id region_item_id : region_items) {
+        heif_region_item* region_item;
+        err = heif_context_get_region_item(ctx.get(), region_item_id, &region_item);
+
+        uint32_t reference_width, reference_height;
+        heif_region_item_get_reference_size(region_item, &reference_width, &reference_height);
+        int numRegions = heif_region_item_get_number_of_regions(region_item);
+        printf("  id: %u, reference_width: %u, reference_height: %u, %d regions\n",
+               region_item_id,
+               reference_width,
+               reference_height,
+               numRegions);
+
+        std::vector<heif_region*> regions(numRegions);
+        numRegions = heif_region_item_get_list_of_regions(region_item, regions.data(), numRegions);
+        for (int j = 0; j < numRegions; j++) {
+          printf("    region %d\n", j);
+          heif_region_type type = heif_region_get_type(regions[j]);
+          if (type == heif_region_type_point) {
+            int32_t x;
+            int32_t y;
+            heif_region_get_point(regions[j], &x, &y);
+            printf("      point [x=%i, y=%i]\n", x, y);
+          }
+          else if (type == heif_region_type_rectangle) {
+            int32_t x;
+            int32_t y;
+            uint32_t w;
+            uint32_t h;
+            heif_region_get_rectangle(regions[j], &x, &y, &w, &h);
+            printf("      rectangle [x=%i, y=%i, w=%u, h=%u]\n", x, y, w, h);
+          }
+          else if (type == heif_region_type_ellipse) {
+            int32_t x;
+            int32_t y;
+            uint32_t rx;
+            uint32_t ry;
+            heif_region_get_ellipse(regions[j], &x, &y, &rx, &ry);
+            printf("      ellipse [x=%i, y=%i, r_x=%u, r_y=%u]\n", x, y, rx, ry);
+          }
+          else if (type == heif_region_type_polygon) {
+            int32_t numPoints = heif_region_get_polygon_num_points(regions[j]);
+            std::vector<int32_t> pts(numPoints*2);
+            heif_region_get_polygon_points(regions[j], pts.data());
+            printf("      polygon [");
+            for (int p=0;p<numPoints;p++) {
+              printf("(%d;%d)", pts[2*p+0], pts[2*p+1]);
+            }
+            printf("]\n");
+          }
+          else if (type == heif_region_type_referenced_mask) {
+            int32_t x;
+            int32_t y;
+            uint32_t w;
+            uint32_t h;
+            heif_item_id referenced_item;
+            heif_region_get_referenced_mask_ID(regions[j], &x, &y, &w, &h, &referenced_item);
+            printf("      referenced mask [x=%i, y=%i, w=%u, h=%u, item=%u]\n", x, y, w, h, referenced_item);
+          }
+          else if (type == heif_region_type_polyline) {
+            int32_t numPoints = heif_region_get_polyline_num_points(regions[j]);
+            std::vector<int32_t> pts(numPoints*2);
+            heif_region_get_polyline_points(regions[j], pts.data());
+            printf("      polyline [");
+            for (int p=0;p<numPoints;p++) {
+              printf("(%d;%d)", pts[2*p+0], pts[2*p+1]);
+            }
+            printf("]\n");
+          }
+          else if (type == heif_region_type_inline_mask) {
+            int32_t x;
+            int32_t y;
+            uint32_t w;
+            uint32_t h;
+            size_t data_len = heif_region_get_inline_mask_data_len(regions[j]);
+            std::vector<uint8_t> mask_data(data_len);
+            heif_region_get_inline_mask_data(regions[j], &x, &y, &w, &h, mask_data.data());
+            printf("      inline mask [x=%i, y=%i, w=%u, h=%u, data len=%zu]\n", x, y, w, h, mask_data.size());
+          }
+      }
+
+        heif_region_release_many(regions.data(), numRegions);
+        heif_region_item_release(region_item);
+
+        heif_property_id properties[MAX_PROPERTIES];
+        int nDescr = heif_item_get_properties_of_type(ctx.get(),
+                                                      region_item_id,
+                                                      heif_item_property_type_user_description,
+                                                      properties,
+                                                      MAX_PROPERTIES);
+
+        for (int k = 0; k < nDescr; k++) {
+          heif_property_user_description* udes;
+          err = heif_item_get_property_user_description(ctx.get(),
+                                                        region_item_id,
+                                                        properties[k],
+                                                        &udes);
+          if (err.code == 0) {
+            printf("    user description:\n");
+            printf("      lang: %s\n", udes->lang);
+            printf("      name: %s\n", udes->name);
+            printf("      description: %s\n", udes->description);
+            printf("      tags: %s\n", udes->tags);
+            heif_property_user_description_release(udes);
+          }
+        }
+      }
+    }
+    else {
+      printf("  none\n");
+    }
+
+    // --- text items
+    int numTextItems = heif_image_handle_get_number_of_text_items(handle);
+    printf("text items:\n");
+
+    if (numTextItems > 0) {
+      std::vector<heif_item_id> text_items(numTextItems);
+      heif_image_handle_get_list_of_text_item_ids(handle, text_items.data(), numTextItems);
+      for (heif_item_id text_item_id : text_items) {
+        struct heif_text_item* text_item;
+        err = heif_context_get_text_item(ctx.get(), text_item_id, &text_item);
+        const char* text_content = heif_text_item_get_content(text_item);
+        printf("  text item: %s\n", text_content);
+        heif_string_release(text_content);
+
+        char* elng;
+        err = heif_item_get_property_extended_language(ctx.get(),
+                                                       text_item_id,
+                                                       &elng);
+        if (err.code == 0) {
+          printf("    extended language: %s\n", elng);
+        }
+        heif_string_release(elng);
+      }
+    }
+    else {
+      printf("  none\n");
+    }
+
+    // --- properties
+
+    printf("properties:\n");
+
+    // user descriptions
+
+    bool properties_shown = false;
+
+    heif_property_id propertyIds[MAX_PROPERTIES];
+    int count;
+    count = heif_item_get_properties_of_type(ctx.get(), IDs[i], heif_item_property_type_user_description,
+                                             propertyIds, MAX_PROPERTIES);
+
+    if (count > 0) {
+      for (int p = 0; p < count; p++) {
+        heif_property_user_description* udes;
+        err = heif_item_get_property_user_description(ctx.get(), IDs[i], propertyIds[p], &udes);
+        if (err.code) {
+          std::cerr << "Error reading udes " << IDs[i] << "/" << propertyIds[p] << "\n";
+        }
+        else {
+          printf("  user description:\n");
+          printf("    lang: %s\n", udes->lang);
+          printf("    name: %s\n", udes->name);
+          printf("    description: %s\n", udes->description);
+          printf("    tags: %s\n", udes->tags);
+          properties_shown = true;
+
+          heif_property_user_description_release(udes);
+        }
+      }
+    }
+
+    // --- camera intrinsic and extrinsic parameters
+
+    if (heif_image_handle_has_camera_intrinsic_matrix(handle)) {
+      heif_camera_intrinsic_matrix matrix{};
+      heif_image_handle_get_camera_intrinsic_matrix(handle, &matrix);
+      printf("  camera intrinsic matrix:\n");
+      printf("    focal length: %f; %f\n", matrix.focal_length_x, matrix.focal_length_y);
+      printf("    principal point: %f; %f\n", matrix.principal_point_x, matrix.principal_point_y);
+      printf("    skew: %f\n", matrix.skew);
+      properties_shown = true;
+    }
+
+    if (heif_image_handle_has_camera_extrinsic_matrix(handle)) {
+      heif_camera_extrinsic_matrix* matrix;
+      heif_image_handle_get_camera_extrinsic_matrix(handle, &matrix);
+      double rot[9];
+      heif_camera_extrinsic_matrix_get_rotation_matrix(matrix, rot);
+      printf("  camera extrinsic matrix:\n");
+      printf("    rotation matrix:\n");
+      printf("      %6.3f %6.3f %6.3f\n", rot[0], rot[1], rot[2]);
+      printf("      %6.3f %6.3f %6.3f\n", rot[3], rot[4], rot[5]);
+      printf("      %6.3f %6.3f %6.3f\n", rot[6], rot[7], rot[8]);
+      heif_camera_extrinsic_matrix_release(matrix);
+      properties_shown = true;
+    }
+
+
+    uint32_t aspect_h, aspect_v;
+    int has_pasp = heif_image_handle_get_pixel_aspect_ratio(handle, &aspect_h, &aspect_v);
+    if (has_pasp) {
+      std::cout << "  pixel aspect ratio: " << aspect_h << "/" << aspect_v << "\n";
+      properties_shown = true;
+    }
+
+    heif_content_light_level clli{};
+    if (heif_image_handle_get_content_light_level(handle, &clli)) {
+      std::cout << "  content light level (clli):\n"
+                << "    max content light level: " << clli.max_content_light_level << "\n"
+                << "    max pic average light level: " << clli.max_pic_average_light_level << "\n";
+      properties_shown = true;
+    }
+
+    heif_mastering_display_colour_volume mdcv;
+    if (heif_image_handle_get_mastering_display_colour_volume(handle, &mdcv)) {
+
+      heif_decoded_mastering_display_colour_volume decoded_mdcv;
+      err = heif_mastering_display_colour_volume_decode(&mdcv, &decoded_mdcv);
+
+      std::cout << "  mastering display color volume:\n"
+                << "    display_primaries (x,y): "
+                << "(" << decoded_mdcv.display_primaries_x[0] << ";" << decoded_mdcv.display_primaries_y[0] << "), "
+                << "(" << decoded_mdcv.display_primaries_x[1] << ";" << decoded_mdcv.display_primaries_y[1] << "), "
+                << "(" << decoded_mdcv.display_primaries_x[2] << ";" << decoded_mdcv.display_primaries_y[2] << ")\n";
+
+      std::cout << "    white point (x,y): (" << decoded_mdcv.white_point_x << ";" << decoded_mdcv.white_point_y << ")\n";
+      std::cout << "    max display mastering luminance: " << decoded_mdcv.max_display_mastering_luminance << "\n";
+      std::cout << "    min display mastering luminance: " << decoded_mdcv.min_display_mastering_luminance << "\n";
+      properties_shown = true;
+    }
+
+    // --- GIMI
+
+    const char* id = heif_image_handle_get_gimi_content_id(handle);
+    if (id) {
+      std::cout << "  GIMI content ID: " << id << "\n";
+      heif_string_release(id);
+      properties_shown = true;
+    }
+
+    // --- cmpd components
+
+    uint32_t num_cmpd_components = heif_image_handle_get_number_of_cmpd_components(handle);
+    if (num_cmpd_components > 0) {
+      int num_content_ids = heif_image_handle_has_gimi_component_content_ids(handle);
+
+      auto get_component_type_name = [](uint16_t type) -> const char* {
+        switch (type) {
+          case 0: return "monochrome";
+          case 1: return "Y";
+          case 2: return "Cb";
+          case 3: return "Cr";
+          case 4: return "red";
+          case 5: return "green";
+          case 6: return "blue";
+          case 7: return "alpha";
+          case 8: return "depth";
+          case 9: return "disparity";
+          case 10: return "palette";
+          case 11: return "filter_array";
+          case 12: return "padded";
+          case 13: return "cyan";
+          case 14: return "magenta";
+          case 15: return "yellow";
+          case 16: return "key_black";
+          default: return nullptr;
+        }
+      };
+
+      // Find the maximum display width of the "type_name (N)" column.
+      size_t max_type_width = 0;
+      for (uint32_t i = 0; i < num_cmpd_components; i++) {
+        uint16_t type = heif_image_handle_get_cmpd_component_type(handle, i);
+        const char* name = get_component_type_name(type);
+        std::ostringstream tmp;
+        if (name) {
+          tmp << name << " (" << type << ")";
+        }
+        else {
+          tmp << type;
+        }
+        max_type_width = std::max(max_type_width, tmp.str().size());
+      }
+
+      std::cout << "  components:\n";
+      for (uint32_t i = 0; i < num_cmpd_components; i++) {
+        uint16_t type = heif_image_handle_get_cmpd_component_type(handle, i);
+        const char* type_name = get_component_type_name(type);
+
+        std::ostringstream type_str;
+        if (type_name) {
+          type_str << type_name << " (" << type << ")";
+        }
+        else {
+          type_str << type;
+        }
+
+        std::cout << "    [" << i << "] type: "
+                  << std::left << std::setw(static_cast<int>(max_type_width)) << type_str.str();
+
+        const char* uri = heif_image_handle_get_cmpd_component_type_uri(handle, i);
+        if (uri) {
+          std::cout << " (uri: " << uri << ")";
+          heif_string_release(uri);
+        }
+
+        if (num_content_ids > 0) {
+          const char* content_id = heif_image_handle_get_gimi_component_content_id(handle, i);
+          if (content_id) {
+            std::cout << "  content ID: " << content_id;
+            heif_string_release(content_id);
+          }
+        }
+
+        std::cout << "\n";
+      }
+      properties_shown = true;
+    }
+
+#if HEIF_WITH_OMAF
+    // --- OMAF
+
+    if (heif_image_handle_has_omaf_image_projection(handle)) {
+      heif_omaf_image_projection projection = heif_image_handle_get_omaf_image_projection(handle);
+      std::cout << "  image projection: ";
+      switch (projection)
+      {
+      case heif_omaf_image_projection_equirectangular:
+        std::cout << "equirectangular";
+        break;
+      case heif_omaf_image_projection_cube_map:
+        std::cout << "cube-map";
+      default:
+        std::cout << "(unknown)";
+        break;
+      }
+      std::cout << "\n";
+      properties_shown = true;
+    }
+#endif
+
+    if (!properties_shown) {
+      std::cout << "none\n";
+    }
+
     heif_image_handle_release(handle);
   }
 
 #if 0
   std::cout << "num images: " << heif_context_get_number_of_top_level_images(ctx.get()) << "\n";
 
-  struct heif_image_handle* handle;
+  heif_image_handle* handle;
   err = heif_context_get_primary_image_handle(ctx.get(), &handle);
   if (err.code != 0) {
     std::cerr << "Could not get primage image handle: " << err.message << "\n";
     return 1;
   }
 
-  struct heif_image* image;
+  heif_image* image;
   err = heif_decode_image(handle, &image, heif_colorspace_undefined, heif_chroma_undefined, NULL);
   if (err.code != 0) {
     heif_image_handle_release(handle);
@@ -361,5 +910,152 @@ int main(int argc, char** argv)
   heif_image_handle_release(handle);
 #endif
 
+  // ==============================================================================
+
+  heif_context* context = ctx.get();
+
+  uint32_t nTracks = heif_context_number_of_sequence_tracks(context);
+
+  if (nTracks > 0) {
+    std::cout << "\n";
+
+    uint64_t timescale = heif_context_get_sequence_timescale(context);
+    std::cout << "sequence time scale: " << timescale << " Hz\n";
+
+    uint64_t duration = heif_context_get_sequence_duration(context);
+    std::cout << "sequence duration: " << ((double)duration)/(double)timescale << " seconds\n";
+
+              //    TrackOptions
+
+    std::vector<uint32_t> track_ids(nTracks);
+
+    heif_context_get_track_ids(context, track_ids.data());
+
+    for (uint32_t id : track_ids) {
+      heif_track* track = heif_context_get_track(context, id);
+
+      heif_track_type handler = heif_track_get_track_handler_type(track);
+      std::cout << "track " << id << "\n";
+      std::cout << "  handler: '" << heif_examples::fourcc_to_string(handler) << "' = ";
+
+      switch (handler) {
+        case heif_track_type_image_sequence:
+          std::cout << "image sequence\n";
+          break;
+        case heif_track_type_video:
+          std::cout << "video\n";
+          break;
+        case heif_track_type_auxiliary:
+          std::cout << "auxiliary ";
+          {
+            heif_auxiliary_track_info_type type = heif_track_get_auxiliary_info_type(track);
+            switch (type) {
+              case heif_auxiliary_track_info_type_unknown: {
+                const char* s = heif_track_get_auxiliary_info_type_urn(track);
+                std::cout << "(unknown: " << s << ")\n";
+                heif_string_release(s);
+                break;
+              }
+              case heif_auxiliary_track_info_type_alpha:
+                std::cout << "(alpha)\n";
+                break;
+            }
+          }
+          break;
+        case heif_track_type_metadata:
+          std::cout << "metadata\n";
+          break;
+        default:
+          std::cout << "unknown\n";
+          break;
+      }
+
+      if (handler == heif_track_type_video ||
+          handler == heif_track_type_image_sequence) {
+        uint16_t w, h;
+        heif_track_get_image_resolution(track, &w, &h);
+        std::cout << "  resolution: " << w << "x" << h << "\n";
+      }
+
+      uint32_t sampleEntryType = heif_track_get_sample_entry_type_of_first_cluster(track);
+      std::cout << "  sample entry type: " << heif_examples::fourcc_to_string(sampleEntryType) << "\n";
+
+      if (sampleEntryType == heif_fourcc('u', 'r', 'i', 'm')) {
+        const char* uri;
+        err = heif_track_get_urim_sample_entry_uri_of_first_cluster(track, &uri);
+        if (err.code) {
+          std::cerr << "error reading urim-track uri: " << err.message << "\n";
+        }
+        std::cout << "  uri: " << uri << "\n";
+        heif_string_release(uri);
+      }
+
+      std::cout << "  sample auxiliary information: ";
+      int nSampleAuxTypes = heif_track_get_number_of_sample_aux_infos(track);
+
+      std::vector<heif_sample_aux_info_type> aux_types(nSampleAuxTypes);
+      heif_track_get_sample_aux_info_types(track, aux_types.data());
+
+      for (size_t i=0;i<aux_types.size();i++) {
+        if (i) { std::cout << ", "; }
+        std::cout << heif_examples::fourcc_to_string(aux_types[i].type);
+      }
+
+      if (nSampleAuxTypes==0) {
+        std::cout << "---";
+      }
+      std::cout << "\n";
+
+
+      size_t nRefTypes = heif_track_get_number_of_track_reference_types(track);
+
+      if (nRefTypes > 0) {
+        std::cout << "  references:\n";
+        std::vector<uint32_t> refTypes(nRefTypes);
+        heif_track_get_track_reference_types(track, refTypes.data());
+
+        for (uint32_t refType : refTypes) {
+          std::cout << "    " << heif_examples::fourcc_to_string(refType) << ": ";
+
+          size_t n = heif_track_get_number_of_track_reference_of_type(track, refType);
+          std::vector<uint32_t> track_ids(n);
+          heif_track_get_references_from_track(track, refType, track_ids.data());
+          for (size_t i=0;i<n;i++) {
+            if (i>0) std::cout << ", ";
+            std::cout << "track#" << track_ids[i];
+          }
+          std::cout << "\n";
+        }
+      }
+
+      const char* gimi_track_id = heif_track_get_gimi_track_content_id(track);
+      if (gimi_track_id) {
+        std::cout << "  GIMI track id: " << gimi_track_id << "\n";
+        heif_string_release(gimi_track_id);
+      }
+
+      heif_track_release(track);
+    }
+  }
+
+  // ==============================================================================
+
+  {
+    int nItems = heif_context_get_number_of_items(context);
+    if (nItems > 0) {
+      std::cout << "MIME items:\n";
+      std::vector<heif_item_id> item_ids(nItems);
+      heif_context_get_list_of_item_IDs(context, item_ids.data(), nItems);
+
+      for (auto id : item_ids) {
+        uint32_t type = heif_item_get_item_type(context, id);
+        if (type == heif_item_type_mime) {
+          const char* mimeType = heif_item_get_mime_item_content_type(context, id);
+          std::cout << "  " << id << " : " << mimeType << "\n";
+        }
+      }
+    }
+  }
+
   return 0;
 }
diff --git a/examples/heif_test.cc b/examples/heif_test.cc
index e1d38269c8..e447255883 100644
--- a/examples/heif_test.cc
+++ b/examples/heif_test.cc
@@ -3,7 +3,7 @@
 
   MIT License
 
-  Copyright (c) 2017 struktur AG, Dirk Farin <farin@struktur.de>
+  Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
 
   Permission is hereby granted, free of charge, to any person obtaining a copy
   of this software and associated documentation files (the "Software"), to deal
@@ -23,9 +23,6 @@
   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
   SOFTWARE.
 */
-#if defined(HAVE_CONFIG_H)
-#include "config.h"
-#endif
 
 #include <errno.h>
 #include <string.h>
@@ -45,6 +42,7 @@
 #include <memory>
 #include <getopt.h>
 #include <assert.h>
+#include "common.h"
 
 
 static struct option long_options[] = {
@@ -52,6 +50,7 @@ static struct option long_options[] = {
     //{"output",    required_argument, 0, 'o' },
     {(char* const) "decode-img", required_argument, 0, 'd'},
     {(char* const) "metadata",   required_argument, 0, 'm'},
+    {(char* const) "version",    required_argument, 0, 'v'},
     {0, 0,                                          0, 0}
 };
 
@@ -65,10 +64,11 @@ void show_help(const char* argv0)
   fprintf(stderr, "  -d, --decode-img ID  decode image and output raw pixel data of all planes\n");
   fprintf(stderr, "  -m, --metadata ID    output metadata\n");
   fprintf(stderr, "  -h, --help           show help\n");
+  fprintf(stderr, "  -v, --version        show version\n");
 }
 
 
-std::pair<heif_item_id, heif_item_id> parse_id_pair(std::string s)
+std::pair<heif_item_id, heif_item_id> parse_id_pair(const std::string& s)
 {
   std::string::size_type p = s.find_first_of(':');
   if (p == std::string::npos) {
@@ -90,7 +90,7 @@ int main(int argc, char** argv)
 
   while (true) {
     int option_index = 0;
-    int c = getopt_long(argc, argv, "d:m:h", long_options, &option_index);
+    int c = getopt_long(argc, argv, "d:m:hv", long_options, &option_index);
     if (c == -1)
       break;
 
@@ -104,6 +104,9 @@ int main(int argc, char** argv)
       case 'h':
         show_help(argv[0]);
         return 0;
+      case 'v':
+        heif_examples::show_version();
+        return 0;
     }
   }
 
@@ -146,8 +149,8 @@ int main(int argc, char** argv)
           int height = img.get_height(channel);
           int bytes = (img.get_bits_per_pixel(channel) + 7) / 8;
 
-          int stride;
-          const uint8_t* p = img.get_plane(channel, &stride);
+          size_t stride;
+          const uint8_t* p = img.get_plane2(channel, &stride);
           for (int y = 0; y < height; y++) {
             fwrite(p + y * stride, width, bytes, stdout);
           }
diff --git a/examples/heif_thumbnailer.cc b/examples/heif_thumbnailer.cc
index 93b2c77baf..a2d13be290 100644
--- a/examples/heif_thumbnailer.cc
+++ b/examples/heif_thumbnailer.cc
@@ -3,7 +3,7 @@
 
   MIT License
 
-  Copyright (c) 2018 struktur AG, Dirk Farin <farin@struktur.de>
+  Copyright (c) 2018 Dirk Farin <dirk.farin@gmail.com>
 
   Permission is hereby granted, free of charge, to any person obtaining a copy
   of this software and associated documentation files (the "Software"), to deal
@@ -23,10 +23,6 @@
   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
   SOFTWARE.
 */
-#if defined(HAVE_CONFIG_H)
-#  include "config.h"
-#endif
-
 
 #if defined(HAVE_UNISTD_H)
 #  include <unistd.h>
@@ -35,11 +31,13 @@
 #include <string>
 #include <iostream>
 #include <cassert>
+#include <memory>
 #include <libheif/heif.h>
-#include "encoder.h"
+#include "heifio/encoder.h"
 
 #if HAVE_LIBPNG
-#  include "encoder_png.h"
+#  include "heifio/encoder_png.h"
+#include "common.h"
 #endif
 
 #if defined(_MSC_VER)
@@ -55,13 +53,23 @@ static int usage(const char* command)
 }
 
 
+class LibHeifInitializer {
+public:
+  LibHeifInitializer() { heif_init(nullptr); }
+  ~LibHeifInitializer() { heif_deinit(); }
+};
+
+
 int main(int argc, char** argv)
 {
+  // This takes care of initializing libheif and also deinitializing it at the end to free all resources.
+  LibHeifInitializer initializer;
+
   int opt;
   int size = 512; // default thumbnail size
   bool thumbnail_from_primary_image_only = false;
 
-  while ((opt = getopt(argc, argv, "s:hp")) != -1) {
+  while ((opt = getopt(argc, argv, "s:hpv")) != -1) {
     switch (opt) {
       case 's':
         size = atoi(optarg);
@@ -69,6 +77,9 @@ int main(int argc, char** argv)
       case 'p':
         thumbnail_from_primary_image_only = true;
         break;
+      case 'v':
+        heif_examples::show_version();
+        return 0;
       case 'h':
       default:
         return usage(argv[0]);
@@ -158,10 +169,10 @@ int main(int argc, char** argv)
   int input_width = heif_image_handle_get_width(image_handle);
   int input_height = heif_image_handle_get_height(image_handle);
 
-  int thumbnail_width = input_width;
-  int thumbnail_height = input_height;
-
   if (input_width > size || input_height > size) {
+    int thumbnail_width;
+    int thumbnail_height;
+
     if (input_width > input_height) {
       thumbnail_height = input_height * size / input_width;
       thumbnail_width = size;
@@ -174,6 +185,11 @@ int main(int argc, char** argv)
       thumbnail_width = thumbnail_height = 0;
     }
 
+    if (thumbnail_width == 0 || thumbnail_height == 0) {
+      std::cerr << "Zero thumbnail output size\n";
+      return 1;
+    }
+
 
     // --- output thumbnail smaller than HEIF thumbnail -> scale down
 
diff --git a/examples/heif_view.cc b/examples/heif_view.cc
new file mode 100644
index 0000000000..15c96dccf9
--- /dev/null
+++ b/examples/heif_view.cc
@@ -0,0 +1,465 @@
+/*
+  libheif example application.
+
+  MIT License
+
+  Copyright (c) 2025 Dirk Farin <dirk.farin@gmail.com>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#include <cstring>
+#include <getopt.h>
+#include "libheif/heif_experimental.h"
+#include "libheif/heif_sequences.h"
+#include <libheif/heif_tai_timestamps.h>
+
+#if defined(HAVE_UNISTD_H)
+
+#include <unistd.h>
+
+#endif
+
+#include <fstream>
+#include <iostream>
+#include <iomanip>
+#include <sstream>
+#include <cassert>
+#include <algorithm>
+#include <vector>
+#include <array>
+#include <cctype>
+#include <memory>
+
+#include <libheif/heif.h>
+
+#include "common.h"
+#include "sdl.hh"
+
+#if defined(_MSC_VER)
+#include "getopt.h"
+#endif
+
+#if !SDL_VERSION_ATLEAST(2, 0, 18)
+#define SDL_GetTicks64 SDL_GetTicks
+#endif
+
+#define UNUSED(x) (void)x
+
+
+static void show_help(const char* argv0)
+{
+  std::cerr << " " << argv0 << "  libheif version: " << heif_get_version() << "\n"
+            << "---------------------------------------\n"
+               "Usage: " << argv0 << " [options]  <input-file>\n"
+            << "\n"
+               "Options:\n"
+               "  -h, --help                     show help\n"
+               "  -v, --version                  show version\n"
+               "      --list-decoders            list all available decoders (built-in and plugins)\n"
+               "  -d, --decoder ID               use a specific decoder (see --list-decoders)\n"
+               "      --speedup FACTOR           increase playback speed by FACTOR\n"
+               "      --show-sai                 show sample auxiliary information\n"
+               "      --show-frame-duration      show each frame duration in milliseconds\n"
+               "      --show-track-metadata      show metadata attached to the track (e.g. TAI config)\n"
+               "      --show-metadata-text       show data in metadata track as text\n"
+               "      --show-metadata-hex        show data in metadata track as hex bytes\n"
+               "      --show-all                 show all extra information\n"
+               "      --ignore-editlist          show the raw media timeline without repetitions\n";
+}
+
+
+class ContextReleaser {
+public:
+  ContextReleaser(struct heif_context* ctx) : ctx_(ctx) {}
+
+  ~ContextReleaser()
+  {
+    heif_context_free(ctx_);
+  }
+
+private:
+  struct heif_context* ctx_;
+};
+
+
+int option_list_decoders = 0;
+double option_speedup = 1.0;
+bool option_show_sai = false;
+bool option_show_frame_duration = false;
+bool option_show_track_metadata = false;
+bool option_ignore_editlist = false;
+enum {
+  metadata_output_none,
+  metadata_output_text,
+  metadata_output_hex
+} option_metadata_output = metadata_output_none;
+
+const int OPTION_SPEEDUP = 1000;
+const int OPTION_SHOW_SAI = 1001;
+const int OPTION_SHOW_FRAME_DURATION = 1002;
+const int OPTION_SHOW_TRACK_METADATA = 1003;
+const int OPTION_SHOW_ALL = 1004;
+const int OPTION_SHOW_METADATA_TEXT = 1005;
+const int OPTION_SHOW_METADATA_HEX = 1006;
+const int OPTION_IGNORE_EDITLIST = 1007;
+
+static struct option long_options[] = {
+    {(char* const) "decoder",             required_argument, 0,                     'd'},
+    {(char* const) "list-decoders",       no_argument,       &option_list_decoders, 1},
+    {(char* const) "help",                no_argument,       0,                     'h'},
+    {(char* const) "version",             no_argument,       0,                     'v'},
+    {(char* const) "speedup",             required_argument, 0,                     OPTION_SPEEDUP},
+    {(char* const) "show-sai",            no_argument,       0,                     OPTION_SHOW_SAI},
+    {(char* const) "show-frame-duration", no_argument,       0,                     OPTION_SHOW_FRAME_DURATION},
+    {(char* const) "show-track-metadata", no_argument,       0,                     OPTION_SHOW_TRACK_METADATA},
+    {(char* const) "show-metadata-text",  no_argument,       0,                     OPTION_SHOW_METADATA_TEXT},
+    {(char* const) "show-metadata-hex",   no_argument,       0,                     OPTION_SHOW_METADATA_HEX},
+    {(char* const) "show-all",            no_argument,       0,                     OPTION_SHOW_ALL},
+    {(char* const) "ignore-editlist",     no_argument,       0,                     OPTION_IGNORE_EDITLIST},
+    {nullptr,                             no_argument,       nullptr,               0}
+};
+
+
+void output_hex(const uint8_t* data, size_t size)
+{
+  std::cout << std::hex << std::setfill('0');
+
+  for (size_t i=0;i<size;i++) {
+    if (i%16==0) {
+      std::cout << std::setw(4) << i << " : ";
+    }
+
+    std::cout << std::setw(2) << (uint16_t)data[i];
+    if (i%16==7)
+      std::cout << "  ";
+    else if (i%16==15)
+      std::cout << '\n';
+    else
+      std::cout << ' ';
+  }
+
+  if (size%16 != 15) {
+    std::cout << '\n';
+  }
+
+  std::cout << std::dec << std::setfill(' ');
+}
+
+
+class LibHeifInitializer {
+public:
+  LibHeifInitializer() { heif_init(nullptr); }
+
+  ~LibHeifInitializer() { heif_deinit(); }
+};
+
+
+int main(int argc, char** argv)
+{
+  // This takes care of initializing libheif and also deinitializing it at the end to free all resources.
+  LibHeifInitializer initializer;
+
+  const char* decoder_id = nullptr;
+  bool show_frame_number = false;
+
+  while (true) {
+    int option_index = 0;
+    int c = getopt_long(argc, argv, "hvd:", long_options, &option_index);
+    if (c == -1) {
+      break;
+    }
+
+    switch (c) {
+      case 'd':
+        decoder_id = optarg;
+        break;
+      case 'h':
+        show_help(argv[0]);
+        return 0;
+      case 'v':
+        heif_examples::show_version();
+        return 0;
+      case OPTION_SPEEDUP:
+        option_speedup = atof(optarg);
+        if (option_speedup <= 0) {
+          std::cerr << "Speedup must be positive.\n";
+          return 5;
+        }
+        break;
+      case OPTION_SHOW_SAI:
+        option_show_sai = true;
+        show_frame_number = true;
+        break;
+      case OPTION_SHOW_FRAME_DURATION:
+        option_show_frame_duration = true;
+        show_frame_number = true;
+        break;
+      case OPTION_SHOW_TRACK_METADATA:
+        option_show_track_metadata = true;
+        show_frame_number = true;
+        break;
+      case OPTION_SHOW_ALL:
+        option_show_sai = true;
+        option_show_frame_duration = true;
+        option_show_track_metadata = true;
+        show_frame_number = true;
+        break;
+      case OPTION_SHOW_METADATA_TEXT:
+        option_metadata_output = metadata_output_text;
+        break;
+      case OPTION_SHOW_METADATA_HEX:
+        option_metadata_output = metadata_output_hex;
+        break;
+      case OPTION_IGNORE_EDITLIST:
+        option_ignore_editlist = true;
+        break;
+    }
+  }
+
+  if (option_list_decoders) {
+    heif_examples::list_all_decoders();
+    return 0;
+  }
+
+  if (optind + 1 != argc) {
+    // Need exactly one input filename as additional argument.
+    show_help(argv[0]);
+    return 5;
+  }
+
+  std::string input_filename(argv[optind++]);
+
+
+  // --- check whether input is a supported HEIF file
+
+  if (int ret = heif_examples::check_for_valid_input_HEIF_file(input_filename)) {
+    return ret;
+  }
+
+  // --- open the HEIF file
+
+  struct heif_context* ctx = heif_context_alloc();
+  if (!ctx) {
+    fprintf(stderr, "Could not create context object\n");
+    return 1;
+  }
+
+  ContextReleaser cr(ctx);
+  struct heif_error err;
+  err = heif_context_read_from_file(ctx, input_filename.c_str(), nullptr);
+  if (err.code != 0) {
+    std::cerr << "Could not read HEIF/AVIF file: " << err.message << "\n";
+    return 1;
+  }
+
+
+  // --- error if file contains no image sequence
+
+  if (!heif_context_has_sequence(ctx)) {
+    std::cerr << "File contains no image sequence\n";
+    return 1;
+  }
+
+
+  // --- get visual track
+
+  struct heif_track* track = heif_context_get_track(ctx, 0);
+
+  uint16_t w, h;
+  heif_track_get_image_resolution(track, &w, &h);
+
+
+  // --- show track properties
+
+  if (option_show_track_metadata) {
+    const char* track_contentId = heif_track_get_gimi_track_content_id(track);
+    if (track_contentId) {
+      std::cout << "track content ID: " << track_contentId << "\n";
+      heif_string_release(track_contentId);
+    }
+
+    const heif_tai_clock_info* taic = heif_track_get_tai_clock_info_of_first_cluster(track);
+    if (taic) {
+      std::cout << "track taic: " << taic->time_uncertainty << " / " << taic->clock_resolution << " / "
+                << taic->clock_drift_rate << " / " << int(taic->clock_type) << "\n";
+    }
+  }
+
+
+  // --- find metadata track
+
+  heif_track* metadata_track = nullptr;
+  if (option_metadata_output != metadata_output_none) {
+    uint32_t metadata_track_id;
+    size_t nMetadataTracks = heif_track_find_referring_tracks(track, heif_track_reference_type_description, &metadata_track_id, 1);
+
+    if (nMetadataTracks == 1) {
+      metadata_track = heif_context_get_track(ctx, metadata_track_id);
+    }
+  }
+
+
+  // --- open output window
+
+  SDL_YUV_Display sdlWindow;
+  std::optional<std::string> sdlError = sdlWindow.init(w, h, SDL_YUV_Display::SDL_CHROMA_420, "heif-view");
+  if (sdlError) {
+    std::cerr << "Cannot open output window. " << *sdlError << "\n";
+    return 10;
+  }
+
+  std::unique_ptr<heif_decoding_options, void (*)(heif_decoding_options*)> decode_options(heif_decoding_options_alloc(), heif_decoding_options_free);
+  decode_options->convert_hdr_to_8bit = true;
+  decode_options->decoder_id = decoder_id;
+  decode_options->ignore_sequence_editlist = option_ignore_editlist;
+
+
+  // --- decoding loop
+
+  for (int frameNr = 1;; frameNr++) {
+    heif_image* out_image = nullptr;
+
+    // --- decode next sequence image
+
+    err = heif_track_decode_next_image(track, &out_image,
+                                       heif_colorspace_YCbCr, // TODO: find best format
+                                       heif_chroma_420,
+                                       decode_options.get());
+    if (err.code == heif_error_End_of_sequence) {
+      break;
+    }
+    else if (err.code) {
+      std::cerr << err.message << "\n";
+      return 1;
+    }
+
+    // --- wait for image presentation time
+
+    uint32_t duration = heif_image_get_duration(out_image);
+    uint64_t timescale = heif_track_get_timescale(track);
+    uint64_t duration_ms = duration * 1000 / timescale;
+
+    if (option_show_frame_duration) {
+      std::cout << "sample duration " << heif_image_get_duration(out_image) << " = " << duration_ms << " ms\n";
+    }
+
+    static const uint64_t start_time = SDL_GetTicks64();
+    static uint64_t next_frame_pts = 0;
+
+    uint64_t now_time = SDL_GetTicks64();
+    uint64_t elapsed_time = (now_time - start_time);
+    if (elapsed_time < next_frame_pts) {
+      SDL_Delay((Uint32)(next_frame_pts - elapsed_time));
+    }
+
+    next_frame_pts += static_cast<uint64_t>(static_cast<double>(duration_ms) / option_speedup);
+
+
+    // --- display image
+
+    size_t stride_Y, stride_Cb, stride_Cr;
+    const uint8_t* p_Y = heif_image_get_plane_readonly2(out_image, heif_channel_Y, &stride_Y);
+    const uint8_t* p_Cb = heif_image_get_plane_readonly2(out_image, heif_channel_Cb, &stride_Cb);
+    const uint8_t* p_Cr = heif_image_get_plane_readonly2(out_image, heif_channel_Cr, &stride_Cr);
+
+    sdlWindow.display(p_Y, p_Cb, p_Cr, static_cast<int>(stride_Y), static_cast<int>(stride_Cb));
+
+    if (show_frame_number) {
+      std::cout << "--- frame " << frameNr << "\n";
+    }
+
+    if (option_show_sai) {
+      const char* contentID = heif_image_get_gimi_sample_content_id(out_image);
+      if (contentID) {
+        std::cout << "GIMI content id: " << contentID << "\n";
+        heif_string_release(contentID);
+      }
+
+      heif_tai_timestamp_packet* timestamp;
+      err = heif_image_get_tai_timestamp(out_image, &timestamp);
+      if (err.code) {
+        std::cerr << err.message << "\n";
+        return 10;
+      }
+      else if (timestamp) {
+        std::cout << "TAI timestamp: " << timestamp->tai_timestamp << "\n";
+        heif_tai_timestamp_packet_release(timestamp);
+      }
+    }
+
+    // --- get metadata sample
+
+    static heif_raw_sequence_sample* metadata_sample = nullptr;
+    static uint64_t metadata_sample_display_time = 0;
+
+    if (metadata_track && metadata_sample == nullptr) {
+      err = heif_track_get_next_raw_sequence_sample(metadata_track, &metadata_sample);
+      if (err.code != heif_error_Ok && err.code != heif_error_End_of_sequence) {
+        std::cerr << err.message << "\n";
+        return 10;
+      }
+    }
+
+    // --- show metadata
+
+    while (metadata_sample && static_cast<uint64_t>((double)metadata_sample_display_time / option_speedup) <= elapsed_time) {
+      size_t size;
+      const uint8_t* data = heif_raw_sequence_sample_get_data(metadata_sample, &size);
+
+      std::cout << "timestamp: " << ((double)metadata_sample_display_time)/1000.0f << "sec\n";
+
+      if (option_metadata_output == metadata_output_text) {
+        std::cout << ((const char*) data) << "\n";
+      }
+      else if (option_metadata_output == metadata_output_hex) {
+        output_hex(data, size);
+        std::cout << '\n';
+      }
+
+      uint64_t metadata_timescale = heif_track_get_timescale(metadata_track);
+      uint32_t metadata_duration = heif_raw_sequence_sample_get_duration(metadata_sample);
+      metadata_sample_display_time += metadata_duration * 1000 / metadata_timescale;
+
+      heif_raw_sequence_sample_release(metadata_sample);
+      metadata_sample = nullptr;
+
+      // get next metadata sample
+
+      err = heif_track_get_next_raw_sequence_sample(metadata_track, &metadata_sample);
+      if (err.code != heif_error_Ok && err.code != heif_error_End_of_sequence) {
+        std::cerr << err.message << "\n";
+        return 10;
+      }
+    }
+
+    heif_image_release(out_image);
+
+    if (sdlWindow.doQuit()) {
+      break;
+    }
+  }
+
+  sdlWindow.close();
+
+  heif_track_release(track);
+  heif_track_release(metadata_track);
+
+  return 0;
+}
diff --git a/examples/sdl.cc b/examples/sdl.cc
new file mode 100644
index 0000000000..051a8d9f5e
--- /dev/null
+++ b/examples/sdl.cc
@@ -0,0 +1,302 @@
+/*
+  This file is part of dec265, an example application using libde265.
+
+  MIT License
+
+  Copyright (c) 2013-2014 struktur AG, Dirk Farin <farin@struktur.de>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#include "sdl.hh"
+#include <sstream>
+
+
+std::optional<std::string> SDL_YUV_Display::init(int frame_width, int frame_height, enum SDL_Chroma chroma,
+                                                 const char* window_title)
+{
+  // reduce image size to a multiple of 8 (apparently required by YUV overlay)
+
+  frame_width  &= ~7;
+  frame_height &= ~7;
+
+  mChroma = chroma;
+
+  if (SDL_Init(SDL_INIT_VIDEO) < 0 ) {
+    std::stringstream sstr;
+    sstr << "SDL_Init() failed: " << SDL_GetError();
+    SDL_Quit();
+    return sstr.str();
+  }
+
+  // set window title
+  mWindow = SDL_CreateWindow(window_title,
+    SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
+    frame_width, frame_height, 0);
+  if (!mWindow) {
+    std::stringstream sstr;
+    sstr << "SDL: Couldn't set video mode to " << frame_width << "x" << frame_height << ": " << SDL_GetError();
+    SDL_Quit();
+    return sstr.str();
+  }
+
+  Uint32 flags = 0;  // Empty flags prioritize SDL_RENDERER_ACCELERATED.
+  mRenderer = SDL_CreateRenderer(mWindow, -1, flags);
+  if (!mRenderer) {
+    std::stringstream sstr;
+    sstr << "SDL: Couldn't create renderer: " << SDL_GetError();
+    SDL_Quit();
+    return sstr.str();
+  }
+
+  Uint32 pixelFormat = 0;
+  switch (mChroma) {
+  case SDL_CHROMA_MONO: pixelFormat = SDL_PIXELFORMAT_YV12; break;
+  case SDL_CHROMA_420:  pixelFormat = SDL_PIXELFORMAT_YV12; break;
+  case SDL_CHROMA_422:  pixelFormat = SDL_PIXELFORMAT_YV12; break;
+  case SDL_CHROMA_444:  pixelFormat = SDL_PIXELFORMAT_YV12; break;
+  default: {
+    std::stringstream sstr;
+    sstr << "Unsupported chroma: " << (int)mChroma;
+    SDL_Quit();
+    return sstr.str();
+  }
+  }
+
+  mTexture = SDL_CreateTexture(mRenderer, pixelFormat,
+    SDL_TEXTUREACCESS_STREAMING, frame_width, frame_height);
+  if (!mTexture ) {
+    std::stringstream sstr;
+    sstr << "SDL: Couldn't create SDL texture: " << SDL_GetError();
+    SDL_Quit();
+    return sstr.str();
+  }
+
+  rect.x = 0;
+  rect.y = 0;
+  rect.w = frame_width;
+  rect.h = frame_height;
+
+  mWindowOpen=true;
+
+  return {};
+}
+
+void SDL_YUV_Display::display(const unsigned char *Y,
+                              const unsigned char *U,
+                              const unsigned char *V,
+                              int stride, int chroma_stride)
+{
+  if (!mWindowOpen) return;
+  if (SDL_LockTexture(mTexture, nullptr,
+    reinterpret_cast<void**>(&mPixels), &mStride) < 0) return;
+
+  if (mChroma == SDL_CHROMA_420) {
+    display420(Y,U,V,stride,chroma_stride);
+  }
+  else if (mChroma == SDL_CHROMA_422) {
+    display422(Y,U,V,stride,chroma_stride);
+  }
+  else if (mChroma == SDL_CHROMA_444) {
+    display444as420(Y,U,V,stride,chroma_stride);
+    //display444as422(Y,U,V,stride,chroma_stride);
+  }
+  else if (mChroma == SDL_CHROMA_MONO) {
+    display400(Y,stride);
+  }
+
+  SDL_UnlockTexture(mTexture);
+
+  SDL_RenderCopy(mRenderer, mTexture, nullptr, nullptr);
+  SDL_RenderPresent(mRenderer);
+}
+
+
+void SDL_YUV_Display::display420(const unsigned char *Y,
+                                 const unsigned char *U,
+                                 const unsigned char *V,
+                                 int stride, int chroma_stride)
+{
+  if (stride == mStride && chroma_stride == mStride/2) {
+
+    // fast copy
+
+    memcpy(mPixels, Y, rect.w * rect.h);
+    memcpy(&mPixels[rect.w * rect.h], V, rect.w * rect.h / 4);
+    memcpy(&mPixels[(rect.w * rect.h) + (rect.w * rect.h / 4)], U, rect.w * rect.h / 4);
+  }
+  else {
+    // copy line by line, because sizes are different
+    uint8_t *dest = mPixels;
+
+    for (int y=0;y<rect.h;y++,dest+=mStride)
+      {
+        memcpy(dest, Y+stride*y, rect.w);
+      }
+
+    for (int y=0;y<rect.h/2;y++,dest+=mStride/2)
+      {
+        memcpy(dest, V+chroma_stride*y, rect.w/2);
+      }
+
+    for (int y=0;y<rect.h/2;y++,dest+=mStride/2)
+      {
+        memcpy(dest, U+chroma_stride*y, rect.w/2);
+      }
+  }
+}
+
+
+void SDL_YUV_Display::display400(const unsigned char *Y, int stride)
+{
+  uint8_t *dest = mPixels;
+  if (stride == mStride) {
+
+    // fast copy
+
+    memcpy(mPixels, Y, rect.w * rect.h);
+    dest += mStride * rect.h;
+  }
+  else {
+    // copy line by line, because sizes are different
+
+    for (int y=0;y<rect.h;y++,dest+=mStride)
+      {
+        memcpy(dest, Y+stride*y, rect.w);
+      }
+  }
+
+  // clear chroma planes
+
+  memset(dest, 0x80, mStride * rect.h / 2);
+}
+
+
+void SDL_YUV_Display::display422(const unsigned char* Y,
+                                 const unsigned char* U,
+                                 const unsigned char* V,
+                                 int stride, int chroma_stride)
+{
+  for (int y = 0; y < rect.h; y++) {
+    unsigned char* dstY = mPixels + y * mStride;
+    const unsigned char* Yp = Y + y * stride;
+
+    memcpy(dstY, Yp, rect.w);
+  }
+
+  for (int y = 0; y < rect.h; y += 2) {
+    unsigned char* dstV = mPixels + (y / 2) * mStride / 2 + rect.w * rect.h;
+    unsigned char* dstU = mPixels + (y / 2) * mStride / 2 + rect.w * rect.h + rect.w * rect.h / 4;
+
+    const unsigned char* Up = U + y * chroma_stride;
+    const unsigned char* Vp = V + y * chroma_stride;
+
+    memcpy(dstU, Up, rect.w / 2);
+    memcpy(dstV, Vp, rect.w / 2);
+  }
+}
+
+
+/* This converts down 4:4:4 input to 4:2:2 for display, as SDL does not support
+   any 4:4:4 pixel format.
+ */
+void SDL_YUV_Display::display444as422(const unsigned char *Y,
+                                      const unsigned char *U,
+                                      const unsigned char *V,
+                                      int stride, int chroma_stride)
+{
+  for (int y=0;y<rect.h;y++)
+    {
+      unsigned char* p = mPixels + y*mStride *2;
+
+      const unsigned char* Yp = Y + y*stride;
+      const unsigned char* Up = U + y*chroma_stride;
+      const unsigned char* Vp = V + y*chroma_stride;
+
+      for (int x=0;x<rect.w;x+=2) {
+        *p++ = Yp[x];
+        *p++ = Up[x];
+        *p++ = Yp[x+1];
+        *p++ = Vp[x];
+      }
+    }
+}
+
+
+void SDL_YUV_Display::display444as420(const unsigned char *Y,
+                                      const unsigned char *U,
+                                      const unsigned char *V,
+                                      int stride, int chroma_stride)
+{
+  for (int y=0;y<rect.h;y++)
+    {
+      unsigned char* p = mPixels + y*mStride;
+      memcpy(p, Y+y*stride, rect.w);
+    }
+
+  uint8_t *startV = mPixels + (rect.h*mStride);
+  uint8_t *startU = startV + (rect.h*mStride/2);
+  for (int y=0;y<rect.h;y+=2)
+    {
+      uint8_t* u = startU + y/2*mStride/2;
+      uint8_t* v = startV + y/2*mStride/2;
+
+      for (int x=0;x<rect.w;x+=2) {
+        u[x / 2] = static_cast<uint8_t>((U[(y + 0) * chroma_stride + x] + U[(y + 0) * chroma_stride + x + 1] +
+                                         U[(y + 1) * chroma_stride + x] + U[(y + 1) * chroma_stride + x + 1]) / 4);
+        v[x / 2] = static_cast<uint8_t>((V[(y + 0) * chroma_stride + x] + V[(y + 0) * chroma_stride + x + 1] +
+                                         V[(y + 1) * chroma_stride + x] + V[(y + 1) * chroma_stride + x + 1]) / 4);
+
+        //u[x/2] = U[y*chroma_stride + x];
+        //v[x/2] = V[y*chroma_stride + x];
+      }
+    }
+}
+
+
+bool SDL_YUV_Display::doQuit() const
+{
+  SDL_Event event;
+  while (SDL_PollEvent(&event)) {
+    if (event.type == SDL_QUIT) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+void SDL_YUV_Display::close()
+{
+  if (mTexture) {
+    SDL_DestroyTexture(mTexture);
+    mTexture = nullptr;
+  }
+  if (mRenderer) {
+    SDL_DestroyRenderer(mRenderer);
+    mRenderer = nullptr;
+  }
+  if (mWindow) {
+    SDL_DestroyWindow(mWindow);
+    mWindow = nullptr;
+  }
+  SDL_Quit();
+
+  mWindowOpen=false;
+}
diff --git a/examples/sdl.hh b/examples/sdl.hh
new file mode 100644
index 0000000000..6fc43d1b5a
--- /dev/null
+++ b/examples/sdl.hh
@@ -0,0 +1,82 @@
+/*
+  This file is part of dec265, an example application using libde265.
+
+  MIT License
+
+  Copyright (c) 2013-2014 struktur AG, Dirk Farin <farin@struktur.de>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+ */
+
+#include <SDL2/SDL.h>
+#include <string>
+#include <optional>
+
+
+class SDL_YUV_Display
+{
+public:
+
+  enum SDL_Chroma {
+    SDL_CHROMA_MONO=400,
+    SDL_CHROMA_420 =420,
+    SDL_CHROMA_422 =422,
+    SDL_CHROMA_444 =444
+  };
+
+  // Returns error message or nullopt on success.
+  std::optional<std::string> init(int frame_width, int frame_height, enum SDL_Chroma chroma, const char* window_title);
+  void display(const unsigned char *Y, const unsigned char *U, const unsigned char *V,
+               int stride, int chroma_stride);
+  void close();
+
+  bool doQuit() const;
+
+  bool isOpen() const { return mWindowOpen; }
+
+private:
+  SDL_Window *mWindow = nullptr;
+  SDL_Renderer *mRenderer = nullptr;
+  SDL_Texture *mTexture = nullptr;
+  SDL_Rect     rect;
+  bool         mWindowOpen;
+  uint8_t *mPixels = nullptr;
+  int mStride = 0;
+
+  SDL_Chroma mChroma;
+
+  void display400(const unsigned char *Y,
+                  int stride);
+  void display420(const unsigned char *Y,
+                  const unsigned char *U,
+                  const unsigned char *V,
+                  int stride, int chroma_stride);
+  void display422(const unsigned char *Y,
+                  const unsigned char *U,
+                  const unsigned char *V,
+                  int stride, int chroma_stride);
+  void display444as422(const unsigned char *Y,
+                       const unsigned char *U,
+                       const unsigned char *V,
+                       int stride, int chroma_stride);
+  void display444as420(const unsigned char *Y,
+                       const unsigned char *U,
+                       const unsigned char *V,
+                       int stride, int chroma_stride);
+};
diff --git a/examples/test_c_api.c b/examples/test_c_api.c
index 3649a7cbf7..bd3a6fc341 100644
--- a/examples/test_c_api.c
+++ b/examples/test_c_api.c
@@ -4,7 +4,7 @@
 
   MIT License
 
-  Copyright (c) 2018 struktur AG, Dirk Farin <farin@struktur.de>
+  Copyright (c) 2018 Dirk Farin <dirk.farin@gmail.com>
 
   Permission is hereby granted, free of charge, to any person obtaining a copy
   of this software and associated documentation files (the "Software"), to deal
diff --git a/examples/utf8.manifest b/examples/utf8.manifest
new file mode 100644
index 0000000000..dab929e151
--- /dev/null
+++ b/examples/utf8.manifest
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1">
+  <application>
+    <windowsSettings>
+      <activeCodePage xmlns="http://schemas.microsoft.com/SMI/2019/WindowsSettings">UTF-8</activeCodePage>
+    </windowsSettings>
+  </application>
+</assembly>
diff --git a/examples/utf8.rc b/examples/utf8.rc
new file mode 100644
index 0000000000..62bdbdc362
--- /dev/null
+++ b/examples/utf8.rc
@@ -0,0 +1,3 @@
+#include <winuser.h>
+
+CREATEPROCESS_MANIFEST_RESOURCE_ID RT_MANIFEST "utf8.manifest"
diff --git a/examples/vmt.cc b/examples/vmt.cc
new file mode 100644
index 0000000000..c0e715e404
--- /dev/null
+++ b/examples/vmt.cc
@@ -0,0 +1,314 @@
+/*
+  libheif example application "heif-enc" - VMT metadata track support.
+
+  MIT License
+
+  Copyright (c) 2025 Dirk Farin <dirk.farin@gmail.com>
+  Copyright (c) 2026 Rob Smith <rob.smith@awayteam.co.uk>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#include "vmt.h"
+
+#include <cstdint>
+#include <fstream>
+#include <iostream>
+#include <optional>
+#include <regex>
+#include <string>
+#include <vector>
+
+#include <libheif/heif.h>
+#include <libheif/heif_sequences.h>
+
+
+static const uint32_t BAD_VMT_TIMESTAMP = 0xFFFFFFFE;
+
+
+static std::optional<uint8_t> nibble_to_val(char c)
+{
+  if (c>='0' && c<='9') {
+    return c - '0';
+  }
+  if (c>='a' && c<='f') {
+    return c - 'a' + 10;
+  }
+  if (c>='A' && c<='F') {
+    return c - 'A' + 10;
+  }
+
+  return std::nullopt;
+}
+
+// Convert hex data to raw binary. Ignore any non-hex characters.
+static std::vector<uint8_t> hex_to_binary(const std::string& line)
+{
+  std::vector<uint8_t> data;
+  uint8_t current_value = 0;
+
+  bool high_nibble = true;
+  for (auto c : line) {
+    auto v = nibble_to_val(c);
+    if (v) {
+      if (high_nibble) {
+        current_value = static_cast<uint8_t>(*v << 4);
+        high_nibble = false;
+      }
+      else {
+        current_value |= *v;
+        data.push_back(current_value);
+        high_nibble = true;
+      }
+    }
+  }
+
+  return data;
+}
+
+
+// Convert base64 data to raw binary.
+static std::vector<uint8_t> decode_base64(const std::string& line)
+{
+  const std::string base64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  std::vector<uint8_t> data;
+
+  size_t len = line.size();
+  if (len % 4 != 0) {
+    len = int(len / 4) * 4;
+  }
+
+  for (size_t i = 0; i < len; i += 4) {
+    uint8_t buf[4];
+    for (uint8_t j = 0; j < 4; j++) {
+      size_t k = base64.find(line[i + j]);
+      buf[j] = (uint8_t)(k == std::string::npos ? base64.size() : k);
+    }
+
+    data.push_back((uint8_t)(buf[0] << 2) + (buf[1] >> 4));
+
+    if (line[i + 2] != '=') {
+      data.push_back((uint8_t)((buf[1] & 0x0f) << 4) + (buf[2] >> 2));
+    }
+
+    if (line[i + 3] != '=') {
+      data.push_back((uint8_t)((buf[2] & 0x03) << 6) + buf[3]);
+    }
+  }
+
+  return data;
+}
+
+
+// Parse metadata from WebVMT sync commmands
+static std::vector<uint8_t> parse_vmt_sync_data(const std::string& content)
+{
+  std::vector<uint8_t> data;
+
+  std::regex pattern_sync(R"(\s*\{\s*\"sync\"\s*:\s*\{(.*?)\}\s*\}\s*)");
+  const std::sregex_token_iterator ti_end;
+
+  for (std::sregex_token_iterator ti(content.begin(), content.end(), pattern_sync, 1); ti != ti_end; ++ti)
+  {
+    std::string sync = *ti;
+    std::regex pattern_type(R"(.*\"type\"\s*:\s*\"(.*?)\".*)");
+    std::regex pattern_data(R"(.*\"data\"\s*:\s*\"(.*?)\".*)");
+    std::smatch match;
+
+    if (std::regex_match(sync, match, pattern_type)) {
+      std::string type = match[1];
+
+      std::regex pattern_hex(R"(.*\.hex$)");
+      std::regex pattern_b64(R"(.*\.base64$)");
+
+      std::string textData;
+      if (std::regex_match(sync, match, pattern_data)) {
+        textData = match[1];
+      }
+
+      if (std::regex_match(type, match, pattern_hex)) {
+        std::vector<uint8_t> binaryData = hex_to_binary(textData);
+        data.insert(data.end(), binaryData.begin(), binaryData.end());
+      }
+      else if (std::regex_match(type, match, pattern_b64)) {
+        std::vector<uint8_t> binaryData = decode_base64(textData);
+        data.insert(data.end(), binaryData.begin(), binaryData.end());
+      }
+      else {
+        data.insert(data.end(), textData.data(), textData.data() + textData.length());
+      }
+    }
+  }
+
+  return data;
+}
+
+
+static uint32_t parse_vmt_timestamp(const std::string& vmt_time)
+{
+  std::regex pattern(R"(-?((\d*):)?(\d\d):(\d\d)(\.(\d*))?)");
+  std::smatch match;
+
+  if (!std::regex_match(vmt_time, match, pattern)) {
+    return 0; // no match
+  }
+
+  std::string hh = match[2]; // optional
+  std::string mm = match[3];
+  std::string ss = match[4];
+  std::string fs = match[6]; // optional
+
+  if (vmt_time.find('-') != std::string::npos) {
+    return 0; // negative time not supported
+  }
+
+  uint32_t ms = 0;
+
+  if (fs != "") {
+    if (fs.length() == 3) {
+      ms = std::stoi(fs);
+    }
+    else {
+      return BAD_VMT_TIMESTAMP; // invalid
+    }
+  }
+
+  uint32_t ts = ((hh != "" ? std::stoi(hh) : 0) * 3600 * 1000 +
+                 std::stoi(mm) * 60 * 1000 +
+                 std::stoi(ss) * 1000 +
+                 ms);
+
+  return ts;
+}
+
+int encode_vmt_metadata_track(heif_context* context, heif_track* visual_track,
+                              const std::string& vmt_metadata_file,
+                              const std::string& track_uri, bool binary)
+{
+  // --- add metadata track
+
+  heif_track* track = nullptr;
+
+  heif_track_options* track_options = heif_track_options_alloc();
+  heif_track_options_set_timescale(track_options, 1000);
+
+  heif_context_add_uri_metadata_sequence_track(context, track_uri.c_str(), track_options, &track);
+  heif_raw_sequence_sample* sample = heif_raw_sequence_sample_alloc();
+
+
+  std::ifstream istr(vmt_metadata_file.c_str());
+
+  std::regex pattern_cue(R"(^\s*(-?(\d|:|\.)*)\s*-->\s*(-?(\d|:|\.)*)?.*)");
+  std::regex pattern_note(R"(^\s*(NOTE).*)");
+
+  static std::vector<uint8_t> prev_metadata;
+  static std::optional<uint32_t> prev_ts;
+
+  std::string line;
+  while (std::getline(istr, line))
+  {
+    std::smatch match;
+
+    if (std::regex_match(line, match, pattern_note)) {
+      while (std::getline(istr, line)) {
+        if (line.empty()) {
+          break;
+        }
+      }
+
+      continue;
+    }
+
+    if (!std::regex_match(line, match, pattern_cue)) {
+      continue;
+    }
+
+    std::string cue_start = match[1];
+    std::string cue_end = match[3]; // == "" for unbounded cues
+
+    uint32_t ts = parse_vmt_timestamp(cue_start);
+
+    std::vector<uint8_t> concat;
+
+    if (binary) {
+      while (std::getline(istr, line)) {
+        if (line.empty()) {
+          break;
+        }
+
+        std::vector<uint8_t> binaryData = hex_to_binary(line);
+        concat.insert(concat.end(), binaryData.begin(), binaryData.end());
+      }
+
+    }
+    else {
+      while (std::getline(istr, line)) {
+        if (line.empty()) {
+          break;
+        }
+
+        concat.insert(concat.end(), line.data(), line.data() + line.length());
+        concat.push_back('\n');
+      }
+
+      concat.push_back(0);
+      std::string content(concat.begin(), concat.end());
+      concat = parse_vmt_sync_data(content);
+    }
+
+    if (ts != BAD_VMT_TIMESTAMP) {
+
+      if (ts > *prev_ts) {
+        heif_raw_sequence_sample_set_data(sample, (const uint8_t*)prev_metadata.data(), prev_metadata.size());
+        heif_raw_sequence_sample_set_duration(sample, ts - *prev_ts);
+        heif_track_add_raw_sequence_sample(track, sample);
+      }
+      else if (ts == *prev_ts) {
+        concat.insert(concat.begin(), prev_metadata.begin(), prev_metadata.end());
+      }
+      else {
+        std::cerr << "Bad WebVMT timestamp order: " << cue_start << "\n";
+      }
+
+      prev_ts = ts;
+      prev_metadata = concat;
+    }
+    else {
+      std::cerr << "Bad WebVMT timestamp: " << cue_start << "\n";
+    }
+  }
+
+  // --- flush last metadata packet
+
+  heif_raw_sequence_sample_set_data(sample, (const uint8_t*)prev_metadata.data(), prev_metadata.size());
+  heif_raw_sequence_sample_set_duration(sample, 1);
+  heif_track_add_raw_sequence_sample(track, sample);
+
+  // --- add track reference
+
+  heif_track_add_reference_to_track(track, heif_track_reference_type_description, visual_track);
+
+  // --- release all objects
+
+  heif_raw_sequence_sample_release(sample);
+  heif_track_options_release(track_options);
+  heif_track_release(track);
+
+  return 0;
+}
diff --git a/examples/vmt.h b/examples/vmt.h
new file mode 100644
index 0000000000..3c65303906
--- /dev/null
+++ b/examples/vmt.h
@@ -0,0 +1,38 @@
+/*
+  libheif example application "heif-enc" - VMT metadata track support.
+
+  MIT License
+
+  Copyright (c) 2025 Dirk Farin <dirk.farin@gmail.com>
+  Copyright (c) 2026 Rob Smith <rob.smith@awayteam.co.uk>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#pragma once
+
+#include <string>
+#include <cstdint>
+
+struct heif_context;
+struct heif_track;
+
+int encode_vmt_metadata_track(heif_context* context, heif_track* visual_track,
+                              const std::string& vmt_metadata_file,
+                              const std::string& track_uri, bool binary);
diff --git a/extra/Makefile.am b/extra/Makefile.am
deleted file mode 100644
index 465d9a5636..0000000000
--- a/extra/Makefile.am
+++ /dev/null
@@ -1,4 +0,0 @@
-EXTRA_DIST = \
-    getopt.c \
-    getopt.h \
-    getopt_long.c
diff --git a/extra/getopt.h b/extra/getopt.h
index b23a4fbeee..f5d3bfaad1 100644
--- a/extra/getopt.h
+++ b/extra/getopt.h
@@ -55,8 +55,8 @@ struct option
 #define required_argument 1
 #define optional_argument 2
 
-int getopt(int, char**, char*);
-int getopt_long(int, char**, char*, struct option*, int*);
+int getopt(int, char**, const char*);
+int getopt_long(int, char**, const char*, struct option*, int*);
 
 #ifdef __cplusplus
 }
diff --git a/extra/getopt_long.c b/extra/getopt_long.c
index 8dfda80049..a1d5055260 100644
--- a/extra/getopt_long.c
+++ b/extra/getopt_long.c
@@ -73,7 +73,7 @@ __progname(char * nargv0)
  *	Parse argc/argv argument vector.
  */
 int
-getopt_internal(int nargc, char ** nargv, const char *ostr)
+getopt_internal(int nargc, char * const* nargv, const char *ostr)
 {
 	static char *place = EMSG;		/* option letter processing */
 	const char *oli;				/* option letter list index */
@@ -142,7 +142,7 @@ getopt2(int nargc, char * nargv, const char *ostr)
 
 	if ((retval = getopt_internal(nargc, nargv, ostr)) == -2) {
 		retval = -1;
-		++optind; 
+		++optind;
 	}
 	return(retval);
 }
@@ -153,7 +153,7 @@ getopt2(int nargc, char * nargv, const char *ostr)
  *	Parse argc/argv argument vector.
  */
 int
-getopt_long(int nargc, char ** nargv, char * options, struct option * long_options, int * index)
+getopt_long(int nargc, char ** nargv, const char * options, struct option * long_options, int * index)
 {
 	int retval;
 
@@ -175,11 +175,11 @@ getopt_long(int nargc, char ** nargv, char * options, struct option * long_optio
 		} else
 			current_argv_len = strlen(current_argv);
 
-		for (i = 0; long_options[i].name; i++) { 
+		for (i = 0; long_options[i].name; i++) {
 			if (strncmp(current_argv, long_options[i].name, current_argv_len))
 				continue;
 
-			if (strlen(long_options[i].name) == (unsigned)current_argv_len) { 
+			if (strlen(long_options[i].name) == (unsigned)current_argv_len) {
 				match = i;
 				break;
 			}
@@ -215,7 +215,7 @@ getopt_long(int nargc, char ** nargv, char * options, struct option * long_optio
 		if (long_options[match].flag) {
 			*long_options[match].flag = long_options[match].val;
 			retval = 0;
-		} else 
+		} else
 			retval = long_options[match].val;
 		if (index)
 			*index = match;
diff --git a/fuzzing/CMakeLists.txt b/fuzzing/CMakeLists.txt
new file mode 100644
index 0000000000..02fb513803
--- /dev/null
+++ b/fuzzing/CMakeLists.txt
@@ -0,0 +1,14 @@
+include_directories(${libheif_BINARY_DIR} ${libheif_SOURCE_DIR}/libheif ${libheif_SOURCE_DIR}/libheif/api)
+
+
+add_executable(box_fuzzer box_fuzzer.cc)
+target_link_libraries(box_fuzzer PRIVATE heif)
+
+add_executable(color_conversion_fuzzer color_conversion_fuzzer.cc)
+target_link_libraries(color_conversion_fuzzer PRIVATE heif)
+
+add_executable(encoder_fuzzer encoder_fuzzer.cc)
+target_link_libraries(encoder_fuzzer PRIVATE heif)
+
+add_executable(file_fuzzer file_fuzzer.cc)
+target_link_libraries(file_fuzzer PRIVATE heif)
diff --git a/fuzzing/Makefile.am b/fuzzing/Makefile.am
deleted file mode 100644
index 534b10b516..0000000000
--- a/fuzzing/Makefile.am
+++ /dev/null
@@ -1,3 +0,0 @@
-EXTRA_DIST = \
-    corpus/*.heic \
-    dictionary.txt
diff --git a/libheif/box_fuzzer.cc b/fuzzing/box_fuzzer.cc
similarity index 63%
rename from libheif/box_fuzzer.cc
rename to fuzzing/box_fuzzer.cc
index f1535c1bd7..114c8dc5e4 100644
--- a/libheif/box_fuzzer.cc
+++ b/fuzzing/box_fuzzer.cc
@@ -22,23 +22,31 @@
 
 #include "box.h"
 #include "bitstream.h"
+#include "context.h"
 #include "logging.h"
 
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
-  auto reader = std::make_shared<heif::StreamReader_memory>(data, size, false);
+  auto reader = std::make_shared<StreamReader_memory>(data, size, false);
 
-  heif::BitstreamRange range(reader, size);
+  // --- OSS-Fuzz assumes a bug if the allocated memory exceeds 2560 MB.
+  //     Set a lower allocation limit to prevent this.
+
+  // Use a context for tracking the memory usage and set the reduced limit.
+  HeifContext ctx;
+  ctx.get_security_limits()->max_total_memory = UINT64_C(2) * 1024 * 1024 * 1024;
+
+  BitstreamRange range(reader, size);
   for (;;) {
-    std::shared_ptr<heif::Box> box;
-    heif::Error error = heif::Box::read(range, &box);
-    if (error != heif::Error::Ok || range.error()) {
+    std::shared_ptr<Box> box;
+    Error error = Box::read(range, &box, ctx.get_security_limits());
+    if (error != Error::Ok || range.error()) {
       break;
     }
 
     box->get_type();
     box->get_type_string();
-    heif::Indent indent;
+    Indent indent;
     box->dump(indent);
   }
 
diff --git a/libheif/color_conversion_fuzzer.cc b/fuzzing/color_conversion_fuzzer.cc
similarity index 72%
rename from libheif/color_conversion_fuzzer.cc
rename to fuzzing/color_conversion_fuzzer.cc
index 13509ff9ed..91d740a8ee 100644
--- a/libheif/color_conversion_fuzzer.cc
+++ b/fuzzing/color_conversion_fuzzer.cc
@@ -23,8 +23,8 @@
 #include <sstream>
 
 #include "bitstream.h"
-#include "heif_colorconversion.h"
-#include "heif_image.h"
+#include "color-conversion/colorconversion.h"
+#include "pixelimage.h"
 
 static bool is_valid_chroma(uint8_t chroma)
 {
@@ -57,47 +57,53 @@ static bool is_valid_colorspace(uint8_t colorspace)
   }
 }
 
-static bool read_plane(heif::BitstreamRange* range,
-                       std::shared_ptr<heif::HeifPixelImage> image, heif_channel channel,
-                       int width, int height, int bit_depth)
+static bool read_plane(BitstreamRange* range,
+                       std::shared_ptr<HeifPixelImage> image, heif_channel channel,
+                       uint32_t width, uint32_t height, int bit_depth)
 {
   if (width <= 0 || height <= 0) {
     return false;
   }
-  if (!range->prepare_read(static_cast<uint64_t>(width) * height)) {
+  if (std::numeric_limits<size_t>::max()/width/height == 0) {
     return false;
   }
-  if (!image->add_plane(channel, width, height, bit_depth)) {
+  if (!range->prepare_read(static_cast<size_t>(width) * height)) {
     return false;
   }
-  int stride;
+  if (auto err = image->add_plane(channel, width, height, bit_depth, heif_get_disabled_security_limits())) {
+    return false;
+  }
+  size_t stride;
   uint8_t* plane = image->get_plane(channel, &stride);
   assert(stride >= width);
   auto stream = range->get_istream();
-  for (int y = 0; y < height; y++, plane += stride) {
+  for (uint32_t y = 0; y < height; y++, plane += stride) {
     assert(stream->read(plane, width));
   }
   return true;
 }
 
-static bool read_plane_interleaved(heif::BitstreamRange* range,
-                                   std::shared_ptr<heif::HeifPixelImage> image, heif_channel channel,
-                                   int width, int height, int bit_depth, int comps)
+static bool read_plane_interleaved(BitstreamRange* range,
+                                   std::shared_ptr<HeifPixelImage> image, heif_channel channel,
+                                   uint32_t width, uint32_t height, int bit_depth, int comps)
 {
   if (width <= 0 || height <= 0) {
     return false;
   }
-  if (!range->prepare_read(static_cast<uint64_t>(width) * height * comps)) {
+  if (std::numeric_limits<size_t>::max()/width/height/comps == 0) {
     return false;
   }
-  if (!image->add_plane(channel, width, height, bit_depth)) {
+  if (!range->prepare_read(static_cast<size_t>(width) * height * comps)) {
     return false;
   }
-  int stride;
+  if (auto err = image->add_plane(channel, width, height, bit_depth, heif_get_disabled_security_limits())) {
+    return false;
+  }
+  size_t stride;
   uint8_t* plane = image->get_plane(channel, &stride);
   assert(stride >= width * comps);
   auto stream = range->get_istream();
-  for (int y = 0; y < height; y++, plane += stride) {
+  for (uint32_t y = 0; y < height; y++, plane += stride) {
     assert(stream->read(plane, width * comps));
   }
   return true;
@@ -105,11 +111,11 @@ static bool read_plane_interleaved(heif::BitstreamRange* range,
 
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
-  auto reader = std::make_shared<heif::StreamReader_memory>(data, size, false);
-  heif::BitstreamRange range(reader, size);
+  auto reader = std::make_shared<StreamReader_memory>(data, size, false);
+  BitstreamRange range(reader, size);
 
-  int width;
-  int height;
+  uint32_t width;
+  uint32_t height;
   int bit_depth;
   bool alpha;
   uint8_t in_chroma;
@@ -147,7 +153,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     return 0;
   }
 
-  auto in_image = std::make_shared<heif::HeifPixelImage>();
+  auto in_image = std::make_shared<HeifPixelImage>();
   in_image->create(width, height, static_cast<heif_colorspace>(in_colorspace),
                    static_cast<heif_chroma>(in_chroma));
 
@@ -240,15 +246,31 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     }
   }
 
-  auto out_image = convert_colorspace(in_image,
-                                      static_cast<heif_colorspace>(out_colorspace),
-                                      static_cast<heif_chroma>(out_chroma),
-                                      nullptr);
-  if (!out_image) {
+  // TODO: also fuzz these parameters.
+  int output_bpp = 0; // Same as input.
+  heif_encoding_options* options = heif_encoding_options_alloc();
+
+  heif_color_conversion_options_ext* options_ext = heif_color_conversion_options_ext_alloc();
+
+  auto out_image_result = convert_colorspace(in_image,
+                                             static_cast<heif_colorspace>(out_colorspace),
+                                             static_cast<heif_chroma>(out_chroma),
+                                             nclx_profile::undefined(),
+                                             output_bpp,
+                                             options->color_conversion_options,
+                                             options_ext,
+                                             heif_get_disabled_security_limits());
+
+  heif_encoding_options_free(options);
+  heif_color_conversion_options_ext_free(options_ext);
+
+  if (!out_image_result) {
     // Conversion is not supported.
     return 0;
   }
 
+  auto out_image = *out_image_result;
+
   assert(out_image->get_width() == width);
   assert(out_image->get_height() == height);
   assert(out_image->get_chroma_format() ==
diff --git a/fuzzing/corpus/clap-overflow-divide-zero.heic b/fuzzing/data/corpus/clap-overflow-divide-zero.heic
similarity index 100%
rename from fuzzing/corpus/clap-overflow-divide-zero.heic
rename to fuzzing/data/corpus/clap-overflow-divide-zero.heic
diff --git a/fuzzing/data/corpus/clusterfuzz-testcase-minimized-color-conversion-fuzzer-6275694804467712 b/fuzzing/data/corpus/clusterfuzz-testcase-minimized-color-conversion-fuzzer-6275694804467712
new file mode 100644
index 0000000000..f781bfba7d
Binary files /dev/null and b/fuzzing/data/corpus/clusterfuzz-testcase-minimized-color-conversion-fuzzer-6275694804467712 differ
diff --git a/fuzzing/data/corpus/clusterfuzz-testcase-minimized-file-fuzzer-4616081830051840.heic b/fuzzing/data/corpus/clusterfuzz-testcase-minimized-file-fuzzer-4616081830051840.heic
new file mode 100644
index 0000000000..c95adbc36e
Binary files /dev/null and b/fuzzing/data/corpus/clusterfuzz-testcase-minimized-file-fuzzer-4616081830051840.heic differ
diff --git a/fuzzing/data/corpus/clusterfuzz-testcase-minimized-file-fuzzer-5120279175102464.heic b/fuzzing/data/corpus/clusterfuzz-testcase-minimized-file-fuzzer-5120279175102464.heic
new file mode 100644
index 0000000000..0fe029e93e
Binary files /dev/null and b/fuzzing/data/corpus/clusterfuzz-testcase-minimized-file-fuzzer-5120279175102464.heic differ
diff --git a/fuzzing/data/corpus/clusterfuzz-testcase-minimized-file-fuzzer-5643900194127872.heic b/fuzzing/data/corpus/clusterfuzz-testcase-minimized-file-fuzzer-5643900194127872.heic
new file mode 100644
index 0000000000..b058f402d0
Binary files /dev/null and b/fuzzing/data/corpus/clusterfuzz-testcase-minimized-file-fuzzer-5643900194127872.heic differ
diff --git a/fuzzing/corpus/clusterfuzz-testcase-minimized-file-fuzzer-5651556035198976.heic b/fuzzing/data/corpus/clusterfuzz-testcase-minimized-file-fuzzer-5651556035198976.heic
similarity index 100%
rename from fuzzing/corpus/clusterfuzz-testcase-minimized-file-fuzzer-5651556035198976.heic
rename to fuzzing/data/corpus/clusterfuzz-testcase-minimized-file-fuzzer-5651556035198976.heic
diff --git a/fuzzing/corpus/clusterfuzz-testcase-minimized-file-fuzzer-5662360964956160.heic b/fuzzing/data/corpus/clusterfuzz-testcase-minimized-file-fuzzer-5662360964956160.heic
similarity index 100%
rename from fuzzing/corpus/clusterfuzz-testcase-minimized-file-fuzzer-5662360964956160.heic
rename to fuzzing/data/corpus/clusterfuzz-testcase-minimized-file-fuzzer-5662360964956160.heic
diff --git a/fuzzing/data/corpus/clusterfuzz-testcase-minimized-file-fuzzer-5671864958976000.heic b/fuzzing/data/corpus/clusterfuzz-testcase-minimized-file-fuzzer-5671864958976000.heic
new file mode 100644
index 0000000000..678997e78b
Binary files /dev/null and b/fuzzing/data/corpus/clusterfuzz-testcase-minimized-file-fuzzer-5671864958976000.heic differ
diff --git a/fuzzing/corpus/clusterfuzz-testcase-minimized-file-fuzzer-5686319331672064.heic b/fuzzing/data/corpus/clusterfuzz-testcase-minimized-file-fuzzer-5686319331672064.heic
similarity index 100%
rename from fuzzing/corpus/clusterfuzz-testcase-minimized-file-fuzzer-5686319331672064.heic
rename to fuzzing/data/corpus/clusterfuzz-testcase-minimized-file-fuzzer-5686319331672064.heic
diff --git a/fuzzing/corpus/clusterfuzz-testcase-minimized-file-fuzzer-5718632116518912.heic b/fuzzing/data/corpus/clusterfuzz-testcase-minimized-file-fuzzer-5718632116518912.heic
similarity index 100%
rename from fuzzing/corpus/clusterfuzz-testcase-minimized-file-fuzzer-5718632116518912.heic
rename to fuzzing/data/corpus/clusterfuzz-testcase-minimized-file-fuzzer-5718632116518912.heic
diff --git a/fuzzing/corpus/clusterfuzz-testcase-minimized-file-fuzzer-5720856641142784.heic b/fuzzing/data/corpus/clusterfuzz-testcase-minimized-file-fuzzer-5720856641142784.heic
similarity index 100%
rename from fuzzing/corpus/clusterfuzz-testcase-minimized-file-fuzzer-5720856641142784.heic
rename to fuzzing/data/corpus/clusterfuzz-testcase-minimized-file-fuzzer-5720856641142784.heic
diff --git a/fuzzing/corpus/clusterfuzz-testcase-minimized-file-fuzzer-5724458239655936.heic b/fuzzing/data/corpus/clusterfuzz-testcase-minimized-file-fuzzer-5724458239655936.heic
similarity index 100%
rename from fuzzing/corpus/clusterfuzz-testcase-minimized-file-fuzzer-5724458239655936.heic
rename to fuzzing/data/corpus/clusterfuzz-testcase-minimized-file-fuzzer-5724458239655936.heic
diff --git a/fuzzing/corpus/clusterfuzz-testcase-minimized-file-fuzzer-5732616832024576.heic b/fuzzing/data/corpus/clusterfuzz-testcase-minimized-file-fuzzer-5732616832024576.heic
similarity index 100%
rename from fuzzing/corpus/clusterfuzz-testcase-minimized-file-fuzzer-5732616832024576.heic
rename to fuzzing/data/corpus/clusterfuzz-testcase-minimized-file-fuzzer-5732616832024576.heic
diff --git a/fuzzing/data/corpus/clusterfuzz-testcase-minimized-file-fuzzer-5752063708495872.heic b/fuzzing/data/corpus/clusterfuzz-testcase-minimized-file-fuzzer-5752063708495872.heic
new file mode 100644
index 0000000000..0c6b1985b6
Binary files /dev/null and b/fuzzing/data/corpus/clusterfuzz-testcase-minimized-file-fuzzer-5752063708495872.heic differ
diff --git a/fuzzing/corpus/clusterfuzz-testcase-minimized-file-fuzzer-5757633845264384.heic b/fuzzing/data/corpus/clusterfuzz-testcase-minimized-file-fuzzer-5757633845264384.heic
similarity index 100%
rename from fuzzing/corpus/clusterfuzz-testcase-minimized-file-fuzzer-5757633845264384.heic
rename to fuzzing/data/corpus/clusterfuzz-testcase-minimized-file-fuzzer-5757633845264384.heic
diff --git a/fuzzing/corpus/clusterfuzz-testcase-minimized-file-fuzzer-6045213633282048.heic b/fuzzing/data/corpus/clusterfuzz-testcase-minimized-file-fuzzer-6045213633282048.heic
similarity index 100%
rename from fuzzing/corpus/clusterfuzz-testcase-minimized-file-fuzzer-6045213633282048.heic
rename to fuzzing/data/corpus/clusterfuzz-testcase-minimized-file-fuzzer-6045213633282048.heic
diff --git a/fuzzing/corpus/colors-no-alpha-thumbnail.heic b/fuzzing/data/corpus/colors-no-alpha-thumbnail.heic
similarity index 100%
rename from fuzzing/corpus/colors-no-alpha-thumbnail.heic
rename to fuzzing/data/corpus/colors-no-alpha-thumbnail.heic
diff --git a/fuzzing/corpus/colors-no-alpha.heic b/fuzzing/data/corpus/colors-no-alpha.heic
similarity index 100%
rename from fuzzing/corpus/colors-no-alpha.heic
rename to fuzzing/data/corpus/colors-no-alpha.heic
diff --git a/fuzzing/corpus/colors-with-alpha-thumbnail.heic b/fuzzing/data/corpus/colors-with-alpha-thumbnail.heic
similarity index 100%
rename from fuzzing/corpus/colors-with-alpha-thumbnail.heic
rename to fuzzing/data/corpus/colors-with-alpha-thumbnail.heic
diff --git a/fuzzing/corpus/colors-with-alpha.heic b/fuzzing/data/corpus/colors-with-alpha.heic
similarity index 100%
rename from fuzzing/corpus/colors-with-alpha.heic
rename to fuzzing/data/corpus/colors-with-alpha.heic
diff --git a/fuzzing/data/corpus/crash-20ca2625096a205937b809a7841e7f019f0b2dc6.heic b/fuzzing/data/corpus/crash-20ca2625096a205937b809a7841e7f019f0b2dc6.heic
new file mode 100644
index 0000000000..d49c028be0
Binary files /dev/null and b/fuzzing/data/corpus/crash-20ca2625096a205937b809a7841e7f019f0b2dc6.heic differ
diff --git a/fuzzing/corpus/github_138.heic b/fuzzing/data/corpus/github_138.heic
similarity index 100%
rename from fuzzing/corpus/github_138.heic
rename to fuzzing/data/corpus/github_138.heic
diff --git a/fuzzing/corpus/github_15.heic b/fuzzing/data/corpus/github_15.heic
similarity index 100%
rename from fuzzing/corpus/github_15.heic
rename to fuzzing/data/corpus/github_15.heic
diff --git a/fuzzing/corpus/github_20.heic b/fuzzing/data/corpus/github_20.heic
similarity index 100%
rename from fuzzing/corpus/github_20.heic
rename to fuzzing/data/corpus/github_20.heic
diff --git a/fuzzing/corpus/github_367_1.heic b/fuzzing/data/corpus/github_367_1.heic
similarity index 100%
rename from fuzzing/corpus/github_367_1.heic
rename to fuzzing/data/corpus/github_367_1.heic
diff --git a/fuzzing/corpus/github_367_2.heic b/fuzzing/data/corpus/github_367_2.heic
similarity index 100%
rename from fuzzing/corpus/github_367_2.heic
rename to fuzzing/data/corpus/github_367_2.heic
diff --git a/fuzzing/corpus/github_44.heic b/fuzzing/data/corpus/github_44.heic
similarity index 100%
rename from fuzzing/corpus/github_44.heic
rename to fuzzing/data/corpus/github_44.heic
diff --git a/fuzzing/corpus/github_45.heic b/fuzzing/data/corpus/github_45.heic
similarity index 100%
rename from fuzzing/corpus/github_45.heic
rename to fuzzing/data/corpus/github_45.heic
diff --git a/fuzzing/corpus/github_46_1.heic b/fuzzing/data/corpus/github_46_1.heic
similarity index 100%
rename from fuzzing/corpus/github_46_1.heic
rename to fuzzing/data/corpus/github_46_1.heic
diff --git a/fuzzing/corpus/github_46_2.heic b/fuzzing/data/corpus/github_46_2.heic
similarity index 100%
rename from fuzzing/corpus/github_46_2.heic
rename to fuzzing/data/corpus/github_46_2.heic
diff --git a/fuzzing/corpus/github_47.heic b/fuzzing/data/corpus/github_47.heic
similarity index 100%
rename from fuzzing/corpus/github_47.heic
rename to fuzzing/data/corpus/github_47.heic
diff --git a/fuzzing/corpus/github_48.heic b/fuzzing/data/corpus/github_48.heic
similarity index 100%
rename from fuzzing/corpus/github_48.heic
rename to fuzzing/data/corpus/github_48.heic
diff --git a/fuzzing/corpus/github_49.heic b/fuzzing/data/corpus/github_49.heic
similarity index 100%
rename from fuzzing/corpus/github_49.heic
rename to fuzzing/data/corpus/github_49.heic
diff --git a/fuzzing/corpus/github_50.heic b/fuzzing/data/corpus/github_50.heic
similarity index 100%
rename from fuzzing/corpus/github_50.heic
rename to fuzzing/data/corpus/github_50.heic
diff --git a/fuzzing/corpus/hbo_heif_context.h_126_1.heic b/fuzzing/data/corpus/hbo_heif_context.h_126_1.heic
similarity index 100%
rename from fuzzing/corpus/hbo_heif_context.h_126_1.heic
rename to fuzzing/data/corpus/hbo_heif_context.h_126_1.heic
diff --git a/fuzzing/data/corpus/j2k-siz-segment-undersized.heic b/fuzzing/data/corpus/j2k-siz-segment-undersized.heic
new file mode 100644
index 0000000000..46a5702d46
Binary files /dev/null and b/fuzzing/data/corpus/j2k-siz-segment-undersized.heic differ
diff --git a/fuzzing/data/corpus/region-mask-missing-refs.heic b/fuzzing/data/corpus/region-mask-missing-refs.heic
new file mode 100644
index 0000000000..2d1ae588fd
Binary files /dev/null and b/fuzzing/data/corpus/region-mask-missing-refs.heic differ
diff --git a/fuzzing/data/corpus/rgb_generic_compressed_brotli.heic b/fuzzing/data/corpus/rgb_generic_compressed_brotli.heic
new file mode 100644
index 0000000000..8771ddc811
Binary files /dev/null and b/fuzzing/data/corpus/rgb_generic_compressed_brotli.heic differ
diff --git a/fuzzing/data/corpus/rgb_generic_compressed_defl.heic b/fuzzing/data/corpus/rgb_generic_compressed_defl.heic
new file mode 100644
index 0000000000..acb484a43c
Binary files /dev/null and b/fuzzing/data/corpus/rgb_generic_compressed_defl.heic differ
diff --git a/fuzzing/data/corpus/rgb_generic_compressed_tile_deflate.heic b/fuzzing/data/corpus/rgb_generic_compressed_tile_deflate.heic
new file mode 100644
index 0000000000..86c2d3e5e6
Binary files /dev/null and b/fuzzing/data/corpus/rgb_generic_compressed_tile_deflate.heic differ
diff --git a/fuzzing/data/corpus/rgb_generic_compressed_zlib.heic b/fuzzing/data/corpus/rgb_generic_compressed_zlib.heic
new file mode 100644
index 0000000000..98455c992d
Binary files /dev/null and b/fuzzing/data/corpus/rgb_generic_compressed_zlib.heic differ
diff --git a/fuzzing/data/corpus/rgb_generic_compressed_zlib_rows.heic b/fuzzing/data/corpus/rgb_generic_compressed_zlib_rows.heic
new file mode 100644
index 0000000000..c0507f6cd9
Binary files /dev/null and b/fuzzing/data/corpus/rgb_generic_compressed_zlib_rows.heic differ
diff --git a/fuzzing/data/corpus/rgb_generic_compressed_zlib_tiled.heic b/fuzzing/data/corpus/rgb_generic_compressed_zlib_tiled.heic
new file mode 100644
index 0000000000..4b905aa465
Binary files /dev/null and b/fuzzing/data/corpus/rgb_generic_compressed_zlib_tiled.heic differ
diff --git a/fuzzing/corpus/uaf_heif_context.h_117_1.heic b/fuzzing/data/corpus/uaf_heif_context.h_117_1.heic
similarity index 100%
rename from fuzzing/corpus/uaf_heif_context.h_117_1.heic
rename to fuzzing/data/corpus/uaf_heif_context.h_117_1.heic
diff --git a/fuzzing/data/corpus/uncompressed_comp_ABGR.heic b/fuzzing/data/corpus/uncompressed_comp_ABGR.heic
new file mode 100644
index 0000000000..d0a01266eb
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_comp_ABGR.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_comp_ABGR_tiled.heic b/fuzzing/data/corpus/uncompressed_comp_ABGR_tiled.heic
new file mode 100644
index 0000000000..5e9ed55bcb
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_comp_ABGR_tiled.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_comp_B16R16G16.heic b/fuzzing/data/corpus/uncompressed_comp_B16R16G16.heic
new file mode 100644
index 0000000000..730106cc10
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_comp_B16R16G16.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_comp_B16R16G16_tiled.heic b/fuzzing/data/corpus/uncompressed_comp_B16R16G16_tiled.heic
new file mode 100644
index 0000000000..34c55deb40
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_comp_B16R16G16_tiled.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_comp_M.heic b/fuzzing/data/corpus/uncompressed_comp_M.heic
new file mode 100644
index 0000000000..e6d0c5424e
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_comp_M.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_comp_M_tiled.heic b/fuzzing/data/corpus/uncompressed_comp_M_tiled.heic
new file mode 100644
index 0000000000..92db9bf779
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_comp_M_tiled.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_comp_R5G6B5_tiled.heic b/fuzzing/data/corpus/uncompressed_comp_R5G6B5_tiled.heic
new file mode 100644
index 0000000000..07a67a2c5e
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_comp_R5G6B5_tiled.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_comp_R7+1G7+1B7+1_tiled.heic b/fuzzing/data/corpus/uncompressed_comp_R7+1G7+1B7+1_tiled.heic
new file mode 100644
index 0000000000..d1f4771d72
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_comp_R7+1G7+1B7+1_tiled.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_comp_R7G7+1B7_tiled.heic b/fuzzing/data/corpus/uncompressed_comp_R7G7+1B7_tiled.heic
new file mode 100644
index 0000000000..d3f4e26f95
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_comp_R7G7+1B7_tiled.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_comp_R7G7B7_tiled.heic b/fuzzing/data/corpus/uncompressed_comp_R7G7B7_tiled.heic
new file mode 100644
index 0000000000..34e37e899e
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_comp_R7G7B7_tiled.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_comp_RGB.heic b/fuzzing/data/corpus/uncompressed_comp_RGB.heic
new file mode 100644
index 0000000000..c74129d6fc
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_comp_RGB.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_comp_RGB_tiled.heic b/fuzzing/data/corpus/uncompressed_comp_RGB_tiled.heic
new file mode 100644
index 0000000000..ab30d7f211
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_comp_RGB_tiled.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_comp_RGB_tiled_row_tile_align.heic b/fuzzing/data/corpus/uncompressed_comp_RGB_tiled_row_tile_align.heic
new file mode 100644
index 0000000000..602cc850ff
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_comp_RGB_tiled_row_tile_align.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_comp_RGxB.heic b/fuzzing/data/corpus/uncompressed_comp_RGxB.heic
new file mode 100644
index 0000000000..a6a40778cd
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_comp_RGxB.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_comp_RGxB_tiled.heic b/fuzzing/data/corpus/uncompressed_comp_RGxB_tiled.heic
new file mode 100644
index 0000000000..3899c91c2f
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_comp_RGxB_tiled.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_comp_VUY_420.heic b/fuzzing/data/corpus/uncompressed_comp_VUY_420.heic
new file mode 100644
index 0000000000..143b1f3155
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_comp_VUY_420.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_comp_VUY_422.heic b/fuzzing/data/corpus/uncompressed_comp_VUY_422.heic
new file mode 100644
index 0000000000..53de4201ea
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_comp_VUY_422.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_comp_Y16U16V16_420.heic b/fuzzing/data/corpus/uncompressed_comp_Y16U16V16_420.heic
new file mode 100644
index 0000000000..412ab1d039
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_comp_Y16U16V16_420.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_comp_Y16U16V16_422.heic b/fuzzing/data/corpus/uncompressed_comp_Y16U16V16_422.heic
new file mode 100644
index 0000000000..16d71dacb4
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_comp_Y16U16V16_422.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_comp_YUV_420.heic b/fuzzing/data/corpus/uncompressed_comp_YUV_420.heic
new file mode 100644
index 0000000000..0836a7ea6a
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_comp_YUV_420.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_comp_YUV_422.heic b/fuzzing/data/corpus/uncompressed_comp_YUV_422.heic
new file mode 100644
index 0000000000..bf4d870095
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_comp_YUV_422.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_comp_YUV_tiled.heic b/fuzzing/data/corpus/uncompressed_comp_YUV_tiled.heic
new file mode 100644
index 0000000000..54c0d94ce2
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_comp_YUV_tiled.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_comp_YVU_420.heic b/fuzzing/data/corpus/uncompressed_comp_YVU_420.heic
new file mode 100644
index 0000000000..38afbeaab5
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_comp_YVU_420.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_comp_YVU_422.heic b/fuzzing/data/corpus/uncompressed_comp_YVU_422.heic
new file mode 100644
index 0000000000..7e3896efc7
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_comp_YVU_422.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_mix_VUY_420.heic b/fuzzing/data/corpus/uncompressed_mix_VUY_420.heic
new file mode 100644
index 0000000000..d13e101dac
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_mix_VUY_420.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_mix_VUY_422.heic b/fuzzing/data/corpus/uncompressed_mix_VUY_422.heic
new file mode 100644
index 0000000000..54820e7ca8
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_mix_VUY_422.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_mix_Y16U16V16_420.heic b/fuzzing/data/corpus/uncompressed_mix_Y16U16V16_420.heic
new file mode 100644
index 0000000000..9b24e1da12
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_mix_Y16U16V16_420.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_mix_Y16U16V16_422.heic b/fuzzing/data/corpus/uncompressed_mix_Y16U16V16_422.heic
new file mode 100644
index 0000000000..d58817fc01
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_mix_Y16U16V16_422.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_mix_YUV_420.heic b/fuzzing/data/corpus/uncompressed_mix_YUV_420.heic
new file mode 100644
index 0000000000..98c9425e88
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_mix_YUV_420.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_mix_YUV_422.heic b/fuzzing/data/corpus/uncompressed_mix_YUV_422.heic
new file mode 100644
index 0000000000..1f5688c313
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_mix_YUV_422.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_mix_YVU_420.heic b/fuzzing/data/corpus/uncompressed_mix_YVU_420.heic
new file mode 100644
index 0000000000..15770e2953
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_mix_YVU_420.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_mix_YVU_422.heic b/fuzzing/data/corpus/uncompressed_mix_YVU_422.heic
new file mode 100644
index 0000000000..4a82cbc633
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_mix_YVU_422.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_pix_ABGR.heic b/fuzzing/data/corpus/uncompressed_pix_ABGR.heic
new file mode 100644
index 0000000000..31bc45bbf6
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_pix_ABGR.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_pix_ABGR_tiled.heic b/fuzzing/data/corpus/uncompressed_pix_ABGR_tiled.heic
new file mode 100644
index 0000000000..031b908105
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_pix_ABGR_tiled.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_pix_B16R16G16.heic b/fuzzing/data/corpus/uncompressed_pix_B16R16G16.heic
new file mode 100644
index 0000000000..3b07cc4d78
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_pix_B16R16G16.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_pix_B16R16G16_tiled.heic b/fuzzing/data/corpus/uncompressed_pix_B16R16G16_tiled.heic
new file mode 100644
index 0000000000..39d1695c1e
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_pix_B16R16G16_tiled.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_pix_M.heic b/fuzzing/data/corpus/uncompressed_pix_M.heic
new file mode 100644
index 0000000000..2b4c44531f
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_pix_M.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_pix_M_tiled.heic b/fuzzing/data/corpus/uncompressed_pix_M_tiled.heic
new file mode 100644
index 0000000000..bae5b75c0b
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_pix_M_tiled.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_pix_R5G6B5_tiled.heic b/fuzzing/data/corpus/uncompressed_pix_R5G6B5_tiled.heic
new file mode 100644
index 0000000000..bb11120608
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_pix_R5G6B5_tiled.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_pix_R7+1G7+1B7+1_tiled.heic b/fuzzing/data/corpus/uncompressed_pix_R7+1G7+1B7+1_tiled.heic
new file mode 100644
index 0000000000..c77af9b14f
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_pix_R7+1G7+1B7+1_tiled.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_pix_R7G7+1B7_tiled.heic b/fuzzing/data/corpus/uncompressed_pix_R7G7+1B7_tiled.heic
new file mode 100644
index 0000000000..a2390e4386
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_pix_R7G7+1B7_tiled.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_pix_R7G7B7_tiled.heic b/fuzzing/data/corpus/uncompressed_pix_R7G7B7_tiled.heic
new file mode 100644
index 0000000000..8bfbe08b6e
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_pix_R7G7B7_tiled.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_pix_R8G8B8A8_bsz0_psz10_tiled.heic b/fuzzing/data/corpus/uncompressed_pix_R8G8B8A8_bsz0_psz10_tiled.heic
new file mode 100644
index 0000000000..3153cd3c6f
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_pix_R8G8B8A8_bsz0_psz10_tiled.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_pix_R8G8B8A8_bsz0_psz5_tiled.heic b/fuzzing/data/corpus/uncompressed_pix_R8G8B8A8_bsz0_psz5_tiled.heic
new file mode 100644
index 0000000000..5269301d78
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_pix_R8G8B8A8_bsz0_psz5_tiled.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_pix_R8G8B8_bsz0_psz10_tiled.heic b/fuzzing/data/corpus/uncompressed_pix_R8G8B8_bsz0_psz10_tiled.heic
new file mode 100644
index 0000000000..862c2b409b
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_pix_R8G8B8_bsz0_psz10_tiled.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_pix_R8G8B8_bsz0_psz5_tiled.heic b/fuzzing/data/corpus/uncompressed_pix_R8G8B8_bsz0_psz5_tiled.heic
new file mode 100644
index 0000000000..17aebda4bf
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_pix_R8G8B8_bsz0_psz5_tiled.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_pix_RGB.heic b/fuzzing/data/corpus/uncompressed_pix_RGB.heic
new file mode 100644
index 0000000000..dac85fca2e
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_pix_RGB.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_pix_RGB_tiled.heic b/fuzzing/data/corpus/uncompressed_pix_RGB_tiled.heic
new file mode 100644
index 0000000000..8eda57d504
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_pix_RGB_tiled.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_pix_RGB_tiled_row_tile_align.heic b/fuzzing/data/corpus/uncompressed_pix_RGB_tiled_row_tile_align.heic
new file mode 100644
index 0000000000..c2829edff8
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_pix_RGB_tiled_row_tile_align.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_pix_RGxB.heic b/fuzzing/data/corpus/uncompressed_pix_RGxB.heic
new file mode 100644
index 0000000000..ae8b8d814a
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_pix_RGxB.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_pix_RGxB_tiled.heic b/fuzzing/data/corpus/uncompressed_pix_RGxB_tiled.heic
new file mode 100644
index 0000000000..d964a29154
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_pix_RGxB_tiled.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_pix_YUV_tiled.heic b/fuzzing/data/corpus/uncompressed_pix_YUV_tiled.heic
new file mode 100644
index 0000000000..b84f32b091
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_pix_YUV_tiled.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_row_ABGR.heic b/fuzzing/data/corpus/uncompressed_row_ABGR.heic
new file mode 100644
index 0000000000..5a60fd6ec9
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_row_ABGR.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_row_ABGR_tiled.heic b/fuzzing/data/corpus/uncompressed_row_ABGR_tiled.heic
new file mode 100644
index 0000000000..896d341b98
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_row_ABGR_tiled.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_row_B16R16G16.heic b/fuzzing/data/corpus/uncompressed_row_B16R16G16.heic
new file mode 100644
index 0000000000..754d6b8af0
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_row_B16R16G16.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_row_B16R16G16_tiled.heic b/fuzzing/data/corpus/uncompressed_row_B16R16G16_tiled.heic
new file mode 100644
index 0000000000..8f8db75e5a
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_row_B16R16G16_tiled.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_row_M.heic b/fuzzing/data/corpus/uncompressed_row_M.heic
new file mode 100644
index 0000000000..130e7cee83
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_row_M.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_row_M_tiled.heic b/fuzzing/data/corpus/uncompressed_row_M_tiled.heic
new file mode 100644
index 0000000000..05aa7f71ac
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_row_M_tiled.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_row_R5G6B5_tiled.heic b/fuzzing/data/corpus/uncompressed_row_R5G6B5_tiled.heic
new file mode 100644
index 0000000000..d94e68675d
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_row_R5G6B5_tiled.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_row_R7+1G7+1B7+1_tiled.heic b/fuzzing/data/corpus/uncompressed_row_R7+1G7+1B7+1_tiled.heic
new file mode 100644
index 0000000000..7b299c0a56
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_row_R7+1G7+1B7+1_tiled.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_row_R7G7+1B7_tiled.heic b/fuzzing/data/corpus/uncompressed_row_R7G7+1B7_tiled.heic
new file mode 100644
index 0000000000..081b9b1c8c
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_row_R7G7+1B7_tiled.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_row_R7G7B7_tiled.heic b/fuzzing/data/corpus/uncompressed_row_R7G7B7_tiled.heic
new file mode 100644
index 0000000000..943b60655b
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_row_R7G7B7_tiled.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_row_RGB.heic b/fuzzing/data/corpus/uncompressed_row_RGB.heic
new file mode 100644
index 0000000000..30c440000e
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_row_RGB.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_row_RGB_tiled.heic b/fuzzing/data/corpus/uncompressed_row_RGB_tiled.heic
new file mode 100644
index 0000000000..a5d6ebcc5a
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_row_RGB_tiled.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_row_RGB_tiled_row_tile_align.heic b/fuzzing/data/corpus/uncompressed_row_RGB_tiled_row_tile_align.heic
new file mode 100644
index 0000000000..a9969bec4b
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_row_RGB_tiled_row_tile_align.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_row_RGxB.heic b/fuzzing/data/corpus/uncompressed_row_RGxB.heic
new file mode 100644
index 0000000000..de274d5c8b
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_row_RGxB.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_row_RGxB_tiled.heic b/fuzzing/data/corpus/uncompressed_row_RGxB_tiled.heic
new file mode 100644
index 0000000000..e438fc2268
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_row_RGxB_tiled.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_row_YUV_tiled.heic b/fuzzing/data/corpus/uncompressed_row_YUV_tiled.heic
new file mode 100644
index 0000000000..7238f7fadb
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_row_YUV_tiled.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_tile_ABGR_tiled.heic b/fuzzing/data/corpus/uncompressed_tile_ABGR_tiled.heic
new file mode 100644
index 0000000000..157944f4bb
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_tile_ABGR_tiled.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_tile_B16R16G16_tiled.heic b/fuzzing/data/corpus/uncompressed_tile_B16R16G16_tiled.heic
new file mode 100644
index 0000000000..3937184d17
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_tile_B16R16G16_tiled.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_tile_M_tiled.heic b/fuzzing/data/corpus/uncompressed_tile_M_tiled.heic
new file mode 100644
index 0000000000..07cce7eecd
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_tile_M_tiled.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_tile_R5G6B5_tiled.heic b/fuzzing/data/corpus/uncompressed_tile_R5G6B5_tiled.heic
new file mode 100644
index 0000000000..8c67f301c7
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_tile_R5G6B5_tiled.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_tile_R7+1G7+1B7+1_tiled.heic b/fuzzing/data/corpus/uncompressed_tile_R7+1G7+1B7+1_tiled.heic
new file mode 100644
index 0000000000..0c40460788
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_tile_R7+1G7+1B7+1_tiled.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_tile_R7G7+1B7_tiled.heic b/fuzzing/data/corpus/uncompressed_tile_R7G7+1B7_tiled.heic
new file mode 100644
index 0000000000..3f001eaa12
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_tile_R7G7+1B7_tiled.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_tile_R7G7B7_tiled.heic b/fuzzing/data/corpus/uncompressed_tile_R7G7B7_tiled.heic
new file mode 100644
index 0000000000..a0d51e6172
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_tile_R7G7B7_tiled.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_tile_RGB_tiled.heic b/fuzzing/data/corpus/uncompressed_tile_RGB_tiled.heic
new file mode 100644
index 0000000000..d4adc501da
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_tile_RGB_tiled.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_tile_RGB_tiled_row_tile_align.heic b/fuzzing/data/corpus/uncompressed_tile_RGB_tiled_row_tile_align.heic
new file mode 100644
index 0000000000..dc8f38484b
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_tile_RGB_tiled_row_tile_align.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_tile_RGxB_tiled.heic b/fuzzing/data/corpus/uncompressed_tile_RGxB_tiled.heic
new file mode 100644
index 0000000000..68a29d1877
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_tile_RGxB_tiled.heic differ
diff --git a/fuzzing/data/corpus/uncompressed_tile_YUV_tiled.heic b/fuzzing/data/corpus/uncompressed_tile_YUV_tiled.heic
new file mode 100644
index 0000000000..3b965e6c32
Binary files /dev/null and b/fuzzing/data/corpus/uncompressed_tile_YUV_tiled.heic differ
diff --git a/fuzzing/dictionary.txt b/fuzzing/data/dictionary.txt
similarity index 100%
rename from fuzzing/dictionary.txt
rename to fuzzing/data/dictionary.txt
diff --git a/libheif/encoder_fuzzer.cc b/fuzzing/encoder_fuzzer.cc
similarity index 93%
rename from libheif/encoder_fuzzer.cc
rename to fuzzing/encoder_fuzzer.cc
index 059ece77c7..fc9fa46b51 100644
--- a/libheif/encoder_fuzzer.cc
+++ b/fuzzing/encoder_fuzzer.cc
@@ -24,7 +24,7 @@
 
 #include <memory>
 
-#include "heif.h"
+#include "libheif/heif.h"
 
 static void generate_plane(int width, int height, uint8_t* output, int stride)
 {
@@ -151,10 +151,9 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 
   static const size_t kMaxEncoders = 5;
   const heif_encoder_descriptor* encoder_descriptors[kMaxEncoders];
-  int count = heif_context_get_encoder_descriptors(context.get(),
-                                                   use_avif ? heif_compression_AV1 : heif_compression_HEVC,
-                                                   nullptr,
-                                                   encoder_descriptors, kMaxEncoders);
+  int count = heif_get_encoder_descriptors(use_avif ? heif_compression_AV1 : heif_compression_HEVC,
+                                           nullptr,
+                                           encoder_descriptors, kMaxEncoders);
   assert(count >= 0);
   if (count == 0) {
     return 0;
@@ -185,12 +184,11 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
   err = heif_context_encode_image(context.get(), image, encoder, nullptr, &img);
   heif_image_release(image);
   heif_encoder_release(encoder);
+  heif_image_handle_release(img);
   if (err.code != heif_error_Ok) {
     return 0;
   }
 
-  heif_image_handle_release(img);
-
   MemoryWriter writer;
   struct heif_writer w;
   w.writer_api_version = 1;
diff --git a/libheif/file_fuzzer.cc b/fuzzing/file_fuzzer.cc
similarity index 82%
rename from libheif/file_fuzzer.cc
rename to fuzzing/file_fuzzer.cc
index 376a3060c0..13fefb60ae 100644
--- a/libheif/file_fuzzer.cc
+++ b/fuzzing/file_fuzzer.cc
@@ -22,7 +22,7 @@
 #include <limits.h>
 #include <stdlib.h>
 
-#include "heif.h"
+#include "libheif/heif.h"
 
 static const enum heif_colorspace kFuzzColorSpace = heif_colorspace_YCbCr;
 static const enum heif_chroma kFuzzChroma = heif_chroma_420;
@@ -30,12 +30,14 @@ static const enum heif_chroma kFuzzChroma = heif_chroma_420;
 static void TestDecodeImage(struct heif_context* ctx,
                             const struct heif_image_handle* handle, size_t filesize)
 {
-  struct heif_image* image;
+  struct heif_image* image = nullptr;
   struct heif_error err;
 
-  heif_image_handle_is_primary_image(handle);
+  bool primary = heif_image_handle_is_primary_image(handle);
+  (void) primary;
   int width = heif_image_handle_get_width(handle);
   int height = heif_image_handle_get_height(handle);
+  (void)width; (void)height;
   assert(width >= 0);
   assert(height >= 0);
   int metadata_count = heif_image_handle_get_number_of_metadata_blocks(handle, nullptr);
@@ -46,11 +48,16 @@ static void TestDecodeImage(struct heif_context* ctx,
   int metadata_ids_count = heif_image_handle_get_list_of_metadata_block_IDs(handle, nullptr, metadata_ids,
                                                                             metadata_count);
   assert(metadata_count == metadata_ids_count);
+  (void)metadata_ids_count;
   for (int i = 0; i < metadata_count; i++) {
     heif_image_handle_get_metadata_type(handle, metadata_ids[i]);
     heif_image_handle_get_metadata_content_type(handle, metadata_ids[i]);
     size_t metadata_size = heif_image_handle_get_metadata_size(handle, metadata_ids[i]);
-    assert(metadata_size < filesize);
+
+    // This assertion is invalid. Metadata can in fact be larger than the file if there are several
+    // overlapping iloc extents. Does not make much sense, but it is technically valid.
+    //assert(metadata_size < filesize);
+
     uint8_t* metadata_data = static_cast<uint8_t*>(malloc(metadata_size));
     assert(metadata_data);
     heif_image_handle_get_metadata(handle, metadata_ids[i], metadata_data);
@@ -60,6 +67,7 @@ static void TestDecodeImage(struct heif_context* ctx,
 
   err = heif_decode_image(handle, &image, kFuzzColorSpace, kFuzzChroma, nullptr);
   if (err.code != heif_error_Ok) {
+    heif_image_release(image);
     return;
   }
 
@@ -80,16 +88,26 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
   struct heif_context* ctx;
   struct heif_error err;
-  struct heif_image_handle* primary_handle;
+  struct heif_image_handle* primary_handle = nullptr;
   int images_count;
   heif_item_id* image_IDs = NULL;
+  bool explicit_init = size == 0 || data[size - 1] & 1;
+
+  if (explicit_init) {
+    heif_init(nullptr);
+  }
 
   heif_check_filetype(data, clip_int(size));
   heif_main_brand(data, clip_int(size));
   heif_get_file_mime_type(data, clip_int(size));
 
   ctx = heif_context_alloc();
+  heif_context_get_security_limits(ctx)->max_total_memory = UINT64_C(2) * 1024 * 1024 * 1024;
   assert(ctx);
+
+  auto* limits = heif_context_get_security_limits(ctx);
+  limits->max_memory_block_size = 128 * 1024 * 1024; // 128 MB
+
   err = heif_context_read_from_memory(ctx, data, size, nullptr);
   if (err.code != heif_error_Ok) {
     // Not a valid HEIF file passed (which is most likely while fuzzing).
@@ -101,6 +119,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     assert(heif_image_handle_is_primary_image(primary_handle));
     TestDecodeImage(ctx, primary_handle, size);
     heif_image_handle_release(primary_handle);
+    primary_handle = nullptr;
   }
 
   images_count = heif_context_get_number_of_top_level_images(ctx);
@@ -118,9 +137,10 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
   }
 
   for (int i = 0; i < images_count; ++i) {
-    struct heif_image_handle* image_handle;
+    struct heif_image_handle* image_handle = nullptr;
     err = heif_context_get_image_handle(ctx, image_IDs[i], &image_handle);
     if (err.code != heif_error_Ok) {
+      heif_image_handle_release(image_handle);
       // Ignore, we are only interested in crashes here.
       continue;
     }
@@ -141,7 +161,13 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
   }
 
   quit:
+  heif_image_handle_release(primary_handle);
   heif_context_free(ctx);
   free(image_IDs);
+
+  if (explicit_init) {
+    heif_deinit();
+  }
+
   return 0;
 }
diff --git a/gdk-pixbuf/CMakeLists.txt b/gdk-pixbuf/CMakeLists.txt
index 85ad597085..de67e79624 100644
--- a/gdk-pixbuf/CMakeLists.txt
+++ b/gdk-pixbuf/CMakeLists.txt
@@ -1,20 +1,21 @@
-if(UNIX)
+if(UNIX OR MINGW)
   find_package(PkgConfig)
-  find_package(Threads)
   pkg_check_modules(GDKPIXBUF2 gdk-pixbuf-2.0)
 
   if(GDKPIXBUF2_FOUND)
-    execute_process(COMMAND ${PKG_CONFIG_EXECUTABLE} gdk-pixbuf-2.0 --variable gdk_pixbuf_moduledir --define-variable=prefix=${CMAKE_INSTALL_PREFIX} OUTPUT_VARIABLE GDKPIXBUF2_MODULE_DIR OUTPUT_STRIP_TRAILING_WHITESPACE)
+    execute_process(
+      COMMAND ${PKG_CONFIG_EXECUTABLE} gdk-pixbuf-2.0 --variable gdk_pixbuf_moduledir
+              --define-variable=prefix=${CMAKE_INSTALL_PREFIX} OUTPUT_VARIABLE GDKPIXBUF2_MODULE_DIR
+      OUTPUT_STRIP_TRAILING_WHITESPACE)
 
     add_library(pixbufloader-heif MODULE pixbufloader-heif.c)
 
-    target_include_directories(pixbufloader-heif
-                               PRIVATE
-                                   ${GDKPIXBUF2_INCLUDE_DIRS}
-                                   ${libheif_BINARY_DIR}
-                                   ${libheif_SOURCE_DIR})
+    target_include_directories(pixbufloader-heif PRIVATE ${GDKPIXBUF2_INCLUDE_DIRS} ${libheif_BINARY_DIR} ${libheif_SOURCE_DIR}/libheif/api)
+
+    target_link_directories(pixbufloader-heif PRIVATE ${GDKPIXBUF2_LIBRARY_DIRS})
+
     target_link_libraries(pixbufloader-heif PUBLIC ${GDKPIXBUF2_LIBRARIES} heif)
 
-    install(TARGETS pixbufloader-heif LIBRARY DESTINATION ${GDKPIXBUF2_MODULE_DIR})
+    install(TARGETS pixbufloader-heif DESTINATION ${GDKPIXBUF2_MODULE_DIR})
   endif()
 endif()
diff --git a/gdk-pixbuf/Makefile.am b/gdk-pixbuf/Makefile.am
deleted file mode 100644
index c89caaa7b8..0000000000
--- a/gdk-pixbuf/Makefile.am
+++ /dev/null
@@ -1,14 +0,0 @@
-AUTOMAKE_OPTIONS = subdir-objects
-
-gdk_pixbuf_module_LTLIBRARIES =
-
-if HAVE_GDKPIXBUF2
-gdk_pixbuf_module_LTLIBRARIES += libpixbufloader-heif.la
-libpixbufloader_heif_la_DEPENDENCIES = ../libheif/libheif.la
-libpixbufloader_heif_la_CFLAGS = -I$(top_srcdir) -I$(top_builddir) $(gdkpixbuf_CFLAGS)
-libpixbufloader_heif_la_LIBADD = ../libheif/libheif.la $(gdkpixbuf_LIBS)
-libpixbufloader_heif_la_LDFLAGS = -avoid-version -module
-libpixbufloader_heif_la_SOURCES = pixbufloader-heif.c
-endif
-
-EXTRA_DIST = CMakeLists.txt
diff --git a/gdk-pixbuf/pixbufloader-heif.c b/gdk-pixbuf/pixbufloader-heif.c
index e547c4f960..9666e798d1 100644
--- a/gdk-pixbuf/pixbufloader-heif.c
+++ b/gdk-pixbuf/pixbufloader-heif.c
@@ -67,7 +67,7 @@ static gboolean stop_load(gpointer context, GError** error)
 {
   HeifPixbufCtx* hpc;
   struct heif_error err;
-  struct heif_context* hc;
+  struct heif_context* hc = NULL;
   struct heif_image_handle* hdl = NULL;
   struct heif_image* img = NULL;
   int width, height, stride;
@@ -79,6 +79,12 @@ static gboolean stop_load(gpointer context, GError** error)
   result = FALSE;
   hpc = (HeifPixbufCtx*) context;
 
+  err = heif_init(NULL);
+  if (err.code != heif_error_Ok) {
+    g_warning("%s", err.message);
+    goto cleanup;
+  }
+
   hc = heif_context_alloc();
   if (!hc) {
     g_warning("cannot allocate heif_context");
@@ -130,6 +136,23 @@ static gboolean stop_load(gpointer context, GError** error)
   pixbuf = gdk_pixbuf_new_from_data(data, GDK_COLORSPACE_RGB, has_alpha, 8, width, height, stride, release_heif_image,
                                     img);
 
+  size_t profile_size = heif_image_handle_get_raw_color_profile_size(hdl);
+  if(profile_size) {
+    guchar *profile_data = (guchar *)g_malloc0(profile_size);
+
+    err = heif_image_handle_get_raw_color_profile(hdl, profile_data);
+    if (err.code == heif_error_Ok) {
+      gchar *profile_base64 = g_base64_encode(profile_data, profile_size);
+      gdk_pixbuf_set_option(pixbuf, "icc-profile", profile_base64);
+      g_free(profile_base64);
+    }
+    else {
+      // Having no ICC profile is perfectly fine. Do not show any warning because of that.
+    }
+
+    g_free(profile_data);
+  }
+  
   if (hpc->prepare_func) {
     (*hpc->prepare_func)(pixbuf, NULL, hpc->user_data);
   }
@@ -162,6 +185,8 @@ static gboolean stop_load(gpointer context, GError** error)
   g_byte_array_free(hpc->data, TRUE);
   g_free(hpc);
 
+  heif_deinit();
+
   return result;
 }
 
diff --git a/gnome/CMakeLists.txt b/gnome/CMakeLists.txt
index e8b8bf6421..c1768cf2ee 100644
--- a/gnome/CMakeLists.txt
+++ b/gnome/CMakeLists.txt
@@ -1,2 +1,3 @@
-install(FILES heif.thumbnailer DESTINATION ${CMAKE_INSTALL_DATADIR}/thumbnailers)
-install(FILES avif.xml heif.xml DESTINATION ${CMAKE_INSTALL_DATADIR}/mime/packages)
+if(TARGET heif-thumbnailer)
+  install(FILES heif.thumbnailer DESTINATION ${CMAKE_INSTALL_DATADIR}/thumbnailers)
+endif()
diff --git a/gnome/Makefile.am b/gnome/Makefile.am
deleted file mode 100644
index a9c066e5a0..0000000000
--- a/gnome/Makefile.am
+++ /dev/null
@@ -1,10 +0,0 @@
-thumbnailer_dir = $(datadir)/thumbnailers
-thumbnailer__DATA = heif.thumbnailer
-
-mime_dir = $(datadir)/mime/packages
-mime__DATA = heif.xml avif.xml
-
-EXTRA_DIST = \
-    heif.thumbnailer \
-    heif.xml \
-    avif.xml
diff --git a/gnome/avif.xml b/gnome/avif.xml
deleted file mode 100644
index 5b576fe62d..0000000000
--- a/gnome/avif.xml
+++ /dev/null
@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<mime-info xmlns='http://www.freedesktop.org/standards/shared-mime-info'>
-  <mime-type type="image/avif">
-    <comment>AVIF image</comment>
-    <comment xml:lang="de">AVIF-Bild</comment>
-    <glob pattern="*.avif"/>
-  </mime-type>
-</mime-info>
diff --git a/gnome/heif.xml b/gnome/heif.xml
deleted file mode 100644
index d82ee83344..0000000000
--- a/gnome/heif.xml
+++ /dev/null
@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<mime-info xmlns='http://www.freedesktop.org/standards/shared-mime-info'>
-  <mime-type type="image/heif">
-    <comment>HEIF image</comment>
-    <comment xml:lang="de">HEIF-Bild</comment>
-    <glob pattern="*.heic"/>
-    <glob pattern="*.heif"/>
-    <alias type="image/heic"/>
-  </mime-type>
-</mime-info>
diff --git a/go/Makefile.am b/go/Makefile.am
deleted file mode 100644
index 329261e457..0000000000
--- a/go/Makefile.am
+++ /dev/null
@@ -1,26 +0,0 @@
-EXTRA_DIST = \
-	heif/heif.go \
-	heif/heif_test.go \
-	heif/keepalive_16.go \
-	heif/keepalive_17.go
-
-gopath:
-	ln -sf ${CURDIR} ${CURDIR}/src
-
-if HAVE_GO
-test-go: gopath $(top_builddir)/libheif/libheif.la $(top_builddir)/libheif.pc
-	GOPATH=${CURDIR} PKG_CONFIG_PATH=$(abs_top_builddir):$(abs_top_builddir)/libde265/dist/lib/pkgconfig/ CGO_CFLAGS="-I$(abs_top_builddir)" CGO_LDFLAGS="-L$(abs_top_builddir)/libheif/.libs" LD_LIBRARY_PATH=$(abs_top_builddir)/libheif/.libs $(GO) test -v heif
-
-format-go: gopath
-	GOPATH=${CURDIR} $(GO) fmt heif
-else
-test-go:
-	echo ""go" not present in "${PATH}", skipping tests"
-
-format-go:
-	echo ""go" not present in "${PATH}", skipping formatting"
-endif
-
-test-local: test-go
-
-format-local: format-go
diff --git a/go/heif/heif.go b/go/heif/heif.go
index d2ee918f96..c4c85bf4c2 100644
--- a/go/heif/heif.go
+++ b/go/heif/heif.go
@@ -1,21 +1,28 @@
 /*
  * GO interface to libheif
- * Copyright (c) 2018 struktur AG, Dirk Farin <farin@struktur.de>
  *
- * This file is part of heif, an example application using libheif.
+ * MIT License
  *
- * heif is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
+ * Copyright (c) 2018 Dirk Farin <dirk.farin@gmail.com>
+ * Copyright (c) 2018 Joachim Bauch <bauch@struktur.de>
  *
- * heif is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
  *
- * You should have received a copy of the GNU General Public License
- * along with heif.  If not, see <http://www.gnu.org/licenses/>.
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
  */
 
 package heif
@@ -45,11 +52,17 @@ func GetVersion() string {
 type Compression C.enum_heif_compression_format
 
 const (
-	CompressionUndefined = C.heif_compression_undefined
-	CompressionHEVC      = C.heif_compression_HEVC
-	CompressionAV1       = C.heif_compression_AV1
-	CompressionAVC       = C.heif_compression_AVC
-	CompressionJPEG      = C.heif_compression_JPEG
+	CompressionUndefined    = C.heif_compression_undefined
+	CompressionHEVC         = C.heif_compression_HEVC
+	CompressionAV1          = C.heif_compression_AV1
+	CompressionAVC          = C.heif_compression_AVC
+	CompressionJPEG         = C.heif_compression_JPEG
+	CompressionJPEG2000     = C.heif_compression_JPEG2000
+	CompressionVVC          = C.heif_compression_VVC
+	CompressionEVC          = C.heif_compression_EVC
+	CompressionUncompressed = C.heif_compression_uncompressed
+	CompressionMask         = C.heif_compression_mask
+	CompressionHTJ2K        = C.heif_compression_HTJ2K
 )
 
 type Chroma C.enum_heif_chroma
@@ -71,13 +84,30 @@ const (
 	ChromaInterleaved32Bit = C.heif_chroma_interleaved_32bit
 )
 
+type ChromaDownsamplingAlgorithm C.enum_heif_chroma_downsampling_algorithm
+
+const (
+	ChromaDownsamplingAverage         = C.heif_chroma_downsampling_average
+	ChromaDownsamplingNearestNeighbor = C.heif_chroma_downsampling_nearest_neighbor
+	ChromaDownsamplingSharpYUV        = C.heif_chroma_downsampling_sharp_yuv
+)
+
+type ChromaUpsamplingAlgorithm C.enum_heif_chroma_upsampling_algorithm
+
+const (
+	ChromaUpsamplingNearestNeighbor = C.heif_chroma_upsampling_nearest_neighbor
+	ChromaUpsamplingBilinear        = C.heif_chroma_upsampling_bilinear
+)
+
 type Colorspace C.enum_heif_colorspace
 
 const (
-	ColorspaceUndefined  = C.heif_colorspace_undefined
-	ColorspaceYCbCr      = C.heif_colorspace_YCbCr
-	ColorspaceRGB        = C.heif_colorspace_RGB
-	ColorspaceMonochrome = C.heif_colorspace_monochrome
+	ColorspaceUndefined   = C.heif_colorspace_undefined
+	ColorspaceYCbCr       = C.heif_colorspace_YCbCr
+	ColorspaceRGB         = C.heif_colorspace_RGB
+	ColorspaceMonochrome  = C.heif_colorspace_monochrome
+	ColorspaceFilterArray = C.heif_colorspace_filter_array
+	ColorspaceNonvisual   = C.heif_colorspace_nonvisual
 )
 
 type Channel C.enum_heif_channel
@@ -91,6 +121,10 @@ const (
 	ChannelB           = C.heif_channel_B
 	ChannelAlpha       = C.heif_channel_Alpha
 	ChannelInterleaved = C.heif_channel_interleaved
+	ChannelFilterArray = C.heif_channel_filter_array
+	ChannelDepth       = C.heif_channel_depth
+	ChannelDisparity   = C.heif_channel_disparity
+	ChannelUnknown     = C.heif_channel_unknown
 )
 
 type ProgressStep C.enum_heif_progress_step
@@ -150,8 +184,14 @@ const (
 	// Error during encoding or when writing to the output
 	ErrorEncoding = C.heif_error_Encoding_error
 
+	ErrorEndOfSequence = C.heif_error_End_of_sequence
+
 	// Application has asked for a color profile type that does not exist
 	ErrorColorProfileDoesNotExist = C.heif_error_Color_profile_does_not_exist
+
+	ErrorPluginLoadingError = C.heif_error_Plugin_loading_error
+
+	ErrorCanceled = C.heif_error_Canceled
 )
 
 type ErrorSubcode C.enum_heif_suberror_code
@@ -175,6 +215,8 @@ const (
 
 	SuberrorNoMetaBox = C.heif_suberror_No_meta_box
 
+	SuberrorNoMoovBox = C.heif_suberror_No_moov_box
+
 	SuberrorNoHdlrBox = C.heif_suberror_No_hdlr_box
 
 	SuberrorNoHvcCBox = C.heif_suberror_No_hvcC_box
@@ -212,6 +254,8 @@ const (
 
 	SuberrorNoAV1CBox = C.heif_suberror_No_av1C_box
 
+	SuberrorNoAVCCBox = C.heif_suberror_No_avcC_box
+
 	SuberrorInvalidCleanAperture = C.heif_suberror_Invalid_clean_aperture
 
 	// Invalid specification of overlay image
@@ -220,8 +264,16 @@ const (
 	// Overlay image completely outside of visible canvas area
 	SuberrorOverlayImageOutsideOfCanvas = C.heif_suberror_Overlay_image_outside_of_canvas
 
+	SuberrorPluginIsNotLoaded = C.heif_suberror_Plugin_is_not_loaded
+
+	SuberrorPluginLoadingError = C.heif_suberror_Plugin_loading_error
+
 	SuberrorAuxiliaryImageTypeUnspecified = C.heif_suberror_Auxiliary_image_type_unspecified
 
+	SuberrorCannotReadPluginDirectory = C.heif_suberror_Cannot_read_plugin_directory
+
+	SuberrorNoMatchingDecoderInstalled = C.heif_suberror_No_matching_decoder_installed
+
 	SuberrorNoOrInvalidPrimaryItem = C.heif_suberror_No_or_invalid_primary_item
 
 	SuberrorNoInfeBox = C.heif_suberror_No_infe_box
@@ -234,6 +286,12 @@ const (
 
 	SuberrorInvalidImageSize = C.heif_suberror_Invalid_image_size
 
+	SuberrorCameraIntrinsicMatrixUndefined = C.heif_suberror_Camera_intrinsic_matrix_undefined
+
+	SuberrorCameraExtrinsicMatrixUndefined = C.heif_suberror_Camera_extrinsic_matrix_undefined
+
+	SuberrorDecompressionInvalidData = C.heif_suberror_Decompression_invalid_data
+
 	// --- Memory_allocation_error ---
 
 	// A security limit preventing unreasonable memory allocations was exceeded by the input file.
@@ -241,6 +299,8 @@ const (
 	// security limits further.
 	SuberrorSecurityLimitExceeded = C.heif_suberror_Security_limit_exceeded
 
+	CompressionInitialisationError = C.heif_suberror_Compression_initialisation_error
+
 	// --- Usage_error ---
 
 	// An item ID was used that is not present in the file.
@@ -264,10 +324,32 @@ const (
 	// The value for the given parameter is not in the valid range.
 	SuberrorInvalidParameterValue = C.heif_suberror_Invalid_parameter_value
 
+	SuberrorInvalidProperty = C.heif_suberror_Invalid_property
+
+	SuberrorItemReferenceCycle = C.heif_suberror_Item_reference_cycle
+
 	SuberrorInvalidPixiBox = C.heif_suberror_Invalid_pixi_box
 
+	SuberrorInvalidRegionData = C.heif_suberror_Invalid_region_data
+
+	SuberrorNoIspeProperty = C.heif_suberror_No_ispe_property
+
 	SuberrorWrongTileImagePixelDepth = C.heif_suberror_Wrong_tile_image_pixel_depth
 
+	SuberrorUnknownNCLXColorPrimaries = C.heif_suberror_Unknown_NCLX_color_primaries
+
+	SuberrorUnknownNCLXTransferCharacteristics = C.heif_suberror_Unknown_NCLX_transfer_characteristics
+
+	SuberrorUnknownNCLXMatrixCoefficients = C.heif_suberror_Unknown_NCLX_matrix_coefficients
+
+	SuberrorInvalidJ2KCodestream = C.heif_suberror_Invalid_J2K_codestream
+
+	SuberrorNoVcCBox = C.heif_suberror_No_vvcC_box
+
+	SuberrorNoIcbrBox = C.heif_suberror_No_icbr_box
+
+	SuberrorInvalidMiniBox = C.heif_suberror_Invalid_mini_box
+
 	// --- Unsupported_feature ---
 
 	// Image was coded with an unsupported compression method.
@@ -278,11 +360,19 @@ const (
 
 	SuberrorUnsupportedDataVersion = C.heif_suberror_Unsupported_data_version
 
+	SuberrorUnsupportedGenericCompressionMethod = C.heif_suberror_Unsupported_generic_compression_method
+
+	SuberrorUnsupportedEssentialProperty = C.heif_suberror_Unsupported_essential_property
+
 	// The conversion of the source image to the requested chroma / colorspace is not supported.
 	SuberrorUnsupportedColorConversion = C.heif_suberror_Unsupported_color_conversion
 
 	SuberrorUnsupportedItemConstructionMethod = C.heif_suberror_Unsupported_item_construction_method
 
+	SuberrorUnsupportedHeaderCompressionMethod = C.heif_suberror_Unsupported_header_compression_method
+
+	SubErrorUnsupportedTrackType = C.heif_suberror_Unsupported_track_type
+
 	// --- Encoder_plugin_error ---
 
 	SuberrorUnsupportedBitDepth = C.heif_suberror_Unsupported_bit_depth
@@ -290,6 +380,14 @@ const (
 	// --- Encoding_error ---
 
 	SuberrorCannotWriteOutputData = C.heif_suberror_Cannot_write_output_data
+
+	SuberrorEncoderInitialization = C.heif_suberror_Encoder_initialization
+
+	SuberrorEncoderEncoding = C.heif_suberror_Encoder_encoding
+
+	SuberrorEncoderCleanup = C.heif_suberror_Encoder_cleanup
+
+	SuberrorTooManyRegions = C.heif_suberror_Too_many_regions
 )
 
 type HeifError struct {
@@ -350,14 +448,14 @@ func (c *Context) ReadFromFile(filename string) error {
 	defer C.free(unsafe.Pointer(c_filename))
 
 	err := C.heif_context_read_from_file(c.context, c_filename, nil)
-	keepAlive(c)
+	runtime.KeepAlive(c)
 	return convertHeifError(err)
 }
 
 func (c *Context) ReadFromMemory(data []byte) error {
 	// TODO: Use reader API internally.
 	err := C.heif_context_read_from_memory(c.context, unsafe.Pointer(&data[0]), C.size_t(len(data)), nil)
-	keepAlive(c)
+	runtime.KeepAlive(c)
 	return convertHeifError(err)
 }
 
@@ -377,19 +475,19 @@ func (e *Encoder) Name() string {
 
 func (e *Encoder) SetQuality(q int) error {
 	err := C.heif_encoder_set_lossy_quality(e.encoder, C.int(q))
-	keepAlive(e)
+	runtime.KeepAlive(e)
 	return convertHeifError(err)
 }
 
 func (e *Encoder) SetLossless(l LosslessMode) error {
 	err := C.heif_encoder_set_lossless(e.encoder, C.int(l))
-	keepAlive(e)
+	runtime.KeepAlive(e)
 	return convertHeifError(err)
 }
 
 func (e *Encoder) SetLoggingLevel(l LoggingLevel) error {
 	err := C.heif_encoder_set_logging_level(e.encoder, C.int(l))
-	keepAlive(e)
+	runtime.KeepAlive(e)
 	return convertHeifError(err)
 }
 
@@ -406,7 +504,7 @@ func (c *Context) convertEncoderDescriptor(d *C.struct_heif_encoder_descriptor)
 		name: C.GoString(cname),
 	}
 	err := C.heif_context_get_encoder(c.context, d, &enc.encoder)
-	keepAlive(c)
+	runtime.KeepAlive(c)
 	if err := convertHeifError(err); err != nil {
 		return nil, err
 	}
@@ -418,7 +516,7 @@ func (c *Context) NewEncoder(compression Compression) (*Encoder, error) {
 	const max = 1
 	descriptors := make([]*C.struct_heif_encoder_descriptor, max)
 	num := int(C.heif_context_get_encoder_descriptors(c.context, uint32(compression), nil, &descriptors[0], C.int(max)))
-	keepAlive(c)
+	runtime.KeepAlive(c)
 	if num == 0 {
 		return nil, fmt.Errorf("no encoder for compression %v", compression)
 	}
@@ -427,39 +525,39 @@ func (c *Context) NewEncoder(compression Compression) (*Encoder, error) {
 
 func (c *Context) WriteToFile(filename string) error {
 	err := C.heif_context_write_to_file(c.context, C.CString(filename))
-	keepAlive(c)
+	runtime.KeepAlive(c)
 	return convertHeifError(err)
 }
 
 func (c *Context) GetNumberOfTopLevelImages() int {
 	i := int(C.heif_context_get_number_of_top_level_images(c.context))
-	keepAlive(c)
+	runtime.KeepAlive(c)
 	return i
 }
 
 func (c *Context) IsTopLevelImageID(ID int) bool {
 	ok := C.heif_context_is_top_level_image_ID(c.context, C.heif_item_id(ID)) != 0
-	keepAlive(c)
+	runtime.KeepAlive(c)
 	return ok
 }
 
 func (c *Context) GetListOfTopLevelImageIDs() []int {
 	num := int(C.heif_context_get_number_of_top_level_images(c.context))
-	keepAlive(c)
+	runtime.KeepAlive(c)
 	if num == 0 {
 		return []int{}
 	}
 
 	origIDs := make([]C.heif_item_id, num)
 	C.heif_context_get_list_of_top_level_image_IDs(c.context, &origIDs[0], C.int(num))
-	keepAlive(c)
+	runtime.KeepAlive(c)
 	return convertItemIDs(origIDs, num)
 }
 
 func (c *Context) GetPrimaryImageID() (int, error) {
 	var id C.heif_item_id
 	err := C.heif_context_get_primary_image_ID(c.context, &id)
-	keepAlive(c)
+	runtime.KeepAlive(c)
 	if err := convertHeifError(err); err != nil {
 		return 0, err
 	}
@@ -480,7 +578,7 @@ func freeHeifImageHandle(c *ImageHandle) {
 func (c *Context) GetPrimaryImageHandle() (*ImageHandle, error) {
 	var handle ImageHandle
 	err := C.heif_context_get_primary_image_handle(c.context, &handle.handle)
-	keepAlive(c)
+	runtime.KeepAlive(c)
 	if err := convertHeifError(err); err != nil {
 		return nil, err
 	}
@@ -491,7 +589,7 @@ func (c *Context) GetPrimaryImageHandle() (*ImageHandle, error) {
 func (c *Context) GetImageHandle(id int) (*ImageHandle, error) {
 	var handle ImageHandle
 	err := C.heif_context_get_image_handle(c.context, C.heif_item_id(id), &handle.handle)
-	keepAlive(c)
+	runtime.KeepAlive(c)
 	if err := convertHeifError(err); err != nil {
 		return nil, err
 	}
@@ -501,57 +599,57 @@ func (c *Context) GetImageHandle(id int) (*ImageHandle, error) {
 
 func (h *ImageHandle) IsPrimaryImage() bool {
 	ok := C.heif_image_handle_is_primary_image(h.handle) != 0
-	keepAlive(h)
+	runtime.KeepAlive(h)
 	return ok
 }
 
 func (h *ImageHandle) GetWidth() int {
 	i := int(C.heif_image_handle_get_width(h.handle))
-	keepAlive(h)
+	runtime.KeepAlive(h)
 	return i
 }
 
 func (h *ImageHandle) GetHeight() int {
 	i := int(C.heif_image_handle_get_height(h.handle))
-	keepAlive(h)
+	runtime.KeepAlive(h)
 	return i
 }
 
 func (h *ImageHandle) HasAlphaChannel() bool {
 	ok := C.heif_image_handle_has_alpha_channel(h.handle) != 0
-	keepAlive(h)
+	runtime.KeepAlive(h)
 	return ok
 }
 
 func (h *ImageHandle) HasDepthImage() bool {
 	ok := C.heif_image_handle_has_depth_image(h.handle) != 0
-	keepAlive(h)
+	runtime.KeepAlive(h)
 	return ok
 }
 
 func (h *ImageHandle) GetNumberOfDepthImages() int {
 	i := int(C.heif_image_handle_get_number_of_depth_images(h.handle))
-	keepAlive(h)
+	runtime.KeepAlive(h)
 	return i
 }
 
 func (h *ImageHandle) GetListOfDepthImageIDs() []int {
 	num := int(C.heif_image_handle_get_number_of_depth_images(h.handle))
-	keepAlive(h)
+	runtime.KeepAlive(h)
 	if num == 0 {
 		return []int{}
 	}
 
 	origIDs := make([]C.heif_item_id, num)
 	C.heif_image_handle_get_list_of_depth_image_IDs(h.handle, &origIDs[0], C.int(num))
-	keepAlive(h)
+	runtime.KeepAlive(h)
 	return convertItemIDs(origIDs, num)
 }
 
 func (h *ImageHandle) GetDepthImageHandle(depth_image_id int) (*ImageHandle, error) {
 	var handle ImageHandle
 	err := C.heif_image_handle_get_depth_image_handle(h.handle, C.heif_item_id(depth_image_id), &handle.handle)
-	keepAlive(h)
+	runtime.KeepAlive(h)
 	if err := convertHeifError(err); err != nil {
 		return nil, err
 	}
@@ -562,27 +660,27 @@ func (h *ImageHandle) GetDepthImageHandle(depth_image_id int) (*ImageHandle, err
 
 func (h *ImageHandle) GetNumberOfThumbnails() int {
 	i := int(C.heif_image_handle_get_number_of_thumbnails(h.handle))
-	keepAlive(h)
+	runtime.KeepAlive(h)
 	return i
 }
 
 func (h *ImageHandle) GetListOfThumbnailIDs() []int {
 	num := int(C.heif_image_handle_get_number_of_thumbnails(h.handle))
-	keepAlive(h)
+	runtime.KeepAlive(h)
 	if num == 0 {
 		return []int{}
 	}
 
 	origIDs := make([]C.heif_item_id, num)
 	C.heif_image_handle_get_list_of_thumbnail_IDs(h.handle, &origIDs[0], C.int(num))
-	keepAlive(h)
+	runtime.KeepAlive(h)
 	return convertItemIDs(origIDs, num)
 }
 
 func (h *ImageHandle) GetThumbnail(thumbnail_id int) (*ImageHandle, error) {
 	var handle ImageHandle
 	err := C.heif_image_handle_get_thumbnail(h.handle, C.heif_item_id(thumbnail_id), &handle.handle)
-	keepAlive(h)
+	runtime.KeepAlive(h)
 	runtime.SetFinalizer(&handle, freeHeifImageHandle)
 	return &handle, convertHeifError(err)
 }
@@ -640,7 +738,7 @@ func (h *ImageHandle) DecodeImage(colorspace Colorspace, chroma Chroma, options
 	}
 
 	err := C.heif_decode_image(h.handle, &image.image, uint32(colorspace), uint32(chroma), opt)
-	keepAlive(h)
+	runtime.KeepAlive(h)
 	if err := convertHeifError(err); err != nil {
 		return nil, err
 	}
@@ -651,37 +749,37 @@ func (h *ImageHandle) DecodeImage(colorspace Colorspace, chroma Chroma, options
 
 func (img *Image) GetColorspace() Colorspace {
 	cs := Colorspace(C.heif_image_get_colorspace(img.image))
-	keepAlive(img)
+	runtime.KeepAlive(img)
 	return cs
 }
 
 func (img *Image) GetChromaFormat() Chroma {
 	c := Chroma(C.heif_image_get_chroma_format(img.image))
-	keepAlive(img)
+	runtime.KeepAlive(img)
 	return c
 }
 
 func (img *Image) GetWidth(channel Channel) int {
 	i := int(C.heif_image_get_width(img.image, uint32(channel)))
-	keepAlive(img)
+	runtime.KeepAlive(img)
 	return i
 }
 
 func (img *Image) GetHeight(channel Channel) int {
 	i := int(C.heif_image_get_height(img.image, uint32(channel)))
-	keepAlive(img)
+	runtime.KeepAlive(img)
 	return i
 }
 
 func (img *Image) GetBitsPerPixel(channel Channel) int {
 	i := int(C.heif_image_get_bits_per_pixel(img.image, uint32(channel)))
-	keepAlive(img)
+	runtime.KeepAlive(img)
 	return i
 }
 
 func (img *Image) GetBitsPerPixelRange(channel Channel) int {
 	i := int(C.heif_image_get_bits_per_pixel_range(img.image, uint32(channel)))
-	keepAlive(img)
+	runtime.KeepAlive(img)
 	return i
 }
 
@@ -1069,14 +1167,14 @@ func (i *ImageAccess) setData(data []byte, stride int) {
 
 func (img *Image) GetPlane(channel Channel) (*ImageAccess, error) {
 	height := C.heif_image_get_height(img.image, uint32(channel))
-	keepAlive(img)
+	runtime.KeepAlive(img)
 	if height == -1 {
 		return nil, fmt.Errorf("No such channel %v", channel)
 	}
 
 	var stride C.int
 	plane := C.heif_image_get_plane(img.image, uint32(channel), &stride)
-	keepAlive(img)
+	runtime.KeepAlive(img)
 	if plane == nil {
 		return nil, fmt.Errorf("No such channel %v", channel)
 	}
@@ -1095,7 +1193,7 @@ func (img *Image) GetPlane(channel Channel) (*ImageAccess, error) {
 
 func (img *Image) NewPlane(channel Channel, width, height, depth int) (*ImageAccess, error) {
 	err := C.heif_image_add_plane(img.image, uint32(channel), C.int(width), C.int(height), C.int(depth))
-	keepAlive(img)
+	runtime.KeepAlive(img)
 	if err := convertHeifError(err); err != nil {
 		return nil, err
 	}
@@ -1105,7 +1203,7 @@ func (img *Image) NewPlane(channel Channel, width, height, depth int) (*ImageAcc
 func (img *Image) ScaleImage(width int, height int) (*Image, error) {
 	var scaled_image Image
 	err := C.heif_image_scale_image(img.image, &scaled_image.image, C.int(width), C.int(height), nil)
-	keepAlive(img)
+	runtime.KeepAlive(img)
 	if err := convertHeifError(err); err != nil {
 		return nil, err
 	}
@@ -1239,6 +1337,10 @@ func imageFromYCbCr(i *image.YCbCr) (*Image, error) {
 	switch sr := i.SubsampleRatio; sr {
 	case image.YCbCrSubsampleRatio420:
 		cm = Chroma420
+	case image.YCbCrSubsampleRatio422:
+		cm = Chroma422
+	case image.YCbCrSubsampleRatio444:
+		cm = Chroma444
 	default:
 		return nil, fmt.Errorf("unsupported subsample ratio: %s", sr.String())
 	}
@@ -1256,13 +1358,23 @@ func imageFromYCbCr(i *image.YCbCr) (*Image, error) {
 	pY.setData([]byte(i.Y), i.YStride)
 
 	// TODO: Might need to be updated for other SubsampleRatio values.
-	halfW, halfH := (w+1)/2, (h+1)/2
-	pCb, err := out.NewPlane(ChannelCb, halfW, halfH, depth)
+	var cw, ch int
+	switch cm {
+	case Chroma420:
+		cw, ch = (w+1)/2, (h+1)/2
+	case Chroma444:
+		cw, ch = w, h
+	case Chroma422:
+		cw, ch = (w+1)/2, h
+	default:
+		return nil, fmt.Errorf("cm not support: %v", cm)
+	}
+	pCb, err := out.NewPlane(ChannelCb, cw, ch, depth)
 	if err != nil {
 		return nil, fmt.Errorf("failed to add Cb plane: %v", err)
 	}
 	pCb.setData([]byte(i.Cb), i.CStride)
-	pCr, err := out.NewPlane(ChannelCr, halfW, halfH, depth)
+	pCr, err := out.NewPlane(ChannelCr, cw, ch, depth)
 	if err != nil {
 		return nil, fmt.Errorf("failed to add Cr plane: %v", err)
 	}
@@ -1330,10 +1442,10 @@ func EncodeFromImage(img image.Image, compression Compression, quality int, loss
 
 	var handle ImageHandle
 	err2 := C.heif_context_encode_image(ctx.context, out.image, enc.encoder, encOpts.options, &handle.handle)
-	keepAlive(ctx)
-	keepAlive(out)
-	keepAlive(enc)
-	keepAlive(encOpts)
+	runtime.KeepAlive(ctx)
+	runtime.KeepAlive(out)
+	runtime.KeepAlive(enc)
+	runtime.KeepAlive(encOpts)
 	if err := convertHeifError(err2); err != nil {
 		return nil, fmt.Errorf("failed to encode image: %v", err)
 	}
diff --git a/go/heif/heif_test.go b/go/heif/heif_test.go
index 8771db0eed..d48c9fb4de 100644
--- a/go/heif/heif_test.go
+++ b/go/heif/heif_test.go
@@ -1,21 +1,27 @@
 /*
- * GO interface to libheif
- * Copyright (c) 2018 struktur AG, Joachim Bauch <bauch@struktur.de>
+ * Test for GO interface to libheif
  *
- * This file is part of heif, an example application using libheif.
+ * MIT License
  *
- * heif is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
+ * Copyright (c) 2018 Joachim Bauch <bauch@struktur.de>
  *
- * heif is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
  *
- * You should have received a copy of the GNU General Public License
- * along with heif.  If not, see <http://www.gnu.org/licenses/>.
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
  */
 
 package heif
@@ -65,14 +71,8 @@ func CheckHeifImage(t *testing.T, handle *ImageHandle, thumbnail bool) {
 		}
 	}
 
-	if img, err := handle.DecodeImage(ColorspaceUndefined, ChromaUndefined, nil); err != nil {
-		t.Errorf("Could not decode image: %s", err)
-	} else {
-		img.GetColorspace()
-		img.GetChromaFormat()
-	}
-
 	decodeTests := []decodeTest{
+		decodeTest{ColorspaceUndefined, ChromaUndefined},
 		decodeTest{ColorspaceYCbCr, Chroma420},
 		decodeTest{ColorspaceYCbCr, Chroma422},
 		decodeTest{ColorspaceYCbCr, Chroma444},
diff --git a/go/heif/keepalive_16.go b/go/heif/keepalive_16.go
deleted file mode 100644
index ef6941d5e4..0000000000
--- a/go/heif/keepalive_16.go
+++ /dev/null
@@ -1,30 +0,0 @@
-// +build !go1.7
-
-/*
- * GO interface to libheif
- * Copyright (c) 2019 struktur AG, Dirk Farin <farin@struktur.de>
- *
- * This file is part of heif, an example application using libheif.
- *
- * heif is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * heif is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with heif.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-package heif
-
-//go:noinline
-func keepAlive(x interface{}) {
-	if _Cgo_always_false {
-		_Cgo_use(x)
-	}
-}
diff --git a/go/heif/keepalive_17.go b/go/heif/keepalive_17.go
deleted file mode 100644
index d5b5d85a27..0000000000
--- a/go/heif/keepalive_17.go
+++ /dev/null
@@ -1,31 +0,0 @@
-// +build go1.7
-
-/*
- * GO interface to libheif
- * Copyright (c) 2019 struktur AG, Dirk Farin <farin@struktur.de>
- *
- * This file is part of heif, an example application using libheif.
- *
- * heif is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * heif is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with heif.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-package heif
-
-import (
-	"runtime"
-)
-
-func keepAlive(x interface{}) {
-	runtime.KeepAlive(x)
-}
diff --git a/heifio/CMakeLists.txt b/heifio/CMakeLists.txt
new file mode 100644
index 0000000000..e6b1bbf7a3
--- /dev/null
+++ b/heifio/CMakeLists.txt
@@ -0,0 +1,118 @@
+# Needed to find libheif/heif_version.h while compiling the library
+include_directories(${libheif_BINARY_DIR} ${libheif_SOURCE_DIR}/libheif/api ${libheif_SOURCE_DIR}/libheif)
+
+add_library(heifio STATIC
+        decoder.h
+        decoder_raw.cc
+        decoder_raw.h
+        decoder_y4m.cc
+        decoder_y4m.h
+        encoder.h
+        encoder.cc
+        encoder_y4m.h
+        encoder_y4m.cc
+        exif.h
+        exif.cc
+        stubs.cc)
+
+target_link_libraries(heifio PRIVATE heif)
+
+set_target_properties(heifio
+        PROPERTIES
+        VERSION ${PROJECT_VERSION})
+
+
+target_compile_definitions(heifio
+        PUBLIC
+        LIBHEIF_EXPORTS
+        HAVE_VISIBILITY)
+
+find_package(TIFF)
+if (TIFF_FOUND)
+    target_sources(heifio PRIVATE decoder_tiff.cc decoder_tiff.h encoder_tiff.h encoder_tiff.cc)
+    target_link_libraries(heifio PRIVATE TIFF::TIFF)
+    target_compile_definitions(heifio PUBLIC HAVE_LIBTIFF=1)
+
+    option(WITH_GEOTIFF "Print GeoTIFF metadata when encoding tiled TIFFs (requires libgeotiff)" OFF)
+    if (WITH_GEOTIFF)
+        find_library(GEOTIFF_LIBRARY geotiff)
+        find_path(GEOTIFF_INCLUDE_DIR geotiff/geotiff.h)
+        if (GEOTIFF_LIBRARY AND GEOTIFF_INCLUDE_DIR)
+            set(GEOTIFF_FOUND TRUE)
+            target_compile_definitions(heifio PUBLIC HAVE_GEOTIFF=1)
+            target_link_libraries(heifio PRIVATE ${GEOTIFF_LIBRARY})
+            target_include_directories(heifio PRIVATE ${GEOTIFF_INCLUDE_DIR})
+        endif()
+    endif()
+endif()
+
+find_package(JPEG)
+if (TARGET JPEG::JPEG)
+    target_compile_definitions(heifio PUBLIC -DHAVE_LIBJPEG=1)
+
+    include(CheckCXXSourceCompiles)
+
+    # this is needed for CheckCXXSourceCompiles
+    set(CMAKE_REQUIRED_LIBRARIES ${JPEG_LIBRARIES})
+    set(CMAKE_REQUIRED_INCLUDES ${JPEG_INCLUDE_DIRS})
+    check_cxx_source_compiles("
+#include <stddef.h>
+#include <stdio.h>
+#include <jpeglib.h>
+
+int main() {
+  jpeg_write_icc_profile(NULL, NULL, 0);
+  return 0;
+}
+" HAVE_JPEG_WRITE_ICC_PROFILE)
+    unset(CMAKE_REQUIRED_LIBRARIES)
+    unset(CMAKE_REQUIRED_INCLUDES)
+
+    if (HAVE_JPEG_WRITE_ICC_PROFILE)
+        add_definitions(-DHAVE_JPEG_WRITE_ICC_PROFILE=1)
+    endif ()
+
+    target_link_libraries(heifio PRIVATE JPEG::JPEG)
+
+    target_sources(heifio PRIVATE encoder_jpeg.cc encoder_jpeg.h)
+    target_sources(heifio PRIVATE decoder.h decoder_jpeg.cc decoder_jpeg.h)
+endif ()
+
+
+find_package(PNG)
+set(PNG_FOUND ${PNG_FOUND} PARENT_SCOPE)
+if (TARGET PNG::PNG)
+    target_compile_definitions(heifio PUBLIC -DHAVE_LIBPNG=1)
+
+    target_link_libraries(heifio PRIVATE PNG::PNG)
+
+    target_sources(heifio PRIVATE encoder_png.cc encoder_png.h)
+    target_sources(heifio PRIVATE decoder_png.cc decoder_png.h)
+endif ()
+
+message("")
+message("=== Active input formats for heif-enc ===")
+if (JPEG_FOUND)
+    message("JPEG: active")
+else ()
+    message("JPEG: ------ (libjpeg not found)")
+endif ()
+if (PNG_FOUND)
+    message("PNG:  active")
+else ()
+    message("PNG:  ------ (libpng not found)")
+endif ()
+if (TIFF_FOUND)
+    message("TIFF: active")
+    if (NOT WITH_GEOTIFF)
+        message("GeoTIFF: ------ (WITH_GEOTIFF=OFF)")
+    elseif (GEOTIFF_FOUND)
+        message("GeoTIFF: active")
+    else ()
+        message("GeoTIFF: ------ (libgeotiff not found)")
+    endif ()
+else ()
+    message("TIFF: ------ (libtiff not found)")
+endif ()
+message("")
+
diff --git a/heifio/decoder.h b/heifio/decoder.h
new file mode 100644
index 0000000000..5e80d25047
--- /dev/null
+++ b/heifio/decoder.h
@@ -0,0 +1,42 @@
+/*
+  libheif example application "heif".
+
+  MIT License
+
+  Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#ifndef LIBHEIF_DECODER_H
+#define LIBHEIF_DECODER_H
+
+#include "libheif/heif.h"
+#include <memory>
+#include <vector>
+
+struct InputImage
+{
+  std::shared_ptr<heif_image> image;
+  std::vector<uint8_t> xmp;
+  std::vector<uint8_t> exif;
+  heif_orientation orientation = heif_orientation_normal;
+};
+
+#endif //LIBHEIF_DECODER_H
diff --git a/heifio/decoder_jpeg.cc b/heifio/decoder_jpeg.cc
new file mode 100644
index 0000000000..f602461c12
--- /dev/null
+++ b/heifio/decoder_jpeg.cc
@@ -0,0 +1,570 @@
+/*
+  libheif example application "heif".
+
+  MIT License
+
+  Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#include <memory>
+#include <vector>
+#include <cstdlib>
+#include <cstring>
+#include <cstdio>
+#include <iostream>
+#include <cassert>
+#include <algorithm>
+#include <array>
+#include "decoder_jpeg.h"
+#include "exif.h"
+
+extern "C" {
+// Prevent duplicate definition for libjpeg-turbo v2.0
+// Note: these 'undef's are only a workaround for a libjpeg-turbo-v2.0 bug and
+// should be removed again later. Bug has been fixed in libjpeg-turbo-v2.0.1.
+#include <jconfig.h>
+#if defined(LIBJPEG_TURBO_VERSION_NUMBER) && LIBJPEG_TURBO_VERSION_NUMBER == 2000000
+#undef HAVE_STDDEF_H
+#undef HAVE_STDLIB_H
+#endif
+#include <jpeglib.h>
+}
+
+#define JPEG_EXIF_MARKER  (JPEG_APP0+1)  /* JPEG marker code for EXIF */
+#define JPEG_EXIF_MARKER_LEN 6 // "Exif/0/0"
+#define JPEG_XMP_MARKER  (JPEG_APP0+1)  /* JPEG marker code for XMP */
+#define JPEG_XMP_MARKER_ID "http://ns.adobe.com/xap/1.0/"
+#define JPEG_ICC_MARKER  (JPEG_APP0+2)  /* JPEG marker code for ICC */
+#define JPEG_ICC_OVERHEAD_LEN  14        /* size of non-profile data in APP2 */
+
+static struct heif_error heif_error_ok = {heif_error_Ok, heif_suberror_Unspecified, "Success"};
+
+static bool JPEGMarkerIsIcc(jpeg_saved_marker_ptr marker)
+{
+  return
+      marker->marker == JPEG_ICC_MARKER &&
+      marker->data_length >= JPEG_ICC_OVERHEAD_LEN &&
+      /* verify the identifying string */
+      GETJOCTET(marker->data[0]) == 0x49 &&
+      GETJOCTET(marker->data[1]) == 0x43 &&
+      GETJOCTET(marker->data[2]) == 0x43 &&
+      GETJOCTET(marker->data[3]) == 0x5F &&
+      GETJOCTET(marker->data[4]) == 0x50 &&
+      GETJOCTET(marker->data[5]) == 0x52 &&
+      GETJOCTET(marker->data[6]) == 0x4F &&
+      GETJOCTET(marker->data[7]) == 0x46 &&
+      GETJOCTET(marker->data[8]) == 0x49 &&
+      GETJOCTET(marker->data[9]) == 0x4C &&
+      GETJOCTET(marker->data[10]) == 0x45 &&
+      GETJOCTET(marker->data[11]) == 0x0;
+}
+
+bool ReadICCProfileFromJPEG(j_decompress_ptr cinfo,
+                            JOCTET** icc_data_ptr,
+                            unsigned int* icc_data_len)
+{
+  jpeg_saved_marker_ptr marker;
+  int num_markers = 0;
+  int seq_no;
+  JOCTET* icc_data;
+  unsigned int total_length;
+#define MAX_SEQ_NO  255        /* sufficient since marker numbers are bytes */
+  char marker_present[MAX_SEQ_NO + 1];      /* 1 if marker found */
+  unsigned int data_length[MAX_SEQ_NO + 1]; /* size of profile data in marker */
+  unsigned int data_offset[MAX_SEQ_NO + 1]; /* offset for data in marker */
+
+  *icc_data_ptr = NULL;        /* avoid confusion if FALSE return */
+  *icc_data_len = 0;
+
+  /* This first pass over the saved markers discovers whether there are
+   * any ICC markers and verifies the consistency of the marker numbering.
+   */
+
+  for (seq_no = 1; seq_no <= MAX_SEQ_NO; seq_no++)
+    marker_present[seq_no] = 0;
+
+  for (marker = cinfo->marker_list; marker != NULL; marker = marker->next) {
+    if (JPEGMarkerIsIcc(marker)) {
+      if (num_markers == 0)
+        num_markers = GETJOCTET(marker->data[13]);
+      else if (num_markers != GETJOCTET(marker->data[13]))
+        return FALSE;        /* inconsistent num_markers fields */
+      seq_no = GETJOCTET(marker->data[12]);
+      if (seq_no <= 0 || seq_no > num_markers)
+        return FALSE;        /* bogus sequence number */
+      if (marker_present[seq_no])
+        return FALSE;        /* duplicate sequence numbers */
+      marker_present[seq_no] = 1;
+      data_length[seq_no] = marker->data_length - JPEG_ICC_OVERHEAD_LEN;
+    }
+  }
+
+  if (num_markers == 0)
+    return FALSE;
+
+  /* Check for missing markers, count total space needed,
+   * compute offset of each marker's part of the data.
+   */
+
+  total_length = 0;
+  for (seq_no = 1; seq_no <= num_markers; seq_no++) {
+    if (marker_present[seq_no] == 0)
+      return FALSE;        /* missing sequence number */
+    data_offset[seq_no] = total_length;
+    total_length += data_length[seq_no];
+  }
+
+  if (total_length <= 0)
+    return FALSE;        /* found only empty markers? */
+
+  /* Allocate space for assembled data */
+  icc_data = (JOCTET*) malloc(total_length * sizeof(JOCTET));
+  if (icc_data == NULL)
+    return FALSE;        /* oops, out of memory */
+
+  /* and fill it in */
+  for (marker = cinfo->marker_list; marker != NULL; marker = marker->next) {
+    if (JPEGMarkerIsIcc(marker)) {
+      JOCTET FAR* src_ptr;
+      JOCTET* dst_ptr;
+      unsigned int length;
+      seq_no = GETJOCTET(marker->data[12]);
+      dst_ptr = icc_data + data_offset[seq_no];
+      src_ptr = marker->data + JPEG_ICC_OVERHEAD_LEN;
+      length = data_length[seq_no];
+      while (length--) {
+        *dst_ptr++ = *src_ptr++;
+      }
+    }
+  }
+
+  *icc_data_ptr = icc_data;
+  *icc_data_len = total_length;
+
+  return TRUE;
+}
+
+
+static bool JPEGMarkerIsXMP(jpeg_saved_marker_ptr marker)
+{
+  return
+      marker->marker == JPEG_XMP_MARKER &&
+      marker->data_length >= strlen(JPEG_XMP_MARKER_ID) + 1 &&
+      strncmp((const char*) (marker->data), JPEG_XMP_MARKER_ID, strlen(JPEG_XMP_MARKER_ID)) == 0;
+}
+
+bool ReadXMPFromJPEG(j_decompress_ptr cinfo,
+                     std::vector<uint8_t>& xmpData)
+{
+  jpeg_saved_marker_ptr marker;
+
+  for (marker = cinfo->marker_list; marker != NULL; marker = marker->next) {
+    if (JPEGMarkerIsXMP(marker)) {
+      int length = (int) (marker->data_length - (strlen(JPEG_XMP_MARKER_ID) + 1));
+      xmpData.resize(length);
+      memcpy(xmpData.data(), marker->data + strlen(JPEG_XMP_MARKER_ID) + 1, length);
+      return true;
+    }
+  }
+
+  return false;
+}
+
+
+static bool JPEGMarkerIsEXIF(jpeg_saved_marker_ptr marker)
+{
+  return marker->marker == JPEG_EXIF_MARKER &&
+         marker->data_length >= JPEG_EXIF_MARKER_LEN &&
+         GETJOCTET(marker->data[0]) == 'E' &&
+         GETJOCTET(marker->data[1]) == 'x' &&
+         GETJOCTET(marker->data[2]) == 'i' &&
+         GETJOCTET(marker->data[3]) == 'f' &&
+         GETJOCTET(marker->data[4]) == 0 &&
+         GETJOCTET(marker->data[5]) == 0;
+}
+
+bool ReadEXIFFromJPEG(j_decompress_ptr cinfo,
+                      std::vector<uint8_t>& exifData)
+{
+  jpeg_saved_marker_ptr marker;
+
+  for (marker = cinfo->marker_list; marker != NULL; marker = marker->next) {
+    if (JPEGMarkerIsEXIF(marker)) {
+      int length = (int) (marker->data_length - JPEG_EXIF_MARKER_LEN);
+      exifData.resize(length);
+      memcpy(exifData.data(), marker->data + JPEG_EXIF_MARKER_LEN, length);
+      return true;
+    }
+  }
+
+  return false;
+}
+
+
+#if JPEG_LIB_VERSION < 70
+#define DCT_h_scaled_size DCT_scaled_size
+#define DCT_v_scaled_size DCT_scaled_size
+#endif
+
+
+heif_error loadJPEG(const char *filename, InputImage *input_image)
+{
+  struct heif_image* image = nullptr;
+  struct heif_error err = heif_error_ok;
+
+  // ### Code copied from LibVideoGfx and slightly modified to use HeifPixelImage
+
+  struct jpeg_decompress_struct cinfo;
+  struct jpeg_error_mgr jerr;
+
+  // to store embedded icc profile
+  uint32_t iccLen;
+  uint8_t* iccBuffer = NULL;
+
+  std::vector<uint8_t> xmpData;
+  std::vector<uint8_t> exifData;
+
+  // open input file
+
+  FILE* infile;
+  if ((infile = fopen(filename, "rb")) == NULL) {
+    struct heif_error err = {
+      .code = heif_error_Invalid_input,
+      .subcode = heif_suberror_Unspecified,
+      .message = "Cannot open JPEG file"};
+    return err;
+  }
+
+
+  // initialize decompressor
+
+  jpeg_create_decompress(&cinfo);
+
+  cinfo.err = jpeg_std_error(&jerr);
+  jpeg_stdio_src(&cinfo, infile);
+
+  /* Adding this part to prepare for icc profile reading. */
+  jpeg_save_markers(&cinfo, JPEG_ICC_MARKER, 0xFFFF);
+  jpeg_save_markers(&cinfo, JPEG_XMP_MARKER, 0xFFFF);
+  jpeg_save_markers(&cinfo, JPEG_EXIF_MARKER, 0xFFFF);
+
+  jpeg_read_header(&cinfo, TRUE);
+
+  bool embeddedIccFlag = ReadICCProfileFromJPEG(&cinfo, &iccBuffer, &iccLen);
+  bool embeddedXMPFlag = ReadXMPFromJPEG(&cinfo, xmpData);
+  if (embeddedXMPFlag) {
+    input_image->xmp = xmpData;
+  }
+
+  bool embeddedEXIFFlag = ReadEXIFFromJPEG(&cinfo, exifData);
+  if (embeddedEXIFFlag) {
+    input_image->exif = exifData;
+    input_image->orientation = (heif_orientation) read_exif_orientation_tag(exifData.data(), (int) exifData.size());
+  }
+
+  if (cinfo.jpeg_color_space == JCS_GRAYSCALE) {
+    cinfo.out_color_space = JCS_GRAYSCALE;
+
+    jpeg_start_decompress(&cinfo);
+
+    JSAMPARRAY buffer;
+    buffer = (*cinfo.mem->alloc_sarray)
+        ((j_common_ptr) &cinfo, JPOOL_IMAGE, cinfo.output_width * cinfo.output_components, 1);
+
+
+    // create destination image
+
+    err = heif_image_create(cinfo.output_width, cinfo.output_height,
+                            heif_colorspace_monochrome,
+                            heif_chroma_monochrome,
+                            &image);
+    if (err.code) {
+      goto cleanup;
+    }
+
+    err = heif_image_add_plane(image, heif_channel_Y, cinfo.output_width, cinfo.output_height, 8);
+    if (err.code) { goto cleanup; }
+
+    size_t y_stride;
+    uint8_t* py = heif_image_get_plane2(image, heif_channel_Y, &y_stride);
+
+
+    // read the image
+
+    while (cinfo.output_scanline < cinfo.output_height) {
+      (void) jpeg_read_scanlines(&cinfo, buffer, 1);
+
+      memcpy(py + (cinfo.output_scanline - 1) * y_stride, *buffer, cinfo.output_width);
+    }
+  }
+  else if (cinfo.jpeg_color_space == JCS_YCbCr) {
+    cinfo.out_color_space = JCS_YCbCr;
+
+    bool read_raw = false;
+    heif_chroma output_chroma = heif_chroma_420;
+
+    if (cinfo.comp_info[1].h_samp_factor == 1 &&
+        cinfo.comp_info[1].v_samp_factor == 1 &&
+        cinfo.comp_info[2].h_samp_factor == 1 &&
+        cinfo.comp_info[2].v_samp_factor == 1) {
+
+      if (cinfo.comp_info[0].h_samp_factor == 1 &&
+          cinfo.comp_info[0].v_samp_factor == 1) {
+        output_chroma = heif_chroma_444;
+        read_raw = true;
+      }
+      else if (cinfo.comp_info[0].h_samp_factor == 2 &&
+               cinfo.comp_info[0].v_samp_factor == 1) {
+        output_chroma = heif_chroma_422;
+        read_raw = true;
+      }
+      else if (cinfo.comp_info[0].h_samp_factor == 2 &&
+               cinfo.comp_info[0].v_samp_factor == 2) {
+        output_chroma = heif_chroma_420;
+        read_raw = true;
+      }
+    }
+
+    int cw=0,ch=0;
+    switch (output_chroma) {
+      case heif_chroma_420:
+        cw = (cinfo.image_width + 1) / 2;
+        ch = (cinfo.image_height + 1) / 2;
+        break;
+      case heif_chroma_422:
+        cw = (cinfo.image_width + 1) / 2;
+        ch = cinfo.image_height;
+        break;
+      case heif_chroma_444:
+        cw = cinfo.image_width;
+        ch = cinfo.image_height;
+        break;
+      default:
+        assert(false);
+    }
+
+    //read_raw = false;
+
+    cinfo.raw_data_out = boolean(read_raw);
+
+    jpeg_start_decompress(&cinfo);
+
+
+    // create destination image
+
+    struct heif_error err = heif_image_create(cinfo.output_width, cinfo.output_height,
+                                              heif_colorspace_YCbCr,
+                                              output_chroma,
+                                              &image);
+    if (err.code) { goto cleanup; }
+
+    err = heif_image_add_plane(image, heif_channel_Y, cinfo.output_width, cinfo.output_height, 8);
+    if (err.code) { goto cleanup; }
+
+    err = heif_image_add_plane(image, heif_channel_Cb, cw, ch, 8);
+    if (err.code) { goto cleanup; }
+
+    err = heif_image_add_plane(image, heif_channel_Cr, cw, ch, 8);
+    if (err.code) { goto cleanup; }
+
+    size_t stride[3];
+    uint8_t* p[3];
+    p[0] = heif_image_get_plane2(image, heif_channel_Y, &stride[0]);
+    p[1] = heif_image_get_plane2(image, heif_channel_Cb, &stride[1]);
+    p[2] = heif_image_get_plane2(image, heif_channel_Cr, &stride[2]);
+
+    // read the image
+
+    if (read_raw) {
+      // adapted from https://github.com/AOMediaCodec/libavif/blob/430ea2df584dcb95ff1632c17643ebbbb2f3bc81/apps/shared/avifjpeg.c
+
+      JSAMPIMAGE buffer;
+      buffer = (JSAMPIMAGE)(cinfo.mem->alloc_small)((j_common_ptr)&cinfo, JPOOL_IMAGE, sizeof(JSAMPARRAY) * cinfo.num_components);
+
+      // lines of output image to be read per jpeg_read_raw_data call
+      int readLines = 0;
+      // lines of samples to be read per call (for each channel)
+      int linesPerCall[3] = { 0, 0, 0 };
+      // expected count of sample lines (for each channel)
+      int targetRead[3] = { 0, 0, 0 };
+      for (int i = 0; i < cinfo.num_components; ++i) {
+        jpeg_component_info * comp = &cinfo.comp_info[i];
+
+        linesPerCall[i] = comp->v_samp_factor * comp->DCT_v_scaled_size;
+        targetRead[i] = comp->downsampled_height;
+        buffer[i] = (cinfo.mem->alloc_sarray)((j_common_ptr)&cinfo,
+                                                JPOOL_IMAGE,
+                                                comp->width_in_blocks * comp->DCT_h_scaled_size,
+                                                linesPerCall[i]);
+        readLines = std::max(readLines, linesPerCall[i]);
+      }
+
+      // count of already-read lines (for each channel)
+      int alreadyRead[3] = { 0, 0, 0 };
+      int width[3] = { (int)cinfo.output_width, cw, cw};
+
+      std::array<int,3> targetChannel{0,1,2};
+
+      if (cinfo.jpeg_color_space == JCS_RGB) {
+        targetChannel = {2, 0, 1};
+      }
+      else if (cinfo.jpeg_color_space == JCS_YCbCr ||
+               cinfo.jpeg_color_space == JCS_GRAYSCALE) {
+        targetChannel = {0, 1, 2};
+      }
+      else {
+        return heif_error{heif_error_Unsupported_filetype,
+                          heif_suberror_Unsupported_image_type,
+                          "JPEG with unsupported colorspace"};
+      }
+
+      while (cinfo.output_scanline < cinfo.output_height) {
+        jpeg_read_raw_data(&cinfo, buffer, readLines);
+
+        int workComponents = 3;
+
+        for (int i = 0; i < workComponents; ++i) {
+          int linesRead = std::min(targetRead[i] - alreadyRead[i], linesPerCall[i]);
+
+          for (int j = 0; j < linesRead; ++j) {
+            memcpy(p[targetChannel[i]] + ((size_t)stride[targetChannel[i]]) * (alreadyRead[i] + j),
+                   buffer[i][j],
+                   width[targetChannel[i]]);
+          }
+          alreadyRead[i] += linesPerCall[i];
+        }
+      }
+    }
+    else {
+      JSAMPARRAY buffer;
+      buffer = (*cinfo.mem->alloc_sarray)
+          ((j_common_ptr) &cinfo, JPOOL_IMAGE, cinfo.output_width * cinfo.output_components, 1);
+
+      while (cinfo.output_scanline < cinfo.output_height) {
+        JOCTET* bufp;
+
+        (void) jpeg_read_scanlines(&cinfo, buffer, 1);
+
+        bufp = buffer[0];
+
+        size_t y = cinfo.output_scanline - 1;
+
+        for (unsigned int x = 0; x < cinfo.output_width; x += 2) {
+          p[0][y * stride[0] + x] = *bufp++;
+          p[1][y / 2 * stride[1] + x / 2] = *bufp++;
+          p[2][y / 2 * stride[2] + x / 2] = *bufp++;
+
+          if (x + 1 < cinfo.output_width) {
+            p[0][y * stride[0] + x + 1] = *bufp++;
+          }
+
+          bufp += 2;
+        }
+
+
+        if (cinfo.output_scanline < cinfo.output_height) {
+          (void) jpeg_read_scanlines(&cinfo, buffer, 1);
+
+          bufp = buffer[0];
+
+          y = cinfo.output_scanline - 1;
+
+          for (unsigned int x = 0; x < cinfo.output_width; x++) {
+            p[0][y * stride[0] + x] = *bufp++;
+            bufp += 2;
+          }
+        }
+      }
+    }
+  }
+  else if (cinfo.jpeg_color_space == JCS_CMYK || cinfo.jpeg_color_space == JCS_YCCK) {
+    // libjpeg converts YCCK to CMYK internally when out_color_space is JCS_CMYK
+    cinfo.out_color_space = JCS_CMYK;
+
+    jpeg_start_decompress(&cinfo);
+
+    JSAMPARRAY buffer;
+    buffer = (*cinfo.mem->alloc_sarray)
+        ((j_common_ptr) &cinfo, JPOOL_IMAGE, cinfo.output_width * 4, 1);
+
+    // create interleaved RGB destination image
+
+    err = heif_image_create(cinfo.output_width, cinfo.output_height,
+                            heif_colorspace_RGB,
+                            heif_chroma_interleaved_RGB,
+                            &image);
+    if (err.code) { goto cleanup; }
+
+    err = heif_image_add_plane(image, heif_channel_interleaved, cinfo.output_width, cinfo.output_height, 8);
+    if (err.code) { goto cleanup; }
+
+    size_t rgb_stride;
+    uint8_t* pRGB = heif_image_get_plane2(image, heif_channel_interleaved, &rgb_stride);
+
+    while (cinfo.output_scanline < cinfo.output_height) {
+      (void) jpeg_read_scanlines(&cinfo, buffer, 1);
+
+      JOCTET* bufp = buffer[0];
+      size_t y = cinfo.output_scanline - 1;
+      uint8_t* row = pRGB + y * rgb_stride;
+
+      for (unsigned int x = 0; x < cinfo.output_width; x++) {
+        uint8_t C = bufp[0];
+        uint8_t M = bufp[1];
+        uint8_t Y = bufp[2];
+        uint8_t K = bufp[3];
+        bufp += 4;
+
+        // CMYK to RGB — JPEG CMYK uses inverted values (255 = no ink)
+        row[0] = (uint8_t)(C * K / 255);
+        row[1] = (uint8_t)(M * K / 255);
+        row[2] = (uint8_t)(Y * K / 255);
+        row += 3;
+      }
+    }
+  }
+  else {
+    jpeg_destroy_decompress(&cinfo);
+    free(iccBuffer);
+    fclose(infile);
+    err = {heif_error_Unsupported_feature,
+           heif_suberror_Unsupported_color_conversion,
+           "Unsupported JPEG color space"};
+    return err;
+  }
+
+  if (embeddedIccFlag && iccLen > 0) {
+    heif_image_set_raw_color_profile(image, "prof", iccBuffer, (size_t) iccLen);
+  }
+
+  input_image->image = std::shared_ptr<heif_image>(image,
+                                                   [](heif_image* img) { heif_image_release(img); });
+
+  // cleanup
+cleanup:
+  free(iccBuffer);
+  jpeg_finish_decompress(&cinfo);
+  jpeg_destroy_decompress(&cinfo);
+
+  fclose(infile);
+
+  return err;
+}
diff --git a/heifio/decoder_jpeg.h b/heifio/decoder_jpeg.h
new file mode 100644
index 0000000000..fd717604d9
--- /dev/null
+++ b/heifio/decoder_jpeg.h
@@ -0,0 +1,35 @@
+/*
+  libheif example application "heif".
+
+  MIT License
+
+  Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#ifndef LIBHEIF_DECODER_JPEG_H
+#define LIBHEIF_DECODER_JPEG_H
+
+#include "decoder.h"
+
+LIBHEIF_API
+heif_error loadJPEG(const char *filename, InputImage *input_image);
+
+#endif //LIBHEIF_DECODER_JPEG_H
diff --git a/heifio/decoder_png.cc b/heifio/decoder_png.cc
new file mode 100644
index 0000000000..3dbf1e562a
--- /dev/null
+++ b/heifio/decoder_png.cc
@@ -0,0 +1,453 @@
+/*
+  libheif example application "heif".
+
+  MIT License
+
+  Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#include <cstdlib>
+#include <cstring>
+#include <cassert>
+#include <iostream>
+#include <memory>
+#include "decoder_png.h"
+#include "exif.h"
+
+extern "C" {
+#include <png.h>
+}
+
+static struct heif_error heif_error_ok = {heif_error_Ok, heif_suberror_Unspecified, "Success"};
+
+static void
+user_read_fn(png_structp png_ptr, png_bytep data, png_size_t length)
+{
+  FILE* fh = (FILE*) png_get_io_ptr(png_ptr);
+  size_t n = fread((char*) data, length, 1, fh);
+  (void) n;
+} // user_read_data
+
+
+heif_error loadPNG(const char* filename, int output_bit_depth, InputImage *input_image)
+{
+  FILE* fh = fopen(filename, "rb");
+  if (!fh) {
+    struct heif_error err = {
+      .code = heif_error_Invalid_input,
+      .subcode = heif_suberror_Unspecified,
+      .message = "Cannot open PNG file"};
+    return err;
+  }
+
+  // ### Code copied from LibVideoGfx and slightly modified to use HeifPixelImage
+
+  struct heif_image* image = nullptr;
+
+  png_structp png_ptr;
+  png_infop info_ptr;
+  png_uint_32 width, height;
+  int bit_depth, color_type, interlace_type;
+  int compression_type;
+  png_charp name;
+#if (PNG_LIBPNG_VER < 10500)
+  png_charp png_profile_data;
+#else
+  png_bytep png_profile_data;
+#endif
+  uint8_t* profile_data = nullptr;
+  png_uint_32 profile_length = 5;
+
+  /* Create and initialize the png_struct with the desired error handler
+   * functions.  If you want to use the default stderr and longjump method,
+   * you can supply NULL for the last three parameters.  We also supply the
+   * the compiler header file version, so that we know if the application
+   * was compiled with a compatible version of the library.  REQUIRED
+   */
+  png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+  assert(png_ptr != NULL);
+
+  /* Allocate/initialize the memory for image information.  REQUIRED. */
+  info_ptr = png_create_info_struct(png_ptr);
+  if (info_ptr == NULL) {
+    png_destroy_read_struct(&png_ptr, (png_infopp) NULL, (png_infopp) NULL);
+    assert(false); // , "could not create info_ptr");
+  } // if
+
+  /* Set error handling if you are using the setjmp/longjmp method (this is
+   * the normal method of doing things with libpng).  REQUIRED unless you
+   * set up your own error handlers in the png_create_read_struct() earlier.
+   */
+  if (setjmp(png_jmpbuf(png_ptr))) {
+    /* Free all of the memory associated with the png_ptr and info_ptr */
+    png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp) NULL);
+    /* If we get here, we had a problem reading the file */
+    assert(false); // , "fatal error in png library");
+  } // if
+
+  /* If you are using replacement read functions, instead of calling
+   * png_init_io() here you would call: */
+  png_set_read_fn(png_ptr, (void*) fh, user_read_fn);
+  /* where user_io_ptr is a structure you want available to the callbacks */
+
+  /* The call to png_read_info() gives us all of the information from the
+   * PNG file before the first IDAT (image data chunk).  REQUIRED
+   */
+  png_read_info(png_ptr, info_ptr);
+
+  png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
+               &interlace_type, NULL, NULL);
+
+  if (png_get_valid(png_ptr, info_ptr, PNG_INFO_iCCP)) {
+    if (PNG_INFO_iCCP ==
+        png_get_iCCP(png_ptr, info_ptr, &name, &compression_type, &png_profile_data, &profile_length) &&
+        profile_length > 0) {
+      profile_data = (uint8_t*) malloc(profile_length);
+      if (profile_data) {
+        memcpy(profile_data, png_profile_data, profile_length);
+      }
+    }
+  }
+  /**** Set up the data transformations you want.  Note that these are all
+   **** optional.  Only call them if you want/need them.  Many of the
+   **** transformations only work on specific types of images, and many
+   **** are mutually exclusive.
+   ****/
+
+  // \TODO
+  //      /* Strip alpha bytes from the input data without combining with the
+  //       * background (not recommended).
+  //       */
+  //      png_set_strip_alpha(png_ptr);
+
+  /* Extract multiple pixels with bit depths of 1, 2, and 4 from a single
+   * byte into separate bytes (useful for paletted and grayscale images).
+   */
+  png_set_packing(png_ptr);
+
+
+  /* Expand paletted colors into true RGB triplets */
+  if (color_type == PNG_COLOR_TYPE_PALETTE) {
+    png_set_palette_to_rgb(png_ptr);
+    bit_depth = 8;
+  }
+
+  /* Expand grayscale images to the full 8 bits from 1, 2, or 4 bits/pixel */
+  if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8) {
+    png_set_expand_gray_1_2_4_to_8(png_ptr);
+    bit_depth = 8;
+  }
+
+  /* Set the background color to draw transparent and alpha images over.
+   * It is possible to set the red, green, and blue components directly
+   * for paletted images instead of supplying a palette index.  Note that
+   * even if the PNG file supplies a background, you are not required to
+   * use it - you should use the (solid) application background if it has one.
+   */
+
+#if 0
+  // \TODO 0 is index in color lookup table - correct? used already?
+  png_color_16 my_background = {0, 255, 255, 255, 255};
+  png_color_16 *image_background;
+
+  if (png_get_bKGD(png_ptr, info_ptr, &image_background))
+    png_set_background(png_ptr, image_background, PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);
+  else
+    png_set_background(png_ptr, &my_background, PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0);
+#endif
+
+
+  /* Optional call to gamma correct and add the background to the palette
+   * and update info structure.  REQUIRED if you are expecting libpng to
+   * update the palette for you (ie you selected such a transform above).
+   */
+  png_read_update_info(png_ptr, info_ptr);
+
+  /* Allocate the memory to hold the image using the fields of info_ptr. */
+
+  /* The easiest way to read the image: */
+  uint8_t** row_pointers = new png_bytep[height];
+  assert(row_pointers != NULL);
+
+  for (uint32_t y = 0; y < height; y++) {
+    row_pointers[y] = (png_bytep) malloc(png_get_rowbytes(png_ptr, info_ptr));
+    assert(row_pointers[y] != NULL);
+  } // for
+
+  /* Now it's time to read the image.  One of these methods is REQUIRED */
+  png_read_image(png_ptr, row_pointers);
+
+  /* read rest of file, and get additional chunks in info_ptr - REQUIRED */
+  png_read_end(png_ptr, info_ptr);
+
+
+  // --- read EXIF data
+
+#ifdef PNG_eXIf_SUPPORTED
+  png_bytep exifPtr = nullptr;
+  png_uint_32 exifSize = 0;
+  if (png_get_eXIf_1(png_ptr, info_ptr, &exifSize, &exifPtr) == PNG_INFO_eXIf) {
+    input_image->exif.resize(exifSize);
+    memcpy(input_image->exif.data(), exifPtr, exifSize);
+
+    // remove the EXIF orientation since it is informal only in PNG and we do not want to confuse with an orientation not matching irot/imir
+    modify_exif_orientation_tag_if_it_exists(input_image->exif.data(), (int) input_image->exif.size(), 1);
+  }
+#endif
+
+  // --- read XMP data
+
+#ifdef PNG_iTXt_SUPPORTED
+  png_textp textPtr = nullptr;
+  const png_uint_32 nTextChunks = png_get_text(png_ptr, info_ptr, &textPtr, nullptr);
+  for (png_uint_32 i = 0; i < nTextChunks; i++, textPtr++) {
+    png_size_t textLength = textPtr->text_length;
+    if ((textPtr->compression == PNG_ITXT_COMPRESSION_NONE) || (textPtr->compression == PNG_ITXT_COMPRESSION_zTXt)) {
+      textLength = textPtr->itxt_length;
+    }
+
+    if (!strcmp(textPtr->key, "XML:com.adobe.xmp")) {
+      if (textLength == 0) {
+        // TODO: error
+      }
+      else {
+        input_image->xmp.resize(textLength);
+        memcpy(input_image->xmp.data(), textPtr->text, textLength);
+      }
+    }
+  }
+#endif
+
+  int band = png_get_channels(png_ptr, info_ptr);
+
+  /* clean up after the read, and free any memory allocated - REQUIRED */
+  png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp) NULL);
+
+
+  struct heif_error err;
+
+  bool has_alpha = (band == 2 || band == 4);
+
+  if (band == 1 && bit_depth == 8) {
+    err = heif_image_create((int) width, (int) height,
+                            heif_colorspace_monochrome,
+                            heif_chroma_monochrome,
+                            &image);
+    (void) err;
+
+    heif_image_add_plane(image, heif_channel_Y, (int) width, (int) height, 8);
+
+    size_t y_stride;
+    size_t a_stride;
+    uint8_t* py = heif_image_get_plane2(image, heif_channel_Y, &y_stride);
+    uint8_t* pa = nullptr;
+
+    if (has_alpha) {
+      heif_image_add_plane(image, heif_channel_Alpha, (int) width, (int) height, 8);
+
+      pa = heif_image_get_plane2(image, heif_channel_Alpha, &a_stride);
+    }
+
+
+    for (uint32_t y = 0; y < height; y++) {
+      uint8_t* p = row_pointers[y];
+
+      if (has_alpha) {
+        for (uint32_t x = 0; x < width; x++) {
+          py[y * y_stride + x] = *p++;
+          pa[y * a_stride + x] = *p++;
+        }
+      }
+      else {
+        memcpy(&py[y * y_stride], p, width);
+      }
+    }
+  }
+  else if (band == 1) {
+    assert(bit_depth > 8);
+
+    err = heif_image_create((int) width, (int) height,
+                            heif_colorspace_monochrome,
+                            heif_chroma_monochrome,
+                            &image);
+    (void) err;
+
+    int bdShift = 16 - output_bit_depth;
+
+    heif_image_add_plane(image, heif_channel_Y, (int) width, (int) height, output_bit_depth);
+
+    size_t y_stride;
+    size_t a_stride = 0;
+    uint16_t* py = (uint16_t*) heif_image_get_plane2(image, heif_channel_Y, &y_stride);
+    uint16_t* pa = nullptr;
+
+    if (has_alpha) {
+      heif_image_add_plane(image, heif_channel_Alpha, (int) width, (int) height, output_bit_depth);
+
+      pa = (uint16_t*) heif_image_get_plane2(image, heif_channel_Alpha, &a_stride);
+    }
+
+    y_stride /= 2;
+    a_stride /= 2;
+
+    for (uint32_t y = 0; y < height; y++) {
+      uint8_t* p = row_pointers[y];
+
+      if (has_alpha) {
+        for (uint32_t x = 0; x < width; x++) {
+          uint16_t vp = (uint16_t) (((p[0] << 8) | p[1]) >> bdShift);
+          uint16_t va = (uint16_t) (((p[2] << 8) | p[3]) >> bdShift);
+
+          py[x + y * y_stride] = vp;
+          pa[x + y * y_stride] = va;
+
+          p += 4;
+        }
+      }
+      else {
+        for (uint32_t x = 0; x < width; x++) {
+          uint16_t vp = (uint16_t) (((p[0] << 8) | p[1]) >> bdShift);
+
+          py[x + y * y_stride] = vp;
+
+          p += 2;
+        }
+      }
+    }
+  }
+  else if (band == 2 && bit_depth==8) {
+    err = heif_image_create((int) width, (int) height,
+                            heif_colorspace_monochrome,
+                            heif_chroma_monochrome,
+                            &image);
+    (void) err;
+
+    heif_image_add_plane(image, heif_channel_Y, (int) width, (int) height, 8);
+    heif_image_add_plane(image, heif_channel_Alpha, (int) width, (int) height, 8);
+
+    size_t stride;
+    uint8_t* p = heif_image_get_plane2(image, heif_channel_Y, &stride);
+
+    size_t strideA;
+    uint8_t* pA = heif_image_get_plane2(image, heif_channel_Alpha, &strideA);
+
+    for (uint32_t y = 0; y < height; y++) {
+      for (uint32_t x = 0; x < width; x++) {
+        p[y * stride + x] = row_pointers[y][2 * x];
+        pA[y * strideA + x] = row_pointers[y][2 * x + 1];
+      }
+    }
+  }
+  else if (bit_depth == 8) {
+    err = heif_image_create((int) width, (int) height,
+                            heif_colorspace_RGB,
+                            has_alpha ? heif_chroma_interleaved_RGBA : heif_chroma_interleaved_RGB,
+                            &image);
+    (void) err;
+
+    heif_image_add_plane(image, heif_channel_interleaved, (int) width, (int) height,
+                         has_alpha ? 32 : 24);
+
+    size_t stride;
+    uint8_t* p = heif_image_get_plane2(image, heif_channel_interleaved, &stride);
+
+    for (uint32_t y = 0; y < height; y++) {
+      if (has_alpha) {
+        memcpy(p + y * stride, row_pointers[y], width * 4);
+      }
+      else {
+        memcpy(p + y * stride, row_pointers[y], width * 3);
+      }
+    }
+  }
+  else {
+    if (output_bit_depth == 8) {
+      err = heif_image_create((int) width, (int) height,
+                              heif_colorspace_RGB,
+                              has_alpha ?
+                              heif_chroma_interleaved_RGBA :
+                              heif_chroma_interleaved_RGB,
+                              &image);
+    }
+    else {
+      err = heif_image_create((int) width, (int) height,
+                              heif_colorspace_RGB,
+                              has_alpha ?
+                              heif_chroma_interleaved_RRGGBBAA_LE :
+                              heif_chroma_interleaved_RRGGBB_LE,
+                              &image);
+    }
+    (void) err;
+
+    int bdShift = 16 - output_bit_depth;
+
+    heif_image_add_plane(image, heif_channel_interleaved, (int) width, (int) height, output_bit_depth);
+
+    size_t stride;
+    uint8_t* p_out = (uint8_t*) heif_image_get_plane2(image, heif_channel_interleaved, &stride);
+
+    if (output_bit_depth==8) {
+      // convert HDR to SDR
+
+      for (uint32_t y = 0; y < height; y++) {
+        uint8_t* p = row_pointers[y];
+
+        uint32_t nVal = (has_alpha ? 4 : 3) * width;
+
+        for (uint32_t x = 0; x < nVal; x++) {
+          p_out[x + y * stride] = p[0];
+          p+=2;
+        }
+      }
+    }
+    else {
+      for (uint32_t y = 0; y < height; y++) {
+        uint8_t* p = row_pointers[y];
+
+        uint32_t nVal = (has_alpha ? 4 : 3) * width;
+
+        for (uint32_t x = 0; x < nVal; x++) {
+          uint16_t v = (uint16_t) (((p[0] << 8) | p[1]) >> bdShift);
+          p_out[2 * x + y * stride + 1] = (uint8_t) (v >> 8);
+          p_out[2 * x + y * stride + 0] = (uint8_t) (v & 0xFF);
+          p += 2;
+        }
+      }
+    }
+  }
+
+  if (profile_data && profile_length > 0) {
+    heif_image_set_raw_color_profile(image, "prof", profile_data, (size_t) profile_length);
+  }
+
+  free(profile_data);
+  for (uint32_t y = 0; y < height; y++) {
+    free(row_pointers[y]);
+  } // for
+
+  delete[] row_pointers;
+  fclose(fh);
+
+  input_image->image = std::shared_ptr<heif_image>(image,
+                                                  [](heif_image* img) { heif_image_release(img); });
+
+  return heif_error_ok;
+}
diff --git a/heifio/decoder_png.h b/heifio/decoder_png.h
new file mode 100644
index 0000000000..811df0d5be
--- /dev/null
+++ b/heifio/decoder_png.h
@@ -0,0 +1,35 @@
+/*
+  libheif example application "heif".
+
+  MIT License
+
+  Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#ifndef LIBHEIF_DECODER_PNG_H
+#define LIBHEIF_DECODER_PNG_H
+
+#include "decoder.h"
+
+LIBHEIF_API
+heif_error loadPNG(const char* filename, int output_bit_depth, InputImage *input_image);
+
+#endif //LIBHEIF_DECODER_PNG_H
diff --git a/heifio/decoder_raw.cc b/heifio/decoder_raw.cc
new file mode 100644
index 0000000000..4ee0cce420
--- /dev/null
+++ b/heifio/decoder_raw.cc
@@ -0,0 +1,220 @@
+/*
+  libheif example application "heif".
+
+  MIT License
+
+  Copyright (c) 2026 Dirk Farin <dirk.farin@gmail.com>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#include "decoder_raw.h"
+#include <libheif/heif.h>
+#include <libheif/heif_uncompressed.h>
+#include <bit>
+#include <cstdio>
+#include <cstring>
+#include <vector>
+#include <memory>
+#include <utility>
+
+static struct heif_error heif_error_ok = {heif_error_Ok, heif_suberror_Unspecified, "Success"};
+
+
+bool parse_raw_pixel_type(const std::string& type_string,
+                          heif_channel_datatype* out_datatype,
+                          int* out_bit_depth)
+{
+  if (type_string == "uint8") {
+    *out_datatype = heif_channel_datatype_unsigned_integer;
+    *out_bit_depth = 8;
+  }
+  else if (type_string == "sint8") {
+    *out_datatype = heif_channel_datatype_signed_integer;
+    *out_bit_depth = 8;
+  }
+  else if (type_string == "uint16") {
+    *out_datatype = heif_channel_datatype_unsigned_integer;
+    *out_bit_depth = 16;
+  }
+  else if (type_string == "sint16") {
+    *out_datatype = heif_channel_datatype_signed_integer;
+    *out_bit_depth = 16;
+  }
+  else if (type_string == "uint32") {
+    *out_datatype = heif_channel_datatype_unsigned_integer;
+    *out_bit_depth = 32;
+  }
+  else if (type_string == "sint32") {
+    *out_datatype = heif_channel_datatype_signed_integer;
+    *out_bit_depth = 32;
+  }
+  else if (type_string == "float32") {
+    *out_datatype = heif_channel_datatype_floating_point;
+    *out_bit_depth = 32;
+  }
+  else if (type_string == "float64") {
+    *out_datatype = heif_channel_datatype_floating_point;
+    *out_bit_depth = 64;
+  }
+  else {
+    return false;
+  }
+  return true;
+}
+
+
+static void byte_swap_buffer(uint8_t* data, size_t num_elements, int bytes_per_element)
+{
+  for (size_t i = 0; i < num_elements; i++) {
+    uint8_t* elem = data + i * bytes_per_element;
+    for (int lo = 0, hi = bytes_per_element - 1; lo < hi; lo++, hi--) {
+      std::swap(elem[lo], elem[hi]);
+    }
+  }
+}
+
+
+heif_error loadRAW(const char* filename, const RawImageParameters& params, InputImage* input_image)
+{
+  if (params.width < 0 || params.height < 0) {
+    return {heif_error_Invalid_input, heif_suberror_Unspecified,
+            "Raw image width and height must not be negative"};
+  }
+
+  if (params.width == 0 && params.height == 0) {
+    return {heif_error_Invalid_input, heif_suberror_Unspecified,
+            "At least one of --raw-width or --raw-height must be specified"};
+  }
+
+  if (params.datatype == heif_channel_datatype_undefined || params.bit_depth <= 0) {
+    return {heif_error_Invalid_input, heif_suberror_Unspecified,
+            "Raw image pixel type must be specified (use --raw-type)"};
+  }
+
+  int bytes_per_pixel = params.bit_depth / 8;
+
+  // Open file and get size
+  FILE* fp = fopen(filename, "rb");
+  if (!fp) {
+    return {heif_error_Invalid_input, heif_suberror_Unspecified,
+            "Cannot open raw input file"};
+  }
+
+  fseek(fp, 0, SEEK_END);
+  long file_size = ftell(fp);
+  fseek(fp, 0, SEEK_SET);
+
+  if (file_size <= 0) {
+    fclose(fp);
+    return {heif_error_Invalid_input, heif_suberror_Unspecified,
+            "Raw input file is empty or unreadable"};
+  }
+
+  // Compute missing dimension from file size
+  int width = params.width;
+  int height = params.height;
+
+  if (width == 0) {
+    size_t row_bytes = static_cast<size_t>(height) * bytes_per_pixel;
+    if (static_cast<size_t>(file_size) % row_bytes != 0) {
+      fclose(fp);
+      return {heif_error_Invalid_input, heif_suberror_Unspecified,
+              "Raw file size is not divisible by height * bytes_per_pixel"};
+    }
+    width = static_cast<int>(static_cast<size_t>(file_size) / row_bytes);
+  }
+  else if (height == 0) {
+    size_t row_bytes = static_cast<size_t>(width) * bytes_per_pixel;
+    if (static_cast<size_t>(file_size) % row_bytes != 0) {
+      fclose(fp);
+      return {heif_error_Invalid_input, heif_suberror_Unspecified,
+              "Raw file size is not divisible by width * bytes_per_pixel"};
+    }
+    height = static_cast<int>(static_cast<size_t>(file_size) / row_bytes);
+  }
+
+  size_t expected_size = static_cast<size_t>(width) * height * bytes_per_pixel;
+
+  if (static_cast<size_t>(file_size) != expected_size) {
+    fclose(fp);
+    return {heif_error_Invalid_input, heif_suberror_Unspecified,
+            "Raw file size does not match width * height * bytes_per_pixel"};
+  }
+
+  // Read entire file
+  std::vector<uint8_t> buffer(expected_size);
+  size_t n = fread(buffer.data(), 1, expected_size, fp);
+  fclose(fp);
+
+  if (n != expected_size) {
+    return {heif_error_Invalid_input, heif_suberror_Unspecified,
+            "Failed to read raw input file"};
+  }
+
+  // Byte-swap from big-endian to host byte order if needed
+  if (params.big_endian && bytes_per_pixel > 1) {
+    if constexpr (std::endian::native == std::endian::little) {
+      byte_swap_buffer(buffer.data(), static_cast<size_t>(width) * height, bytes_per_pixel);
+    }
+  }
+
+  // Create image with nonvisual colorspace for typed component API
+  struct heif_image* image = nullptr;
+  heif_error err = heif_image_create(width, height,
+                                     heif_colorspace_nonvisual,
+                                     heif_chroma_undefined,
+                                     &image);
+  if (err.code != heif_error_Ok) {
+    return err;
+  }
+
+  uint32_t component_idx = 0;
+  err = heif_image_add_component(image, width, height,
+                                 heif_uncompressed_component_type_monochrome,
+                                 params.datatype, params.bit_depth,
+                                 &component_idx);
+  if (err.code != heif_error_Ok) {
+    heif_image_release(image);
+    return err;
+  }
+
+  // Get writable pointer and copy data row by row
+  size_t stride = 0;
+  uint8_t* plane = heif_image_get_component(image, component_idx, &stride);
+  if (!plane) {
+    heif_image_release(image);
+    return {heif_error_Invalid_input, heif_suberror_Unspecified,
+            "Failed to get component plane from image"};
+  }
+
+  size_t row_bytes = static_cast<size_t>(width) * bytes_per_pixel;
+  size_t stride_bytes = stride;
+
+  for (int y = 0; y < height; y++) {
+    memcpy(plane + y * stride_bytes,
+           buffer.data() + y * row_bytes,
+           row_bytes);
+  }
+
+  input_image->image = std::shared_ptr<heif_image>(image,
+                                                    [](heif_image* img) { heif_image_release(img); });
+
+  return heif_error_ok;
+}
diff --git a/heifio/decoder_raw.h b/heifio/decoder_raw.h
new file mode 100644
index 0000000000..b272e67d0e
--- /dev/null
+++ b/heifio/decoder_raw.h
@@ -0,0 +1,51 @@
+/*
+  libheif example application "heif".
+
+  MIT License
+
+  Copyright (c) 2026 Dirk Farin <dirk.farin@gmail.com>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#ifndef LIBHEIF_DECODER_RAW_H
+#define LIBHEIF_DECODER_RAW_H
+
+#include "decoder.h"
+#include <libheif/heif_uncompressed_types.h>
+#include <string>
+
+struct RawImageParameters {
+  int width = 0;
+  int height = 0;
+  heif_channel_datatype datatype = heif_channel_datatype_undefined;
+  int bit_depth = 0;
+  bool big_endian = false;
+};
+
+// Maps a CLI string like "uint16" or "float32" to datatype + bit_depth.
+// Returns false if the string is not recognized.
+bool parse_raw_pixel_type(const std::string& type_string,
+                          heif_channel_datatype* out_datatype,
+                          int* out_bit_depth);
+
+LIBHEIF_API
+heif_error loadRAW(const char* filename, const RawImageParameters& params, InputImage* input_image);
+
+#endif //LIBHEIF_DECODER_RAW_H
diff --git a/heifio/decoder_tiff.cc b/heifio/decoder_tiff.cc
new file mode 100644
index 0000000000..f37464b13c
--- /dev/null
+++ b/heifio/decoder_tiff.cc
@@ -0,0 +1,1944 @@
+/*
+  libheif example application "heif".
+
+  MIT License
+
+  Copyright (c) 2024 Joachim Bauch <bauch@struktur.de>
+  Copyright (c) 2026 Dirk Farin <dirk.farin@gmail.com>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#include <cstring>
+#include <memory>
+#include <utility>
+#include <vector>
+#include <algorithm>
+#include <limits>
+
+extern "C" {
+#include <tiff.h>
+#include <tiffio.h>
+}
+
+#if HAVE_GEOTIFF
+#include <geotiff/geotiff.h>
+#include <geotiff/geotiffio.h>
+#include <geotiff/geo_normalize.h>
+#include <geotiff/xtiffio.h>
+#endif
+
+#include "decoder_tiff.h"
+#include "libheif/heif_uncompressed.h"
+
+static heif_error heif_error_ok = {heif_error_Ok, heif_suberror_Unspecified, "Success"};
+
+// Forward declarations for YCbCr helpers (defined after validateTiffFormat)
+static YCbCrInfo getYCbCrInfo(TIFF* tif);
+static heif_chroma ycbcrChroma(const YCbCrInfo& ycbcr);
+static void deinterleaveYCbCr(const uint8_t* src, uint32_t block_w, uint32_t block_h,
+                              uint32_t actual_w, uint32_t actual_h,
+                              uint16_t horiz_sub, uint16_t vert_sub,
+                              uint8_t* y_plane, size_t y_stride,
+                              uint8_t* cb_plane, size_t cb_stride,
+                              uint8_t* cr_plane, size_t cr_stride);
+
+// Forward declarations for YCbCr helpers (defined after validateTiffFormat)
+static YCbCrInfo getYCbCrInfo(TIFF* tif);
+static heif_chroma ycbcrChroma(const YCbCrInfo& ycbcr);
+static void deinterleaveYCbCr(const uint8_t* src, uint32_t block_w, uint32_t block_h,
+                              uint32_t actual_w, uint32_t actual_h,
+                              uint16_t horiz_sub, uint16_t vert_sub,
+                              uint8_t* y_plane, size_t y_stride,
+                              uint8_t* cb_plane, size_t cb_stride,
+                              uint8_t* cr_plane, size_t cr_stride);
+
+static bool seekTIFF(TIFF* tif, toff_t offset, int whence) {
+  TIFFSeekProc seekProc = TIFFGetSeekProc(tif);
+  if (!seekProc) {
+    return false;
+  }
+
+  thandle_t handle = TIFFClientdata(tif);
+  if (!handle) {
+    return false;
+  }
+
+  return seekProc(handle, offset, whence) != static_cast<toff_t>(-1);
+}
+
+static bool readTIFF(TIFF* tif, void* dest, size_t size) {
+  TIFFReadWriteProc readProc = TIFFGetReadProc(tif);
+  if (!readProc) {
+    return false;
+  }
+
+  thandle_t handle = TIFFClientdata(tif);
+  if (!handle) {
+    return false;
+  }
+
+  tmsize_t result = readProc(handle, dest, size);
+  if (result < 0 || static_cast<size_t>(result) != size) {
+    return false;
+  }
+
+  return true;
+}
+
+static bool readTIFFUint16(TIFF* tif, uint16_t* dest) {
+  if (!readTIFF(tif, dest, 2)) {
+    return false;
+  }
+
+  if (TIFFIsByteSwapped(tif)) {
+    TIFFSwabShort(dest);
+  }
+  return true;
+}
+
+static bool readTIFFUint32(TIFF* tif, uint32_t* dest) {
+  if (!readTIFF(tif, dest, 4)) {
+    return false;
+  }
+
+  if (TIFFIsByteSwapped(tif)) {
+    TIFFSwabLong(dest);
+  }
+  return true;
+}
+
+class ExifTags {
+ public:
+  ~ExifTags() = default;
+
+  void Encode(std::vector<uint8_t>* dest);
+
+  static std::unique_ptr<ExifTags> Parse(TIFF* tif);
+
+ private:
+  class Tag {
+   public:
+    uint16_t tag;
+    uint16_t type;
+    uint32_t len;
+
+    uint32_t offset;
+    std::vector<uint8_t> data;
+  };
+
+  ExifTags(uint16_t count);
+  void writeUint16(std::vector<uint8_t>* dest, uint16_t value);
+  void writeUint32(std::vector<uint8_t>* dest, uint32_t value);
+  void writeUint32(std::vector<uint8_t>* dest, size_t pos, uint32_t value);
+  void writeData(std::vector<uint8_t>* dest, const std::vector<uint8_t>& value);
+
+  std::vector<std::unique_ptr<Tag>> tags_;
+};
+
+ExifTags::ExifTags(uint16_t count) {
+  tags_.reserve(count);
+}
+
+// static
+std::unique_ptr<ExifTags> ExifTags::Parse(TIFF* tif) {
+  toff_t exif_offset;
+  if (!TIFFGetField(tif, TIFFTAG_EXIFIFD, &exif_offset)) {
+    // Image doesn't contain EXIF data.
+    return nullptr;
+  }
+
+  if (!seekTIFF(tif, exif_offset, SEEK_SET)) {
+    return nullptr;
+  }
+
+  uint16_t count;
+  if (!readTIFFUint16(tif, &count)) {
+    return nullptr;
+  }
+
+  if (count == 0) {
+    return nullptr;
+  }
+
+  std::unique_ptr<ExifTags> tags(new ExifTags(count));
+  for (uint16_t i = 0; i < count; i++) {
+    std::unique_ptr<Tag> tag(new Tag());
+    if (!readTIFFUint16(tif, &tag->tag)) {
+      return nullptr;
+    }
+
+    if (!readTIFFUint16(tif, &tag->type) || tag->type > TIFF_IFD8) {
+      return nullptr;
+    }
+
+    if (TIFFDataWidth(static_cast<TIFFDataType>(tag->type)) == 0) {
+      return nullptr;
+    }
+
+    if (!readTIFFUint32(tif, &tag->len)) {
+      return nullptr;
+    }
+
+    if (!readTIFFUint32(tif, &tag->offset)) {
+      return nullptr;
+    }
+
+    tags->tags_.push_back(std::move(tag));
+  }
+
+  for (const auto& tag : tags->tags_) {
+    size_t size = tag->len * TIFFDataWidth(static_cast<TIFFDataType>(tag->type));
+    if (size <= 4) {
+      continue;
+    }
+
+    if (!seekTIFF(tif, tag->offset, SEEK_SET)) {
+      return nullptr;
+    }
+
+    tag->data.resize(size);
+    if (!readTIFF(tif, tag->data.data(), size)) {
+      return nullptr;
+    }
+  }
+
+  return tags;
+}
+
+void ExifTags::writeUint16(std::vector<uint8_t>* dest, uint16_t value) {
+  dest->resize(dest->size() + sizeof(value));
+  void* d = dest->data() + dest->size() - sizeof(value);
+  memcpy(d, &value, sizeof(value));
+}
+
+void ExifTags::writeUint32(std::vector<uint8_t>* dest, uint32_t value) {
+  dest->resize(dest->size() + sizeof(value));
+  writeUint32(dest, dest->size() - sizeof(value), value);
+}
+
+void ExifTags::writeUint32(std::vector<uint8_t>* dest, size_t pos, uint32_t value) {
+  void* d = dest->data() + pos;
+  memcpy(d, &value, sizeof(value));
+}
+
+void ExifTags::writeData(std::vector<uint8_t>* dest, const std::vector<uint8_t>& value) {
+  dest->resize(dest->size() + value.size());
+  void* d = dest->data() + dest->size() - value.size();
+  memcpy(d, value.data(), value.size());
+}
+
+void ExifTags::Encode(std::vector<uint8_t>* dest) {
+  if (tags_.empty()) {
+    return;
+  }
+
+#if HOST_BIGENDIAN
+  dest->push_back('M');
+  dest->push_back('M');
+#else
+  dest->push_back('I');
+  dest->push_back('I');
+#endif
+  writeUint16(dest, 42);
+  // Offset of IFD0.
+  writeUint32(dest, 8);
+
+  writeUint16(dest, static_cast<uint16_t>(tags_.size()));
+  for (const auto& tag : tags_) {
+    writeUint16(dest, tag->tag);
+    writeUint16(dest, tag->type);
+    writeUint32(dest, tag->len);
+    writeUint32(dest, tag->offset);
+  }
+  // No IFD1 dictionary.
+  writeUint32(dest, 0);
+
+  // Update offsets of tags that have their data stored separately.
+  for (size_t i = 0; i < tags_.size(); i++) {
+    const auto& tag = tags_[i];
+    size_t size = tag->data.size();
+    if (size <= 4) {
+      continue;
+    }
+
+    // StartOfTags + (TagIndex * sizeof(Tag)) + OffsetOfTagData
+    size_t pos = 10 + (i * 12) + 8;
+    size_t offset = dest->size();
+    writeUint32(dest, pos, static_cast<uint32_t>(offset));
+    writeData(dest, tag->data);
+  }
+}
+
+static heif_chroma get_heif_chroma(uint16_t outSpp, int output_bit_depth)
+{
+  if (outSpp == 1) {
+    return heif_chroma_monochrome;
+  }
+  if (output_bit_depth > 8) {
+#if IS_BIG_ENDIAN
+    return (outSpp == 4) ? heif_chroma_interleaved_RRGGBBAA_BE : heif_chroma_interleaved_RRGGBB_BE;
+#else
+    return (outSpp == 4) ? heif_chroma_interleaved_RRGGBBAA_LE : heif_chroma_interleaved_RRGGBB_LE;
+#endif
+  }
+  return (outSpp == 4) ? heif_chroma_interleaved_RGBA : heif_chroma_interleaved_RGB;
+}
+
+
+heif_error getImageWidthAndHeight(TIFF *tif, uint32_t &width, uint32_t &height)
+{
+  if (!TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &width) ||
+      !TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &height))
+  {
+    struct heif_error err = {
+      .code = heif_error_Invalid_input,
+      .subcode = heif_suberror_Unspecified,
+      .message = "Can not read width and/or height from TIFF image."};
+    return err;
+  }
+
+  if (width == 0 || height == 0) {
+    return {heif_error_Invalid_input, heif_suberror_Unspecified, "Zero TIFF image size is invalid."};
+  }
+
+  return heif_error_ok;
+}
+
+heif_error readMono(TIFF *tif, uint16_t bps, int output_bit_depth, heif_image **image)
+{
+  uint32_t width, height;
+  heif_error err = getImageWidthAndHeight(tif, width, height);
+  if (err.code != heif_error_Ok) {
+    return err;
+  }
+  err = heif_image_create((int) width, (int) height, heif_colorspace_monochrome, heif_chroma_monochrome, image);
+  if (err.code != heif_error_Ok) {
+    return err;
+  }
+
+  if (bps <= 8) {
+    heif_image_add_plane(*image, heif_channel_Y, (int)width, (int)height, 8);
+
+    size_t y_stride;
+    uint8_t *py = heif_image_get_plane2(*image, heif_channel_Y, &y_stride);
+    for (uint32_t row = 0; row < height; row++) {
+      if (TIFFReadScanline(tif, py, row, 0) < 0) {
+        heif_image_release(*image);
+        *image = nullptr;
+        return {heif_error_Invalid_input, heif_suberror_Unspecified, "Failed to read TIFF scanline"};
+      }
+      py += y_stride;
+    }
+  }
+  else {
+    heif_image_add_plane(*image, heif_channel_Y, (int)width, (int)height, output_bit_depth);
+
+    size_t y_stride;
+    uint8_t *py = heif_image_get_plane2(*image, heif_channel_Y, &y_stride);
+    int bdShift = 16 - output_bit_depth;
+    tdata_t buf = _TIFFmalloc(TIFFScanlineSize(tif));
+
+    if (output_bit_depth <= 8) {
+      for (uint32_t row = 0; row < height; row++) {
+        if (TIFFReadScanline(tif, buf, row, 0) < 0) {
+          _TIFFfree(buf);
+          heif_image_release(*image);
+          *image = nullptr;
+          return {heif_error_Invalid_input, heif_suberror_Unspecified, "Failed to read TIFF scanline"};
+        }
+        uint16_t* src = static_cast<uint16_t*>(buf);
+        uint8_t* dst = py + row * y_stride;
+        for (uint32_t x = 0; x < width; x++) {
+          dst[x] = static_cast<uint8_t>(src[x] >> 8);
+        }
+      }
+    }
+    else {
+      for (uint32_t row = 0; row < height; row++) {
+        if (TIFFReadScanline(tif, buf, row, 0) < 0) {
+          _TIFFfree(buf);
+          heif_image_release(*image);
+          *image = nullptr;
+          return {heif_error_Invalid_input, heif_suberror_Unspecified, "Failed to read TIFF scanline"};
+        }
+        uint16_t* src = static_cast<uint16_t*>(buf);
+        uint16_t* dst = reinterpret_cast<uint16_t*>(py + row * y_stride);
+        for (uint32_t x = 0; x < width; x++) {
+          dst[x] = static_cast<uint16_t>(src[x] >> bdShift);
+        }
+      }
+    }
+    _TIFFfree(buf);
+  }
+  return heif_error_ok;
+}
+
+heif_error readPixelInterleaveRGB(TIFF *tif, uint16_t samplesPerPixel, bool hasAlpha, uint16_t bps, int output_bit_depth, heif_image **image)
+{
+  uint32_t width, height;
+  heif_error err = getImageWidthAndHeight(tif, width, height);
+  if (err.code != heif_error_Ok) {
+    return err;
+  }
+
+  // --- YCbCr strip path: TIFFReadScanline doesn't work with packed YCbCr ---
+  YCbCrInfo ycbcr = getYCbCrInfo(tif);
+  if (ycbcr.is_ycbcr) {
+    if (bps != 8) {
+      return {heif_error_Unsupported_feature, heif_suberror_Unspecified,
+              "Only 8-bit YCbCr TIFF is supported."};
+    }
+
+    heif_chroma chroma = ycbcrChroma(ycbcr);
+    err = heif_image_create((int)width, (int)height, heif_colorspace_YCbCr, chroma, image);
+    if (err.code != heif_error_Ok) return err;
+
+    heif_image_add_plane(*image, heif_channel_Y, (int)width, (int)height, 8);
+    uint32_t chroma_w = (width + ycbcr.horiz_sub - 1) / ycbcr.horiz_sub;
+    uint32_t chroma_h = (height + ycbcr.vert_sub - 1) / ycbcr.vert_sub;
+    heif_image_add_plane(*image, heif_channel_Cb, (int)chroma_w, (int)chroma_h, 8);
+    heif_image_add_plane(*image, heif_channel_Cr, (int)chroma_w, (int)chroma_h, 8);
+
+    size_t y_stride, cb_stride, cr_stride;
+    uint8_t* y_plane = heif_image_get_plane2(*image, heif_channel_Y, &y_stride);
+    uint8_t* cb_plane = heif_image_get_plane2(*image, heif_channel_Cb, &cb_stride);
+    uint8_t* cr_plane = heif_image_get_plane2(*image, heif_channel_Cr, &cr_stride);
+
+    uint32_t rows_per_strip = 0;
+    TIFFGetFieldDefaulted(tif, TIFFTAG_ROWSPERSTRIP, &rows_per_strip);
+    if (rows_per_strip == 0) rows_per_strip = height;
+
+    tmsize_t strip_size = TIFFStripSize(tif);
+    std::vector<uint8_t> strip_buf(strip_size);
+
+    uint32_t n_strips = TIFFNumberOfStrips(tif);
+    for (uint32_t s = 0; s < n_strips; s++) {
+      tmsize_t read = TIFFReadEncodedStrip(tif, s, strip_buf.data(), strip_size);
+      if (read < 0) {
+        heif_image_release(*image);
+        *image = nullptr;
+        return {heif_error_Invalid_input, heif_suberror_Unspecified, "Failed to read TIFF strip"};
+      }
+
+      uint32_t strip_y = s * rows_per_strip;
+      uint32_t actual_h = std::min(rows_per_strip, height - strip_y);
+      // Packed YCbCr block dimensions must be multiples of subsampling factors
+      uint32_t block_w = ((width + ycbcr.horiz_sub - 1) / ycbcr.horiz_sub) * ycbcr.horiz_sub;
+      uint32_t block_h = ((actual_h + ycbcr.vert_sub - 1) / ycbcr.vert_sub) * ycbcr.vert_sub;
+
+      deinterleaveYCbCr(strip_buf.data(), block_w, block_h, width, actual_h,
+                        ycbcr.horiz_sub, ycbcr.vert_sub,
+                        y_plane + strip_y * y_stride, y_stride,
+                        cb_plane + (strip_y / ycbcr.vert_sub) * cb_stride, cb_stride,
+                        cr_plane + (strip_y / ycbcr.vert_sub) * cr_stride, cr_stride);
+    }
+
+    return heif_error_ok;
+  }
+
+  uint16_t outSpp = (samplesPerPixel == 4 && !hasAlpha) ? 3 : samplesPerPixel;
+
+  if (bps <= 8) {
+    heif_chroma chroma = get_heif_chroma(outSpp, 8);
+    err = heif_image_create((int)width, (int)height, heif_colorspace_RGB, chroma, image);
+    if (err.code != heif_error_Ok) {
+      return err;
+    }
+    heif_channel channel = heif_channel_interleaved;
+    heif_image_add_plane(*image, channel, (int)width, (int)height, outSpp * 8);
+
+    size_t y_stride;
+    uint8_t *py = heif_image_get_plane2(*image, channel, &y_stride);
+    tdata_t buf = _TIFFmalloc(TIFFScanlineSize(tif));
+    for (uint32_t row = 0; row < height; row++) {
+      if (TIFFReadScanline(tif, buf, row, 0) < 0) {
+        _TIFFfree(buf);
+        heif_image_release(*image);
+        *image = nullptr;
+        return {heif_error_Invalid_input, heif_suberror_Unspecified, "Failed to read TIFF scanline"};
+      }
+      uint8_t* src = static_cast<uint8_t*>(buf);
+      if (outSpp == samplesPerPixel) {
+        memcpy(py, src, width * outSpp);
+      }
+      else {
+        for (uint32_t x = 0; x < width; x++) {
+          memcpy(py + x * outSpp, src + x * samplesPerPixel, outSpp);
+        }
+      }
+      py += y_stride;
+    }
+    _TIFFfree(buf);
+  }
+  else {
+    heif_chroma chroma = get_heif_chroma(outSpp, output_bit_depth);
+    err = heif_image_create((int)width, (int)height, heif_colorspace_RGB, chroma, image);
+    if (err.code != heif_error_Ok) {
+      return err;
+    }
+    heif_channel channel = heif_channel_interleaved;
+    int planeBitDepth = (output_bit_depth <= 8) ? outSpp * 8 : output_bit_depth;
+    heif_image_add_plane(*image, channel, (int)width, (int)height, planeBitDepth);
+
+    size_t y_stride;
+    uint8_t *py = heif_image_get_plane2(*image, channel, &y_stride);
+    int bdShift = 16 - output_bit_depth;
+    tdata_t buf = _TIFFmalloc(TIFFScanlineSize(tif));
+
+    if (output_bit_depth <= 8) {
+      for (uint32_t row = 0; row < height; row++) {
+        if (TIFFReadScanline(tif, buf, row, 0) < 0) {
+          _TIFFfree(buf);
+          heif_image_release(*image);
+          *image = nullptr;
+          return {heif_error_Invalid_input, heif_suberror_Unspecified, "Failed to read TIFF scanline"};
+        }
+        uint16_t* src = static_cast<uint16_t*>(buf);
+        uint8_t* dst = py + row * y_stride;
+        if (outSpp == samplesPerPixel) {
+          for (uint32_t x = 0; x < width * outSpp; x++) {
+            dst[x] = static_cast<uint8_t>(src[x] >> 8);
+          }
+        }
+        else {
+          for (uint32_t x = 0; x < width; x++) {
+            for (uint16_t c = 0; c < outSpp; c++) {
+              dst[x * outSpp + c] = static_cast<uint8_t>(src[x * samplesPerPixel + c] >> 8);
+            }
+          }
+        }
+      }
+    }
+    else {
+      for (uint32_t row = 0; row < height; row++) {
+        if (TIFFReadScanline(tif, buf, row, 0) < 0) {
+          _TIFFfree(buf);
+          heif_image_release(*image);
+          *image = nullptr;
+          return {heif_error_Invalid_input, heif_suberror_Unspecified, "Failed to read TIFF scanline"};
+        }
+        uint16_t* src = static_cast<uint16_t*>(buf);
+        uint16_t* dst = reinterpret_cast<uint16_t*>(py + row * y_stride);
+        if (outSpp == samplesPerPixel) {
+          for (uint32_t x = 0; x < width * outSpp; x++) {
+            dst[x] = static_cast<uint16_t>(src[x] >> bdShift);
+          }
+        }
+        else {
+          for (uint32_t x = 0; x < width; x++) {
+            for (uint16_t c = 0; c < outSpp; c++) {
+              dst[x * outSpp + c] = static_cast<uint16_t>(src[x * samplesPerPixel + c] >> bdShift);
+            }
+          }
+        }
+      }
+    }
+    _TIFFfree(buf);
+  }
+  return heif_error_ok;
+}
+
+heif_error readPixelInterleave(TIFF *tif, uint16_t samplesPerPixel, bool hasAlpha, uint16_t bps, int output_bit_depth, heif_image **image)
+{
+  if (samplesPerPixel == 1) {
+    return readMono(tif, bps, output_bit_depth, image);
+  } else {
+    return readPixelInterleaveRGB(tif, samplesPerPixel, hasAlpha, bps, output_bit_depth, image);
+  }
+}
+
+heif_error readBandInterleaveRGB(TIFF *tif, uint16_t samplesPerPixel, bool hasAlpha, uint16_t bps, int output_bit_depth, heif_image **image)
+{
+  uint32_t width, height;
+  heif_error err = getImageWidthAndHeight(tif, width, height);
+  if (err.code != heif_error_Ok) {
+    return err;
+  }
+
+  uint16_t outSpp = (samplesPerPixel == 4 && !hasAlpha) ? 3 : samplesPerPixel;
+
+  if (bps <= 8) {
+    heif_chroma chroma = get_heif_chroma(outSpp, 8);
+    err = heif_image_create((int)width, (int)height, heif_colorspace_RGB, chroma, image);
+    if (err.code != heif_error_Ok) {
+      return err;
+    }
+    heif_channel channel = heif_channel_interleaved;
+    heif_image_add_plane(*image, channel, (int)width, (int)height, outSpp * 8);
+
+    size_t y_stride;
+    uint8_t *py = heif_image_get_plane2(*image, channel, &y_stride);
+
+    uint8_t *buf = static_cast<uint8_t *>(_TIFFmalloc(TIFFScanlineSize(tif)));
+    for (uint16_t i = 0; i < outSpp; i++) {
+      uint8_t *dest = py + i;
+      for (uint32_t row = 0; row < height; row++) {
+        if (TIFFReadScanline(tif, buf, row, i) < 0) {
+          _TIFFfree(buf);
+          heif_image_release(*image);
+          *image = nullptr;
+          return {heif_error_Invalid_input, heif_suberror_Unspecified, "Failed to read TIFF scanline"};
+        }
+        for (uint32_t x = 0; x < width; x++, dest += outSpp) {
+          *dest = buf[x];
+        }
+        dest += (y_stride - width * outSpp);
+      }
+    }
+    _TIFFfree(buf);
+  }
+  else {
+    heif_chroma chroma = get_heif_chroma(outSpp, output_bit_depth);
+    err = heif_image_create((int)width, (int)height, heif_colorspace_RGB, chroma, image);
+    if (err.code != heif_error_Ok) {
+      return err;
+    }
+    heif_channel channel = heif_channel_interleaved;
+    int planeBitDepth = (output_bit_depth <= 8) ? outSpp * 8 : output_bit_depth;
+    heif_image_add_plane(*image, channel, (int)width, (int)height, planeBitDepth);
+
+    size_t y_stride;
+    uint8_t *py = heif_image_get_plane2(*image, channel, &y_stride);
+    int bdShift = 16 - output_bit_depth;
+    uint8_t *buf = static_cast<uint8_t *>(_TIFFmalloc(TIFFScanlineSize(tif)));
+
+    if (output_bit_depth <= 8) {
+      for (uint16_t i = 0; i < outSpp; i++) {
+        for (uint32_t row = 0; row < height; row++) {
+          if (TIFFReadScanline(tif, buf, row, i) < 0) {
+            _TIFFfree(buf);
+            heif_image_release(*image);
+            *image = nullptr;
+            return {heif_error_Invalid_input, heif_suberror_Unspecified, "Failed to read TIFF scanline"};
+          }
+          uint16_t* src = reinterpret_cast<uint16_t*>(buf);
+          uint8_t* dst = py + row * y_stride + i;
+          for (uint32_t x = 0; x < width; x++) {
+            dst[x * outSpp] = static_cast<uint8_t>(src[x] >> 8);
+          }
+        }
+      }
+    }
+    else {
+      for (uint16_t i = 0; i < outSpp; i++) {
+        for (uint32_t row = 0; row < height; row++) {
+          if (TIFFReadScanline(tif, buf, row, i) < 0) {
+            _TIFFfree(buf);
+            heif_image_release(*image);
+            *image = nullptr;
+            return {heif_error_Invalid_input, heif_suberror_Unspecified, "Failed to read TIFF scanline"};
+          }
+          uint16_t* src = reinterpret_cast<uint16_t*>(buf);
+          uint16_t* dst = reinterpret_cast<uint16_t*>(py + row * y_stride);
+          for (uint32_t x = 0; x < width; x++) {
+            dst[x * outSpp + i] = static_cast<uint16_t>(src[x] >> bdShift);
+          }
+        }
+      }
+    }
+    _TIFFfree(buf);
+  }
+  return heif_error_ok;
+}
+
+
+heif_error readBandInterleave(TIFF *tif, uint16_t samplesPerPixel, bool hasAlpha, uint16_t bps, int output_bit_depth, heif_image **image)
+{
+  if (samplesPerPixel == 1) {
+    return readMono(tif, bps, output_bit_depth, image);
+  } else if (samplesPerPixel == 3) {
+    return readBandInterleaveRGB(tif, samplesPerPixel, hasAlpha, bps, output_bit_depth, image);
+  } else if (samplesPerPixel == 4) {
+    return readBandInterleaveRGB(tif, samplesPerPixel, hasAlpha, bps, output_bit_depth, image);
+  } else {
+    struct heif_error err = {
+      .code = heif_error_Unsupported_feature,
+      .subcode = heif_suberror_Unspecified,
+      .message = "Only 1, 3 and 4 bands are supported"};
+    return err;
+  }
+}
+
+
+#if WITH_UNCOMPRESSED_CODEC
+static heif_error readMonoFloat(TIFF* tif, heif_image** image)
+{
+  uint32_t width, height;
+  heif_error err = getImageWidthAndHeight(tif, width, height);
+  if (err.code != heif_error_Ok) {
+    return err;
+  }
+
+  err = heif_image_create((int)width, (int)height, heif_colorspace_nonvisual, heif_chroma_undefined, image);
+  if (err.code != heif_error_Ok) {
+    return err;
+  }
+
+  uint32_t component_idx;
+  err = heif_image_add_component(*image, (int)width, (int)height,
+                                 heif_uncompressed_component_type_monochrome,
+                                 heif_channel_datatype_floating_point, 32, &component_idx);
+  if (err.code != heif_error_Ok) {
+    heif_image_release(*image);
+    *image = nullptr;
+    return err;
+  }
+
+  size_t stride;
+  float* plane = heif_image_get_component_float32(*image, component_idx, &stride);
+  if (!plane) {
+    heif_image_release(*image);
+    *image = nullptr;
+    return {heif_error_Memory_allocation_error, heif_suberror_Unspecified, "Failed to get float plane"};
+  }
+
+  tdata_t buf = _TIFFmalloc(TIFFScanlineSize(tif));
+  for (uint32_t row = 0; row < height; row++) {
+    if (TIFFReadScanline(tif, buf, row, 0) < 0) {
+      _TIFFfree(buf);
+      heif_image_release(*image);
+      *image = nullptr;
+      return {heif_error_Invalid_input, heif_suberror_Unspecified, "Failed to read TIFF scanline"};
+    }
+    memcpy(reinterpret_cast<uint8_t*>(plane) + row * stride, buf, width * sizeof(float));
+  }
+  _TIFFfree(buf);
+
+  return heif_error_ok;
+}
+
+
+static heif_error readMonoSignedInt(TIFF* tif, uint16_t bps, heif_image** image)
+{
+  uint32_t width, height;
+  heif_error err = getImageWidthAndHeight(tif, width, height);
+  if (err.code != heif_error_Ok) {
+    return err;
+  }
+
+  err = heif_image_create((int)width, (int)height, heif_colorspace_nonvisual, heif_chroma_undefined, image);
+  if (err.code != heif_error_Ok) {
+    return err;
+  }
+
+  uint32_t component_idx;
+  err = heif_image_add_component(*image, (int)width, (int)height,
+                                 heif_uncompressed_component_type_monochrome,
+                                 heif_channel_datatype_signed_integer, bps, &component_idx);
+  if (err.code != heif_error_Ok) {
+    heif_image_release(*image);
+    *image = nullptr;
+    return err;
+  }
+
+  size_t stride;
+  uint8_t* plane;
+  if (bps == 8) {
+    plane = reinterpret_cast<uint8_t*>(heif_image_get_component_int8(*image, component_idx, &stride));
+  }
+  else {
+    plane = reinterpret_cast<uint8_t*>(heif_image_get_component_int16(*image, component_idx, &stride));
+  }
+  if (!plane) {
+    heif_image_release(*image);
+    *image = nullptr;
+    return {heif_error_Memory_allocation_error, heif_suberror_Unspecified, "Failed to get signed int plane"};
+  }
+
+  int bytesPerSample = bps / 8;
+  tdata_t buf = _TIFFmalloc(TIFFScanlineSize(tif));
+  for (uint32_t row = 0; row < height; row++) {
+    if (TIFFReadScanline(tif, buf, row, 0) < 0) {
+      _TIFFfree(buf);
+      heif_image_release(*image);
+      *image = nullptr;
+      return {heif_error_Invalid_input, heif_suberror_Unspecified, "Failed to read TIFF scanline"};
+    }
+    memcpy(plane + row * stride, buf, width * bytesPerSample);
+  }
+  _TIFFfree(buf);
+
+  return heif_error_ok;
+}
+#endif
+
+
+static void suppress_warnings(const char* module, const char* fmt, va_list ap) {
+  // Do nothing
+}
+
+
+static heif_error validateTiffFormat(TIFF* tif, uint16_t& samplesPerPixel, uint16_t& bps,
+                                     uint16_t& config, bool& hasAlpha, uint16_t& sampleFormat)
+{
+  uint16_t shortv;
+  if (TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &shortv) && shortv == PHOTOMETRIC_PALETTE) {
+    return {heif_error_Unsupported_feature, heif_suberror_Unspecified,
+            "Palette TIFF images are not supported yet"};
+  }
+
+  TIFFGetField(tif, TIFFTAG_PLANARCONFIG, &config);
+  TIFFGetField(tif, TIFFTAG_SAMPLESPERPIXEL, &samplesPerPixel);
+  if (samplesPerPixel != 1 && samplesPerPixel != 3 && samplesPerPixel != 4) {
+    return {heif_error_Invalid_input, heif_suberror_Unspecified,
+            "Only 1, 3 and 4 samples per pixel are supported."};
+  }
+
+  // Determine whether the 4th sample is true alpha or an unrelated extra sample
+  hasAlpha = false;
+  if (samplesPerPixel == 4) {
+    uint16_t extraCount = 0;
+    uint16_t* extraTypes = nullptr;
+    if (TIFFGetField(tif, TIFFTAG_EXTRASAMPLES, &extraCount, &extraTypes) && extraCount > 0) {
+      hasAlpha = (extraTypes[0] == EXTRASAMPLE_ASSOCALPHA || extraTypes[0] == EXTRASAMPLE_UNASSALPHA);
+    }
+    else {
+      // No EXTRASAMPLES tag with 4 spp — assume the extra sample is not alpha
+      hasAlpha = false;
+    }
+  }
+
+  TIFFGetField(tif, TIFFTAG_BITSPERSAMPLE, &bps);
+
+  if (!TIFFGetField(tif, TIFFTAG_SAMPLEFORMAT, &sampleFormat)) {
+    sampleFormat = SAMPLEFORMAT_UINT;
+  }
+
+  if (sampleFormat == SAMPLEFORMAT_IEEEFP) {
+    if (bps != 32) {
+      return {heif_error_Unsupported_feature, heif_suberror_Unspecified,
+              "Only 32-bit floating point TIFF is supported."};
+    }
+    if (samplesPerPixel != 1) {
+      return {heif_error_Unsupported_feature, heif_suberror_Unspecified,
+              "Only monochrome floating point TIFF is supported."};
+    }
+  }
+  else if (sampleFormat == SAMPLEFORMAT_INT) {
+    if (bps != 8 && bps != 16) {
+      return {heif_error_Invalid_input, heif_suberror_Unspecified,
+              "Only 8 and 16 bits per sample are supported for signed integer TIFF."};
+    }
+    if (samplesPerPixel != 1) {
+      return {heif_error_Unsupported_feature, heif_suberror_Unspecified,
+              "Only monochrome signed integer TIFF is supported."};
+    }
+  }
+  else if (sampleFormat == SAMPLEFORMAT_UINT) {
+    if (bps != 8 && bps != 16) {
+      return {heif_error_Invalid_input, heif_suberror_Unspecified,
+              "Only 8 and 16 bits per sample are supported."};
+    }
+  }
+  else {
+    return {heif_error_Unsupported_feature, heif_suberror_Unspecified,
+            "Unsupported TIFF sample format."};
+  }
+
+  return heif_error_ok;
+}
+
+
+static YCbCrInfo getYCbCrInfo(TIFF* tif)
+{
+  YCbCrInfo info;
+  uint16_t photometric;
+  if (TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &photometric) && photometric == PHOTOMETRIC_YCBCR) {
+    info.is_ycbcr = true;
+    TIFFGetFieldDefaulted(tif, TIFFTAG_YCBCRSUBSAMPLING, &info.horiz_sub, &info.vert_sub);
+  }
+  return info;
+}
+
+
+static heif_chroma ycbcrChroma(const YCbCrInfo& ycbcr)
+{
+  if (ycbcr.horiz_sub == 2 && ycbcr.vert_sub == 2) return heif_chroma_420;
+  if (ycbcr.horiz_sub == 2 && ycbcr.vert_sub == 1) return heif_chroma_422;
+  return heif_chroma_444;
+}
+
+
+// Deinterleave libtiff's packed YCbCr format into separate Y/Cb/Cr planes.
+// Packed format: MCUs of (horiz_sub * vert_sub) Y samples + 1 Cb + 1 Cr.
+// block_w/block_h must be multiples of horiz_sub/vert_sub respectively.
+// actual_w/actual_h are the clipped dimensions for edge tiles/strips.
+static void deinterleaveYCbCr(
+    const uint8_t* src,
+    uint32_t block_w, uint32_t block_h,
+    uint32_t actual_w, uint32_t actual_h,
+    uint16_t horiz_sub, uint16_t vert_sub,
+    uint8_t* y_plane, size_t y_stride,
+    uint8_t* cb_plane, size_t cb_stride,
+    uint8_t* cr_plane, size_t cr_stride)
+{
+  uint32_t mcus_h = block_w / horiz_sub;
+  uint32_t mcu_rows = block_h / vert_sub;
+  uint32_t mcu_size = horiz_sub * vert_sub + 2;
+
+  uint32_t chroma_w = (actual_w + horiz_sub - 1) / horiz_sub;
+  uint32_t chroma_h = (actual_h + vert_sub - 1) / vert_sub;
+
+  for (uint32_t mcu_y = 0; mcu_y < mcu_rows; mcu_y++) {
+    for (uint32_t mcu_x = 0; mcu_x < mcus_h; mcu_x++) {
+      const uint8_t* mcu = src + (mcu_y * mcus_h + mcu_x) * mcu_size;
+
+      // Scatter Y samples
+      for (uint32_t vy = 0; vy < vert_sub; vy++) {
+        uint32_t py = mcu_y * vert_sub + vy;
+        if (py >= actual_h) break;
+        for (uint32_t hx = 0; hx < horiz_sub; hx++) {
+          uint32_t px = mcu_x * horiz_sub + hx;
+          if (px >= actual_w) break;
+          y_plane[py * y_stride + px] = mcu[vy * horiz_sub + hx];
+        }
+      }
+
+      // Scatter Cb/Cr
+      if (mcu_x < chroma_w && mcu_y < chroma_h) {
+        cb_plane[mcu_y * cb_stride + mcu_x] = mcu[horiz_sub * vert_sub];
+        cr_plane[mcu_y * cr_stride + mcu_x] = mcu[horiz_sub * vert_sub + 1];
+      }
+    }
+  }
+}
+
+
+// Create a YCbCr heif_image from a single packed YCbCr tile/block.
+static heif_error readYCbCrBlock(
+    const uint8_t* tile_buf,
+    uint32_t block_w, uint32_t block_h,
+    uint32_t actual_w, uint32_t actual_h,
+    const YCbCrInfo& ycbcr,
+    heif_image** out_image)
+{
+  heif_chroma chroma = ycbcrChroma(ycbcr);
+
+  heif_error err = heif_image_create((int)actual_w, (int)actual_h, heif_colorspace_YCbCr, chroma, out_image);
+  if (err.code != heif_error_Ok) return err;
+
+  heif_image_add_plane(*out_image, heif_channel_Y, (int)actual_w, (int)actual_h, 8);
+  uint32_t chroma_w = (actual_w + ycbcr.horiz_sub - 1) / ycbcr.horiz_sub;
+  uint32_t chroma_h = (actual_h + ycbcr.vert_sub - 1) / ycbcr.vert_sub;
+  heif_image_add_plane(*out_image, heif_channel_Cb, (int)chroma_w, (int)chroma_h, 8);
+  heif_image_add_plane(*out_image, heif_channel_Cr, (int)chroma_w, (int)chroma_h, 8);
+
+  size_t y_stride, cb_stride, cr_stride;
+  uint8_t* y_plane = heif_image_get_plane2(*out_image, heif_channel_Y, &y_stride);
+  uint8_t* cb_plane = heif_image_get_plane2(*out_image, heif_channel_Cb, &cb_stride);
+  uint8_t* cr_plane = heif_image_get_plane2(*out_image, heif_channel_Cr, &cr_stride);
+
+  deinterleaveYCbCr(tile_buf, block_w, block_h, actual_w, actual_h,
+                    ycbcr.horiz_sub, ycbcr.vert_sub,
+                    y_plane, y_stride, cb_plane, cb_stride, cr_plane, cr_stride);
+
+  return heif_error_ok;
+}
+
+
+static heif_error readTiledContiguous(TIFF* tif, uint32_t width, uint32_t height,
+                                  uint32_t tile_width, uint32_t tile_height,
+                                  uint16_t samplesPerPixel, bool hasAlpha,
+                                  uint16_t bps, int output_bit_depth,
+                                  uint16_t sampleFormat, heif_image** out_image)
+{
+  // --- YCbCr path: deinterleave packed MCU data into planar Y/Cb/Cr ---
+  YCbCrInfo ycbcr = getYCbCrInfo(tif);
+  if (ycbcr.is_ycbcr) {
+    if (bps != 8) {
+      return {heif_error_Unsupported_feature, heif_suberror_Unspecified,
+              "Only 8-bit YCbCr TIFF is supported."};
+    }
+
+    if (width > std::numeric_limits<int>::max() || height > std::numeric_limits<int>::max()) {
+      return {heif_error_Invalid_input, heif_suberror_Unspecified, "TIFF image size exceeds maximum supported by libheif."};
+    }
+
+
+    heif_chroma chroma = ycbcrChroma(ycbcr);
+    heif_error err = heif_image_create((int)width, (int)height, heif_colorspace_YCbCr, chroma, out_image);
+    if (err.code != heif_error_Ok) return err;
+
+    heif_image_add_plane(*out_image, heif_channel_Y, (int)width, (int)height, 8);
+    uint32_t chroma_w = (width + ycbcr.horiz_sub - 1) / ycbcr.horiz_sub;
+    uint32_t chroma_h = (height + ycbcr.vert_sub - 1) / ycbcr.vert_sub;
+    heif_image_add_plane(*out_image, heif_channel_Cb, (int)chroma_w, (int)chroma_h, 8);
+    heif_image_add_plane(*out_image, heif_channel_Cr, (int)chroma_w, (int)chroma_h, 8);
+
+    size_t y_stride, cb_stride, cr_stride;
+    uint8_t* y_plane = heif_image_get_plane2(*out_image, heif_channel_Y, &y_stride);
+    uint8_t* cb_plane = heif_image_get_plane2(*out_image, heif_channel_Cb, &cb_stride);
+    uint8_t* cr_plane = heif_image_get_plane2(*out_image, heif_channel_Cr, &cr_stride);
+
+    tmsize_t tile_buf_size = TIFFTileSize(tif);
+    std::vector<uint8_t> tile_buf(tile_buf_size);
+
+    uint32_t n_cols = (width - 1) / tile_width + 1;
+    uint32_t n_rows = (height - 1) / tile_height + 1;
+
+    for (uint32_t ty = 0; ty < n_rows; ty++) {
+      for (uint32_t tx = 0; tx < n_cols; tx++) {
+        tmsize_t read = TIFFReadEncodedTile(tif, TIFFComputeTile(tif, tx * tile_width, ty * tile_height, 0, 0),
+                                            tile_buf.data(), tile_buf_size);
+        if (read < 0) {
+          heif_image_release(*out_image);
+          *out_image = nullptr;
+          return {heif_error_Invalid_input, heif_suberror_Unspecified, "Failed to read TIFF tile"};
+        }
+
+        uint32_t actual_w = std::min(tile_width, width - tx * tile_width);
+        uint32_t actual_h = std::min(tile_height, height - ty * tile_height);
+
+        uint32_t y_offset = ty * tile_height;
+        uint32_t x_offset = tx * tile_width;
+        uint32_t chroma_x_offset = x_offset / ycbcr.horiz_sub;
+        uint32_t chroma_y_offset = y_offset / ycbcr.vert_sub;
+
+        deinterleaveYCbCr(tile_buf.data(), tile_width, tile_height, actual_w, actual_h,
+                          ycbcr.horiz_sub, ycbcr.vert_sub,
+                          y_plane + y_offset * y_stride + x_offset, y_stride,
+                          cb_plane + chroma_y_offset * cb_stride + chroma_x_offset, cb_stride,
+                          cr_plane + chroma_y_offset * cr_stride + chroma_x_offset, cr_stride);
+      }
+    }
+
+    return heif_error_ok;
+  }
+
+  bool isFloat = (sampleFormat == SAMPLEFORMAT_IEEEFP);
+
+  if (isFloat) {
+#if WITH_UNCOMPRESSED_CODEC
+    heif_error err = heif_image_create((int)width, (int)height, heif_colorspace_nonvisual, heif_chroma_undefined, out_image);
+    if (err.code != heif_error_Ok) return err;
+
+    uint32_t component_idx;
+    err = heif_image_add_component(*out_image, (int)width, (int)height,
+                                   heif_uncompressed_component_type_monochrome,
+                                   heif_channel_datatype_floating_point, 32, &component_idx);
+    if (err.code != heif_error_Ok) {
+      heif_image_release(*out_image);
+      *out_image = nullptr;
+      return err;
+    }
+
+    size_t out_stride;
+    float* out_plane = heif_image_get_component_float32(*out_image, component_idx, &out_stride);
+    if (!out_plane) {
+      heif_image_release(*out_image);
+      *out_image = nullptr;
+      return {heif_error_Memory_allocation_error, heif_suberror_Unspecified, "Failed to get float plane"};
+    }
+
+    tmsize_t tile_buf_size = TIFFTileSize(tif);
+    std::vector<uint8_t> tile_buf(tile_buf_size);
+
+    uint32_t n_cols = (width - 1) / tile_width + 1;
+    uint32_t n_rows = (height - 1) / tile_height + 1;
+
+    for (uint32_t ty = 0; ty < n_rows; ty++) {
+      for (uint32_t tx = 0; tx < n_cols; tx++) {
+        tmsize_t read = TIFFReadEncodedTile(tif, TIFFComputeTile(tif, tx * tile_width, ty * tile_height, 0, 0),
+                                            tile_buf.data(), tile_buf_size);
+        if (read < 0) {
+          heif_image_release(*out_image);
+          *out_image = nullptr;
+          return {heif_error_Invalid_input, heif_suberror_Unspecified, "Failed to read TIFF tile"};
+        }
+
+        uint32_t actual_w = std::min(tile_width, width - tx * tile_width);
+        uint32_t actual_h = std::min(tile_height, height - ty * tile_height);
+
+        for (uint32_t row = 0; row < actual_h; row++) {
+          uint8_t* dst = reinterpret_cast<uint8_t*>(out_plane) + (size_t)(ty * tile_height + row) * out_stride
+                         + (size_t)tx * tile_width * sizeof(float);
+          float* src = reinterpret_cast<float*>(tile_buf.data() + (size_t)row * tile_width * sizeof(float));
+          memcpy(dst, src, actual_w * sizeof(float));
+        }
+      }
+    }
+
+    return heif_error_ok;
+#else
+    return {heif_error_Unsupported_feature, heif_suberror_Unspecified,
+            "Floating point TIFF requires uncompressed codec support (WITH_UNCOMPRESSED_CODEC)."};
+#endif
+  }
+
+  bool isSignedInt = (sampleFormat == SAMPLEFORMAT_INT);
+
+  if (isSignedInt) {
+#if WITH_UNCOMPRESSED_CODEC
+    heif_error err = heif_image_create((int)width, (int)height, heif_colorspace_nonvisual, heif_chroma_undefined, out_image);
+    if (err.code != heif_error_Ok) return err;
+
+    uint32_t component_idx;
+    err = heif_image_add_component(*out_image, (int)width, (int)height,
+                                   heif_uncompressed_component_type_monochrome,
+                                   heif_channel_datatype_signed_integer, bps, &component_idx);
+    if (err.code != heif_error_Ok) {
+      heif_image_release(*out_image);
+      *out_image = nullptr;
+      return err;
+    }
+
+    size_t out_stride;
+    uint8_t* out_plane;
+    if (bps == 8) {
+      out_plane = reinterpret_cast<uint8_t*>(heif_image_get_component_int8(*out_image, component_idx, &out_stride));
+    }
+    else {
+      out_plane = reinterpret_cast<uint8_t*>(heif_image_get_component_int16(*out_image, component_idx, &out_stride));
+    }
+    if (!out_plane) {
+      heif_image_release(*out_image);
+      *out_image = nullptr;
+      return {heif_error_Memory_allocation_error, heif_suberror_Unspecified, "Failed to get signed int plane"};
+    }
+
+    int bytesPerSample = bps / 8;
+    tmsize_t tile_buf_size = TIFFTileSize(tif);
+    std::vector<uint8_t> tile_buf(tile_buf_size);
+
+    uint32_t n_cols = (width - 1) / tile_width + 1;
+    uint32_t n_rows = (height - 1) / tile_height + 1;
+
+    for (uint32_t ty = 0; ty < n_rows; ty++) {
+      for (uint32_t tx = 0; tx < n_cols; tx++) {
+        tmsize_t read = TIFFReadEncodedTile(tif, TIFFComputeTile(tif, tx * tile_width, ty * tile_height, 0, 0),
+                                            tile_buf.data(), tile_buf_size);
+        if (read < 0) {
+          heif_image_release(*out_image);
+          *out_image = nullptr;
+          return {heif_error_Invalid_input, heif_suberror_Unspecified, "Failed to read TIFF tile"};
+        }
+
+        uint32_t actual_w = std::min(tile_width, width - tx * tile_width);
+        uint32_t actual_h = std::min(tile_height, height - ty * tile_height);
+
+        for (uint32_t row = 0; row < actual_h; row++) {
+          uint8_t* dst = out_plane + ((size_t)ty * tile_height + row) * out_stride
+                         + (size_t)tx * tile_width * bytesPerSample;
+          uint8_t* src = tile_buf.data() + (size_t)row * tile_width * bytesPerSample;
+          memcpy(dst, src, actual_w * bytesPerSample);
+        }
+      }
+    }
+
+    return heif_error_ok;
+#else
+    return {heif_error_Unsupported_feature, heif_suberror_Unspecified,
+            "Signed integer TIFF requires uncompressed codec support (WITH_UNCOMPRESSED_CODEC)."};
+#endif
+  }
+
+  uint16_t outSpp = (samplesPerPixel == 4 && !hasAlpha) ? 3 : samplesPerPixel;
+  int effectiveBitDepth = (bps <= 8) ? 8 : output_bit_depth;
+  heif_chroma chroma = get_heif_chroma(outSpp, effectiveBitDepth);
+  heif_colorspace colorspace = (outSpp == 1) ? heif_colorspace_monochrome : heif_colorspace_RGB;
+  heif_channel channel = (outSpp == 1) ? heif_channel_Y : heif_channel_interleaved;
+
+  heif_error err = heif_image_create((int)width, (int)height, colorspace, chroma, out_image);
+  if (err.code != heif_error_Ok) return err;
+
+  int planeBitDepth = (effectiveBitDepth <= 8) ? outSpp * 8 : effectiveBitDepth;
+  heif_image_add_plane(*out_image, channel, (int)width, (int)height, planeBitDepth);
+
+  size_t out_stride;
+  uint8_t* out_plane = heif_image_get_plane2(*out_image, channel, &out_stride);
+
+  tmsize_t tile_buf_size = TIFFTileSize(tif);
+  std::vector<uint8_t> tile_buf(tile_buf_size);
+
+  uint32_t n_cols = (width - 1) / tile_width + 1;
+  uint32_t n_rows = (height - 1) / tile_height + 1;
+
+  for (uint32_t ty = 0; ty < n_rows; ty++) {
+    for (uint32_t tx = 0; tx < n_cols; tx++) {
+      tmsize_t read = TIFFReadEncodedTile(tif, TIFFComputeTile(tif, tx * tile_width, ty * tile_height, 0, 0),
+                                          tile_buf.data(), tile_buf_size);
+      if (read < 0) {
+        heif_image_release(*out_image);
+        *out_image = nullptr;
+        return {heif_error_Invalid_input, heif_suberror_Unspecified, "Failed to read TIFF tile"};
+      }
+
+      uint32_t actual_w = std::min(tile_width, width - tx * tile_width);
+      uint32_t actual_h = std::min(tile_height, height - ty * tile_height);
+
+      if (bps <= 8) {
+        for (uint32_t row = 0; row < actual_h; row++) {
+          uint8_t* dst = out_plane + ((size_t)ty * tile_height + row) * out_stride + (size_t)tx * tile_width * outSpp;
+          uint8_t* src = tile_buf.data() + (size_t)row * tile_width * samplesPerPixel;
+          if (outSpp == samplesPerPixel) {
+            memcpy(dst, src, actual_w * outSpp);
+          }
+          else {
+            for (uint32_t x = 0; x < actual_w; x++) {
+              memcpy(dst + x * outSpp, src + x * samplesPerPixel, outSpp);
+            }
+          }
+        }
+      }
+      else if (output_bit_depth <= 8) {
+        for (uint32_t row = 0; row < actual_h; row++) {
+          uint8_t* dst = out_plane + ((size_t)ty * tile_height + row) * out_stride + (size_t)tx * tile_width * outSpp;
+          uint16_t* src = reinterpret_cast<uint16_t*>(tile_buf.data() + (size_t)row * tile_width * samplesPerPixel * 2);
+          if (outSpp == samplesPerPixel) {
+            for (uint32_t x = 0; x < actual_w * outSpp; x++) {
+              dst[x] = static_cast<uint8_t>(src[x] >> 8);
+            }
+          }
+          else {
+            for (uint32_t x = 0; x < actual_w; x++) {
+              for (uint16_t c = 0; c < outSpp; c++) {
+                dst[x * outSpp + c] = static_cast<uint8_t>(src[x * samplesPerPixel + c] >> 8);
+              }
+            }
+          }
+        }
+      }
+      else {
+        int bdShift = 16 - output_bit_depth;
+        for (uint32_t row = 0; row < actual_h; row++) {
+          uint16_t* dst = reinterpret_cast<uint16_t*>(out_plane + ((size_t)ty * tile_height + row) * out_stride
+                                                      + (size_t)tx * tile_width * outSpp * 2);
+          uint16_t* src = reinterpret_cast<uint16_t*>(tile_buf.data() + (size_t)row * tile_width * samplesPerPixel * 2);
+          if (outSpp == samplesPerPixel) {
+            if (bdShift == 0) {
+              memcpy(dst, src, actual_w * outSpp * 2);
+            }
+            else {
+              for (uint32_t x = 0; x < actual_w * outSpp; x++) {
+                dst[x] = static_cast<uint16_t>(src[x] >> bdShift);
+              }
+            }
+          }
+          else {
+            for (uint32_t x = 0; x < actual_w; x++) {
+              for (uint16_t c = 0; c < outSpp; c++) {
+                dst[x * outSpp + c] = static_cast<uint16_t>(src[x * samplesPerPixel + c] >> bdShift);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  return heif_error_ok;
+}
+
+
+static heif_error readTiledSeparate(TIFF* tif, uint32_t width, uint32_t height,
+                                    uint32_t tile_width, uint32_t tile_height,
+                                    uint16_t samplesPerPixel, bool hasAlpha,
+                                    uint16_t bps, int output_bit_depth,
+                                    uint16_t sampleFormat, heif_image** out_image)
+{
+  // For mono float/signed int, separate layout is the same as contiguous (1 sample)
+  if (sampleFormat == SAMPLEFORMAT_IEEEFP || sampleFormat == SAMPLEFORMAT_INT) {
+#if WITH_UNCOMPRESSED_CODEC
+    return readTiledContiguous(tif, width, height, tile_width, tile_height,
+                               samplesPerPixel, hasAlpha, bps, output_bit_depth,
+                               sampleFormat, out_image);
+#else
+    return {heif_error_Unsupported_feature, heif_suberror_Unspecified,
+            "Float/signed integer TIFF requires uncompressed codec support (WITH_UNCOMPRESSED_CODEC)."};
+#endif
+  }
+
+  uint16_t outSpp = (samplesPerPixel == 4 && !hasAlpha) ? 3 : samplesPerPixel;
+  int effectiveBitDepth = (bps <= 8) ? 8 : output_bit_depth;
+  heif_chroma chroma = get_heif_chroma(outSpp, effectiveBitDepth);
+  heif_colorspace colorspace = (outSpp == 1) ? heif_colorspace_monochrome : heif_colorspace_RGB;
+  heif_channel channel = (outSpp == 1) ? heif_channel_Y : heif_channel_interleaved;
+
+  heif_error err = heif_image_create((int)width, (int)height, colorspace, chroma, out_image);
+  if (err.code != heif_error_Ok) return err;
+
+  int planeBitDepth = (effectiveBitDepth <= 8) ? outSpp * 8 : effectiveBitDepth;
+  heif_image_add_plane(*out_image, channel, (int)width, (int)height, planeBitDepth);
+
+  size_t out_stride;
+  uint8_t* out_plane = heif_image_get_plane2(*out_image, channel, &out_stride);
+
+  tmsize_t tile_buf_size = TIFFTileSize(tif);
+  std::vector<uint8_t> tile_buf(tile_buf_size);
+
+  uint32_t n_cols = (width - 1) / tile_width + 1;
+  uint32_t n_rows = (height - 1) / tile_height + 1;
+
+  for (uint16_t s = 0; s < outSpp; s++) {
+    for (uint32_t ty = 0; ty < n_rows; ty++) {
+      for (uint32_t tx = 0; tx < n_cols; tx++) {
+        tmsize_t read = TIFFReadEncodedTile(tif, TIFFComputeTile(tif, tx * tile_width, ty * tile_height, 0, s),
+                                            tile_buf.data(), tile_buf_size);
+        if (read < 0) {
+          heif_image_release(*out_image);
+          *out_image = nullptr;
+          return {heif_error_Invalid_input, heif_suberror_Unspecified, "Failed to read TIFF tile"};
+        }
+
+        uint32_t actual_w = std::min(tile_width, width - tx * tile_width);
+        uint32_t actual_h = std::min(tile_height, height - ty * tile_height);
+
+        if (bps <= 8) {
+          for (uint32_t row = 0; row < actual_h; row++) {
+            uint8_t* dst = out_plane + ((size_t)ty * tile_height + row) * out_stride + (size_t)tx * tile_width * outSpp + s;
+            uint8_t* src = tile_buf.data() + (size_t)row * tile_width;
+            for (uint32_t x = 0; x < actual_w; x++) {
+              dst[x * outSpp] = src[x];
+            }
+          }
+        }
+        else if (output_bit_depth <= 8) {
+          for (uint32_t row = 0; row < actual_h; row++) {
+            uint8_t* dst = out_plane + ((size_t)ty * tile_height + row) * out_stride + (size_t)tx * tile_width * outSpp + s;
+            uint16_t* src = reinterpret_cast<uint16_t*>(tile_buf.data() + (size_t)row * tile_width * 2);
+            for (uint32_t x = 0; x < actual_w; x++) {
+              dst[x * outSpp] = static_cast<uint8_t>(src[x] >> 8);
+            }
+          }
+        }
+        else {
+          int bdShift = 16 - output_bit_depth;
+          for (uint32_t row = 0; row < actual_h; row++) {
+            uint16_t* dst = reinterpret_cast<uint16_t*>(out_plane + ((size_t)ty * tile_height + row) * out_stride) + (size_t)tx * tile_width * outSpp + s;
+            uint16_t* src = reinterpret_cast<uint16_t*>(tile_buf.data() + (size_t)row * tile_width * 2);
+            for (uint32_t x = 0; x < actual_w; x++) {
+              dst[x * outSpp] = static_cast<uint16_t>(src[x] >> bdShift);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  return heif_error_ok;
+}
+
+
+heif_error loadTIFF(const char* filename, int output_bit_depth, InputImage *input_image) {
+  TIFFSetWarningHandler(suppress_warnings);
+
+  std::unique_ptr<TIFF, void(*)(TIFF*)> tifPtr(TIFFOpen(filename, "r"), [](TIFF* tif) { TIFFClose(tif); });
+  if (!tifPtr) {
+    return {heif_error_Invalid_input, heif_suberror_Unspecified, "Cannot open TIFF file"};
+  }
+
+  TIFF* tif = tifPtr.get();
+
+  uint16_t samplesPerPixel, bps, config, sampleFormat;
+  bool hasAlpha;
+  heif_error err = validateTiffFormat(tif, samplesPerPixel, bps, config, hasAlpha, sampleFormat);
+  if (err.code != heif_error_Ok) return err;
+
+  // For PLANARCONFIG_SEPARATE + YCbCr, tell libtiff to convert to RGB on the fly
+  YCbCrInfo ycbcr = getYCbCrInfo(tif);
+  if (ycbcr.is_ycbcr && config == PLANARCONFIG_SEPARATE) {
+    TIFFSetField(tif, TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RGB);
+  }
+
+  bool isFloat = (sampleFormat == SAMPLEFORMAT_IEEEFP);
+  bool isSignedInt = (sampleFormat == SAMPLEFORMAT_INT);
+
+  // For 8-bit source, always produce 8-bit output (ignore output_bit_depth).
+  // For float, use 32-bit. For signed int, preserve original bit depth.
+  int effectiveOutputBitDepth = isFloat ? 32 : (isSignedInt ? bps : ((bps <= 8) ? 8 : output_bit_depth));
+
+  struct heif_image* image = nullptr;
+
+  if (TIFFIsTiled(tif)) {
+    uint32_t width, height, tile_width, tile_height;
+    err = getImageWidthAndHeight(tif, width, height);
+    if (err.code != heif_error_Ok) return err;
+
+    if (!TIFFGetField(tif, TIFFTAG_TILEWIDTH, &tile_width) ||
+        !TIFFGetField(tif, TIFFTAG_TILELENGTH, &tile_height)) {
+      return {heif_error_Invalid_input, heif_suberror_Unspecified, "Cannot read TIFF tile dimensions"};
+    }
+
+    if (tile_width == 0 || tile_height == 0) {
+      return {heif_error_Invalid_input, heif_suberror_Unspecified, "Invalid TIFF tile dimensions"};
+    }
+
+    switch (config) {
+      case PLANARCONFIG_CONTIG:
+        err = readTiledContiguous(tif, width, height, tile_width, tile_height, samplesPerPixel, hasAlpha, bps, effectiveOutputBitDepth, sampleFormat, &image);
+        break;
+      case PLANARCONFIG_SEPARATE:
+        err = readTiledSeparate(tif, width, height, tile_width, tile_height, samplesPerPixel, hasAlpha, bps, effectiveOutputBitDepth, sampleFormat, &image);
+        break;
+      default:
+        return {heif_error_Invalid_input, heif_suberror_Unspecified, "Unsupported planar configuration"};
+    }
+  }
+  else {
+    if (isFloat) {
+#if WITH_UNCOMPRESSED_CODEC
+      err = readMonoFloat(tif, &image);
+#else
+      return {heif_error_Unsupported_feature, heif_suberror_Unspecified,
+              "Floating point TIFF requires uncompressed codec support (WITH_UNCOMPRESSED_CODEC)."};
+#endif
+    }
+    else if (isSignedInt) {
+#if WITH_UNCOMPRESSED_CODEC
+      err = readMonoSignedInt(tif, bps, &image);
+#else
+      return {heif_error_Unsupported_feature, heif_suberror_Unspecified,
+              "Signed integer TIFF requires uncompressed codec support (WITH_UNCOMPRESSED_CODEC)."};
+#endif
+    }
+    else {
+      switch (config) {
+        case PLANARCONFIG_CONTIG:
+          err = readPixelInterleave(tif, samplesPerPixel, hasAlpha, bps, effectiveOutputBitDepth, &image);
+          break;
+        case PLANARCONFIG_SEPARATE:
+          err = readBandInterleave(tif, samplesPerPixel, hasAlpha, bps, effectiveOutputBitDepth, &image);
+          break;
+        default:
+          return {heif_error_Invalid_input, heif_suberror_Unspecified, "Unsupported planar configuration"};
+      }
+    }
+  }
+
+  if (err.code != heif_error_Ok) {
+    return err;
+  }
+
+  input_image->image = std::shared_ptr<heif_image>(image,
+                                          [](heif_image* img) { heif_image_release(img); });
+
+  // Unfortunately libtiff doesn't provide a way to read a raw dictionary.
+  // Therefore we manually parse the EXIF data, extract the tags and encode
+  // them for use in the HEIF image.
+  std::unique_ptr<ExifTags> tags = ExifTags::Parse(tif);
+  if (tags) {
+    tags->Encode(&(input_image->exif));
+  }
+  return heif_error_ok;
+}
+
+
+// --- TiledTiffReader ---
+
+void TiledTiffReader::TiffCloser::operator()(void* tif) const {
+  if (tif) {
+    TIFFClose(static_cast<TIFF*>(tif));
+  }
+}
+
+
+std::unique_ptr<TiledTiffReader> TiledTiffReader::open(const char* filename, heif_error* out_err)
+{
+  TIFFSetWarningHandler(suppress_warnings);
+
+  TIFF* tif = TIFFOpen(filename, "r");
+  if (!tif) {
+    *out_err = {heif_error_Invalid_input, heif_suberror_Unspecified, "Cannot open TIFF file"};
+    return nullptr;
+  }
+
+  if (!TIFFIsTiled(tif)) {
+    TIFFClose(tif);
+    *out_err = heif_error_ok;
+    return nullptr;
+  }
+
+  auto reader = std::unique_ptr<TiledTiffReader>(new TiledTiffReader());
+  reader->m_tif.reset(tif);
+
+  uint16_t bps;
+  heif_error err = validateTiffFormat(tif, reader->m_samples_per_pixel, bps, reader->m_planar_config, reader->m_has_alpha, reader->m_sample_format);
+  if (err.code != heif_error_Ok) {
+    *out_err = err;
+    return nullptr;
+  }
+  reader->m_bits_per_sample = bps;
+
+  reader->m_ycbcr = getYCbCrInfo(tif);
+  if (reader->m_ycbcr.is_ycbcr && reader->m_planar_config == PLANARCONFIG_SEPARATE) {
+    TIFFSetField(tif, TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RGB);
+    reader->m_ycbcr.is_ycbcr = false;  // data comes out as RGB now
+  }
+
+  if (!TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &reader->m_image_width) ||
+      !TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &reader->m_image_height)) {
+    *out_err = {heif_error_Invalid_input, heif_suberror_Unspecified, "Cannot read TIFF image dimensions"};
+    return nullptr;
+  }
+
+  if (!TIFFGetField(tif, TIFFTAG_TILEWIDTH, &reader->m_tile_width) ||
+      !TIFFGetField(tif, TIFFTAG_TILELENGTH, &reader->m_tile_height)) {
+    *out_err = {heif_error_Invalid_input, heif_suberror_Unspecified, "Cannot read TIFF tile dimensions"};
+    return nullptr;
+  }
+
+  if (reader->m_tile_width == 0 || reader->m_tile_height == 0) {
+    *out_err = {heif_error_Invalid_input, heif_suberror_Unspecified, "Invalid TIFF tile dimensions"};
+    return nullptr;
+  }
+
+  reader->m_n_columns = (reader->m_image_width - 1) / reader->m_tile_width + 1;
+  reader->m_n_rows = (reader->m_image_height - 1) / reader->m_tile_height + 1;
+
+  // Detect overview directories (reduced-resolution images)
+  tdir_t n_dirs = TIFFNumberOfDirectories(tif);
+  for (uint16_t d = 1; d < n_dirs; d++) {
+    if (!TIFFSetDirectory(tif, d)) {
+      continue;
+    }
+
+    uint32_t subfiletype = 0;
+    TIFFGetField(tif, TIFFTAG_SUBFILETYPE, &subfiletype);
+    if (!(subfiletype & FILETYPE_REDUCEDIMAGE)) {
+      continue;
+    }
+
+    if (!TIFFIsTiled(tif)) {
+      continue;
+    }
+
+    uint16_t spp, bps_ov, config_ov, sampleFormat_ov;
+    bool hasAlpha_ov;
+    heif_error valErr = validateTiffFormat(tif, spp, bps_ov, config_ov, hasAlpha_ov, sampleFormat_ov);
+    if (valErr.code != heif_error_Ok) {
+      continue;
+    }
+
+    uint32_t ov_width, ov_height, ov_tw, ov_th;
+    if (!TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &ov_width) ||
+        !TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &ov_height)) {
+      continue;
+    }
+    if (!TIFFGetField(tif, TIFFTAG_TILEWIDTH, &ov_tw) ||
+        !TIFFGetField(tif, TIFFTAG_TILELENGTH, &ov_th)) {
+      continue;
+    }
+
+    if (ov_width == 0 || ov_height == 0) {
+      continue;
+    }
+
+    if (ov_tw == 0 || ov_th == 0) {
+      continue;
+    }
+
+    reader->m_overviews.push_back({d, ov_width, ov_height, ov_tw, ov_th});
+  }
+
+  // Switch back to directory 0
+  TIFFSetDirectory(tif, 0);
+
+  *out_err = heif_error_ok;
+  return reader;
+}
+
+
+TiledTiffReader::~TiledTiffReader() = default;
+
+
+bool TiledTiffReader::setDirectory(uint32_t dir_index)
+{
+  TIFF* tif = static_cast<TIFF*>(m_tif.get());
+
+  if (!TIFFSetDirectory(tif, static_cast<uint16_t>(dir_index))) {
+    return false;
+  }
+
+  if (!TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &m_image_width) ||
+      !TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &m_image_height)) {
+    return false;
+  }
+
+  if (!TIFFGetField(tif, TIFFTAG_TILEWIDTH, &m_tile_width) ||
+      !TIFFGetField(tif, TIFFTAG_TILELENGTH, &m_tile_height)) {
+    return false;
+  }
+
+  if (m_image_width == 0 || m_image_height == 0) {
+    return false;
+  }
+
+  if (m_tile_width == 0 || m_tile_height == 0) {
+    return false;
+  }
+
+  uint16_t bps;
+  heif_error err = validateTiffFormat(tif, m_samples_per_pixel, bps, m_planar_config, m_has_alpha, m_sample_format);
+  if (err.code != heif_error_Ok) {
+    return false;
+  }
+  m_bits_per_sample = bps;
+
+  m_ycbcr = getYCbCrInfo(tif);
+  if (m_ycbcr.is_ycbcr && m_planar_config == PLANARCONFIG_SEPARATE) {
+    TIFFSetField(tif, TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RGB);
+    m_ycbcr.is_ycbcr = false;
+  }
+
+  m_n_columns = (m_image_width - 1) / m_tile_width + 1;
+  m_n_rows = (m_image_height - 1) / m_tile_height + 1;
+
+  return true;
+}
+
+
+heif_error TiledTiffReader::readTile(uint32_t tx, uint32_t ty, int output_bit_depth, heif_image** out_image)
+{
+  TIFF* tif = static_cast<TIFF*>(m_tif.get());
+
+  uint32_t actual_w = std::min(m_tile_width, m_image_width - tx * m_tile_width);
+  uint32_t actual_h = std::min(m_tile_height, m_image_height - ty * m_tile_height);
+
+  // --- YCbCr path (PLANARCONFIG_CONTIG only; SEPARATE was converted to RGB in open/setDirectory) ---
+  if (m_ycbcr.is_ycbcr && m_planar_config == PLANARCONFIG_CONTIG) {
+    if (m_bits_per_sample != 8) {
+      return {heif_error_Unsupported_feature, heif_suberror_Unspecified,
+              "Only 8-bit YCbCr TIFF is supported."};
+    }
+
+    tmsize_t tile_buf_size = TIFFTileSize(tif);
+    std::vector<uint8_t> tile_buf(tile_buf_size);
+
+    tmsize_t read = TIFFReadEncodedTile(tif, TIFFComputeTile(tif, tx * m_tile_width, ty * m_tile_height, 0, 0),
+                                        tile_buf.data(), tile_buf_size);
+    if (read < 0) {
+      return {heif_error_Invalid_input, heif_suberror_Unspecified, "Failed to read TIFF tile"};
+    }
+
+    return readYCbCrBlock(tile_buf.data(), m_tile_width, m_tile_height, actual_w, actual_h, m_ycbcr, out_image);
+  }
+
+  if (m_sample_format == SAMPLEFORMAT_IEEEFP) {
+#if WITH_UNCOMPRESSED_CODEC
+    heif_error err = heif_image_create((int)actual_w, (int)actual_h, heif_colorspace_nonvisual, heif_chroma_undefined, out_image);
+    if (err.code != heif_error_Ok) return err;
+
+    uint32_t component_idx;
+    err = heif_image_add_component(*out_image, (int)actual_w, (int)actual_h,
+                                   heif_uncompressed_component_type_monochrome,
+                                   heif_channel_datatype_floating_point, 32, &component_idx);
+    if (err.code != heif_error_Ok) {
+      heif_image_release(*out_image);
+      *out_image = nullptr;
+      return err;
+    }
+
+    size_t out_stride;
+    float* out_plane = heif_image_get_component_float32(*out_image, component_idx, &out_stride);
+    if (!out_plane) {
+      heif_image_release(*out_image);
+      *out_image = nullptr;
+      return {heif_error_Memory_allocation_error, heif_suberror_Unspecified, "Failed to get float plane"};
+    }
+
+    tmsize_t tile_buf_size = TIFFTileSize(tif);
+    std::vector<uint8_t> tile_buf(tile_buf_size);
+
+    tmsize_t read = TIFFReadEncodedTile(tif, TIFFComputeTile(tif, tx * m_tile_width, ty * m_tile_height, 0, 0),
+                                        tile_buf.data(), tile_buf_size);
+    if (read < 0) {
+      heif_image_release(*out_image);
+      *out_image = nullptr;
+      return {heif_error_Invalid_input, heif_suberror_Unspecified, "Failed to read TIFF tile"};
+    }
+
+    for (uint32_t row = 0; row < actual_h; row++) {
+      uint8_t* dst = reinterpret_cast<uint8_t*>(out_plane) + row * out_stride;
+      float* src = reinterpret_cast<float*>(tile_buf.data() + row * m_tile_width * sizeof(float));
+      memcpy(dst, src, actual_w * sizeof(float));
+    }
+
+    return heif_error_ok;
+#else
+    return {heif_error_Unsupported_feature, heif_suberror_Unspecified,
+            "Floating point TIFF requires uncompressed codec support (WITH_UNCOMPRESSED_CODEC)."};
+#endif
+  }
+
+  if (m_sample_format == SAMPLEFORMAT_INT) {
+#if WITH_UNCOMPRESSED_CODEC
+    heif_error err = heif_image_create((int)actual_w, (int)actual_h, heif_colorspace_nonvisual, heif_chroma_undefined, out_image);
+    if (err.code != heif_error_Ok) return err;
+
+    uint32_t component_idx;
+    err = heif_image_add_component(*out_image, (int)actual_w, (int)actual_h,
+                                   heif_uncompressed_component_type_monochrome,
+                                   heif_channel_datatype_signed_integer, m_bits_per_sample, &component_idx);
+    if (err.code != heif_error_Ok) {
+      heif_image_release(*out_image);
+      *out_image = nullptr;
+      return err;
+    }
+
+    size_t out_stride;
+    uint8_t* out_plane;
+    if (m_bits_per_sample == 8) {
+      out_plane = reinterpret_cast<uint8_t*>(heif_image_get_component_int8(*out_image, component_idx, &out_stride));
+    }
+    else {
+      out_plane = reinterpret_cast<uint8_t*>(heif_image_get_component_int16(*out_image, component_idx, &out_stride));
+    }
+    if (!out_plane) {
+      heif_image_release(*out_image);
+      *out_image = nullptr;
+      return {heif_error_Memory_allocation_error, heif_suberror_Unspecified, "Failed to get signed int plane"};
+    }
+
+    int bytesPerSample = m_bits_per_sample / 8;
+    tmsize_t tile_buf_size = TIFFTileSize(tif);
+    std::vector<uint8_t> tile_buf(tile_buf_size);
+
+    tmsize_t read = TIFFReadEncodedTile(tif, TIFFComputeTile(tif, tx * m_tile_width, ty * m_tile_height, 0, 0),
+                                        tile_buf.data(), tile_buf_size);
+    if (read < 0) {
+      heif_image_release(*out_image);
+      *out_image = nullptr;
+      return {heif_error_Invalid_input, heif_suberror_Unspecified, "Failed to read TIFF tile"};
+    }
+
+    for (uint32_t row = 0; row < actual_h; row++) {
+      uint8_t* dst = out_plane + row * out_stride;
+      uint8_t* src = tile_buf.data() + row * m_tile_width * bytesPerSample;
+      memcpy(dst, src, actual_w * bytesPerSample);
+    }
+
+    return heif_error_ok;
+#else
+    return {heif_error_Unsupported_feature, heif_suberror_Unspecified,
+            "Signed integer TIFF requires uncompressed codec support (WITH_UNCOMPRESSED_CODEC)."};
+#endif
+  }
+
+  int effectiveBitDepth = (m_bits_per_sample <= 8) ? 8 : output_bit_depth;
+  uint16_t outSpp = (m_samples_per_pixel == 4 && !m_has_alpha) ? 3 : m_samples_per_pixel;
+  heif_chroma chroma = get_heif_chroma(outSpp, effectiveBitDepth);
+  heif_colorspace colorspace = (outSpp == 1) ? heif_colorspace_monochrome : heif_colorspace_RGB;
+  heif_channel channel = (outSpp == 1) ? heif_channel_Y : heif_channel_interleaved;
+
+  heif_error err = heif_image_create((int)actual_w, (int)actual_h, colorspace, chroma, out_image);
+  if (err.code != heif_error_Ok) return err;
+
+  int planeBitDepth = (effectiveBitDepth <= 8) ? outSpp * 8 : effectiveBitDepth;
+  heif_image_add_plane(*out_image, channel, (int)actual_w, (int)actual_h, planeBitDepth);
+
+  size_t out_stride;
+  uint8_t* out_plane = heif_image_get_plane2(*out_image, channel, &out_stride);
+
+  tmsize_t tile_buf_size = TIFFTileSize(tif);
+  std::vector<uint8_t> tile_buf(tile_buf_size);
+
+  if (m_planar_config == PLANARCONFIG_CONTIG) {
+    tmsize_t read = TIFFReadEncodedTile(tif, TIFFComputeTile(tif, tx * m_tile_width, ty * m_tile_height, 0, 0),
+                                        tile_buf.data(), tile_buf_size);
+    if (read < 0) {
+      heif_image_release(*out_image);
+      *out_image = nullptr;
+      return {heif_error_Invalid_input, heif_suberror_Unspecified, "Failed to read TIFF tile"};
+    }
+
+    if (m_bits_per_sample <= 8) {
+      for (uint32_t row = 0; row < actual_h; row++) {
+        uint8_t* dst = out_plane + row * out_stride;
+        uint8_t* src = tile_buf.data() + row * m_tile_width * m_samples_per_pixel;
+        if (outSpp == m_samples_per_pixel) {
+          memcpy(dst, src, actual_w * outSpp);
+        }
+        else {
+          for (uint32_t x = 0; x < actual_w; x++) {
+            memcpy(dst + x * outSpp, src + x * m_samples_per_pixel, outSpp);
+          }
+        }
+      }
+    }
+    else if (output_bit_depth <= 8) {
+      for (uint32_t row = 0; row < actual_h; row++) {
+        uint8_t* dst = out_plane + row * out_stride;
+        uint16_t* src = reinterpret_cast<uint16_t*>(tile_buf.data() + row * m_tile_width * m_samples_per_pixel * 2);
+        if (outSpp == m_samples_per_pixel) {
+          for (uint32_t x = 0; x < actual_w * outSpp; x++) {
+            dst[x] = static_cast<uint8_t>(src[x] >> 8);
+          }
+        }
+        else {
+          for (uint32_t x = 0; x < actual_w; x++) {
+            for (uint16_t c = 0; c < outSpp; c++) {
+              dst[x * outSpp + c] = static_cast<uint8_t>(src[x * m_samples_per_pixel + c] >> 8);
+            }
+          }
+        }
+      }
+    }
+    else {
+      int bdShift = 16 - output_bit_depth;
+      for (uint32_t row = 0; row < actual_h; row++) {
+        uint16_t* dst = reinterpret_cast<uint16_t*>(out_plane + row * out_stride);
+        uint16_t* src = reinterpret_cast<uint16_t*>(tile_buf.data() + row * m_tile_width * m_samples_per_pixel * 2);
+        if (outSpp == m_samples_per_pixel) {
+          if (bdShift == 0) {
+            memcpy(dst, src, actual_w * outSpp * 2);
+          }
+          else {
+            for (uint32_t x = 0; x < actual_w * outSpp; x++) {
+              dst[x] = static_cast<uint16_t>(src[x] >> bdShift);
+            }
+          }
+        }
+        else {
+          for (uint32_t x = 0; x < actual_w; x++) {
+            for (uint16_t c = 0; c < outSpp; c++) {
+              dst[x * outSpp + c] = static_cast<uint16_t>(src[x * m_samples_per_pixel + c] >> bdShift);
+            }
+          }
+        }
+      }
+    }
+  }
+  else {
+    // PLANARCONFIG_SEPARATE
+    for (uint16_t s = 0; s < outSpp; s++) {
+      tmsize_t read = TIFFReadEncodedTile(tif, TIFFComputeTile(tif, tx * m_tile_width, ty * m_tile_height, 0, s),
+                                          tile_buf.data(), tile_buf_size);
+      if (read < 0) {
+        heif_image_release(*out_image);
+        *out_image = nullptr;
+        return {heif_error_Invalid_input, heif_suberror_Unspecified, "Failed to read TIFF tile"};
+      }
+
+      if (m_bits_per_sample <= 8) {
+        for (uint32_t row = 0; row < actual_h; row++) {
+          uint8_t* dst = out_plane + row * out_stride + s;
+          uint8_t* src = tile_buf.data() + row * m_tile_width;
+          for (uint32_t x = 0; x < actual_w; x++) {
+            dst[x * outSpp] = src[x];
+          }
+        }
+      }
+      else if (output_bit_depth <= 8) {
+        for (uint32_t row = 0; row < actual_h; row++) {
+          uint8_t* dst = out_plane + row * out_stride + s;
+          uint16_t* src = reinterpret_cast<uint16_t*>(tile_buf.data() + row * m_tile_width * 2);
+          for (uint32_t x = 0; x < actual_w; x++) {
+            dst[x * outSpp] = static_cast<uint8_t>(src[x] >> 8);
+          }
+        }
+      }
+      else {
+        int bdShift = 16 - output_bit_depth;
+        for (uint32_t row = 0; row < actual_h; row++) {
+          uint16_t* dst = reinterpret_cast<uint16_t*>(out_plane + row * out_stride) + s;
+          uint16_t* src = reinterpret_cast<uint16_t*>(tile_buf.data() + row * m_tile_width * 2);
+          for (uint32_t x = 0; x < actual_w; x++) {
+            dst[x * outSpp] = static_cast<uint16_t>(src[x] >> bdShift);
+          }
+        }
+      }
+    }
+  }
+
+  return heif_error_ok;
+}
+
+
+void TiledTiffReader::readExif(InputImage* input_image)
+{
+  TIFF* tif = static_cast<TIFF*>(m_tif.get());
+  std::unique_ptr<ExifTags> tags = ExifTags::Parse(tif);
+  if (tags) {
+    tags->Encode(&(input_image->exif));
+  }
+}
+
+/*
+void TiledTiffReader::printGeoInfo(const char* filename) const
+{
+#if HAVE_GEOTIFF
+  TIFF* tif = XTIFFOpen(filename, "r");
+  if (!tif) {
+    return;
+  }
+
+  GTIF* gtif = GTIFNew(tif);
+  if (!gtif) {
+    XTIFFClose(tif);
+    return;
+  }
+
+  // Get EPSG code
+  unsigned short epsg = 0;
+  GTIFKeyGetSHORT(gtif, ProjectedCSTypeGeoKey, &epsg, 0, 1);
+
+  // Get CRS citation string
+  char citation[256] = {};
+  GTIFKeyGetASCII(gtif, GTCitationGeoKey, citation, sizeof(citation));
+  if (citation[0] == '\0') {
+    GTIFKeyGetASCII(gtif, GeogCitationGeoKey, citation, sizeof(citation));
+  }
+
+  if (epsg > 0 || citation[0] != '\0') {
+    std::cout << "GeoTIFF: ";
+    if (epsg > 0) {
+      std::cout << "EPSG:" << epsg;
+    }
+    if (citation[0] != '\0') {
+      if (epsg > 0) {
+        std::cout << " (" << citation << ")";
+      }
+      else {
+        std::cout << citation;
+      }
+    }
+    std::cout << "\n";
+  }
+
+  // Get pixel scale
+  uint16_t scale_count = 0;
+  double* scale = nullptr;
+  if (TIFFGetField(tif, TIFFTAG_GEOPIXELSCALE, &scale_count, &scale) && scale_count >= 2) {
+    std::cout << std::fixed << std::setprecision(3)
+              << "  pixel scale: " << scale[0] << " x " << scale[1] << "\n";
+  }
+
+  // Get tiepoint (origin)
+  uint16_t tp_count = 0;
+  double* tiepoints = nullptr;
+  if (TIFFGetField(tif, TIFFTAG_GEOTIEPOINTS, &tp_count, &tiepoints) && tp_count >= 6) {
+    std::cout << std::fixed << std::setprecision(3)
+              << "  origin: (" << tiepoints[3] << ", " << tiepoints[4] << ")\n";
+  }
+
+  GTIFFree(gtif);
+  XTIFFClose(tif);
+#endif
+
+  if (!m_overviews.empty()) {
+    std::cout << "  overviews: ";
+    for (size_t i = 0; i < m_overviews.size(); i++) {
+      if (i > 0) std::cout << ", ";
+      std::cout << m_overviews[i].image_width << "x" << m_overviews[i].image_height;
+    }
+    std::cout << "\n";
+  }
+}
+*/
\ No newline at end of file
diff --git a/heifio/decoder_tiff.h b/heifio/decoder_tiff.h
new file mode 100644
index 0000000000..487ced5eb8
--- /dev/null
+++ b/heifio/decoder_tiff.h
@@ -0,0 +1,97 @@
+/*
+  libheif example application "heif".
+
+  MIT License
+
+  Copyright (c) 2024 Joachim Bauch <bauch@struktur.de>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#ifndef LIBHEIF_DECODER_TIFF_H
+#define LIBHEIF_DECODER_TIFF_H
+
+#include "decoder.h"
+#include "libheif/heif.h"
+#include <memory>
+#include <cstdint>
+#include <vector>
+
+struct YCbCrInfo {
+  bool is_ycbcr = false;
+  uint16_t horiz_sub = 1;  // horizontal subsampling factor
+  uint16_t vert_sub = 1;   // vertical subsampling factor
+};
+
+LIBHEIF_API
+heif_error loadTIFF(const char *filename, int output_bit_depth, InputImage *input_image);
+
+class LIBHEIF_API TiledTiffReader {
+public:
+  ~TiledTiffReader();
+
+  struct OverviewInfo {
+    uint32_t dir_index;
+    uint32_t image_width;
+    uint32_t image_height;
+    uint32_t tile_width;
+    uint32_t tile_height;
+  };
+
+  // Returns a reader if the file is a tiled TIFF. If the TIFF is not tiled,
+  // returns nullptr with heif_error_Ok (caller should fall back to loadTIFF).
+  static std::unique_ptr<TiledTiffReader> open(const char* filename, heif_error* out_err);
+
+  uint32_t imageWidth() const { return m_image_width; }
+  uint32_t imageHeight() const { return m_image_height; }
+  uint32_t tileWidth() const { return m_tile_width; }
+  uint32_t tileHeight() const { return m_tile_height; }
+  uint32_t nColumns() const { return m_n_columns; }
+  uint32_t nRows() const { return m_n_rows; }
+
+  const std::vector<OverviewInfo>& overviews() const { return m_overviews; }
+  bool setDirectory(uint32_t dir_index);
+
+  uint16_t bitsPerSample() const { return m_bits_per_sample; }
+  uint16_t sampleFormat() const { return m_sample_format; }
+
+  heif_error readTile(uint32_t tx, uint32_t ty, int output_bit_depth, heif_image** out_image);
+  void readExif(InputImage* input_image);
+  //void printGeoInfo(const char* filename) const;
+
+private:
+  TiledTiffReader() = default;
+
+  struct TiffCloser { void operator()(void* tif) const; };
+  std::unique_ptr<void, TiffCloser> m_tif;
+
+  uint32_t m_image_width = 0, m_image_height = 0;
+  uint32_t m_tile_width = 0, m_tile_height = 0;
+  uint32_t m_n_columns = 0, m_n_rows = 0;
+  uint16_t m_samples_per_pixel = 0;
+  uint16_t m_bits_per_sample = 0;
+  uint16_t m_planar_config = 0;
+  uint16_t m_sample_format = 1; // SAMPLEFORMAT_UINT
+  bool m_has_alpha = false;
+  YCbCrInfo m_ycbcr;
+
+  std::vector<OverviewInfo> m_overviews;
+};
+
+#endif // LIBHEIF_DECODER_TIFF_H
diff --git a/heifio/decoder_y4m.cc b/heifio/decoder_y4m.cc
new file mode 100644
index 0000000000..599e86419a
--- /dev/null
+++ b/heifio/decoder_y4m.cc
@@ -0,0 +1,149 @@
+/*
+  libheif example application "heif".
+
+  MIT License
+
+  Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#include "decoder_y4m.h"
+#include <iostream>
+#include <fstream>
+#include <memory>
+#include <string>
+
+static struct heif_error heif_error_ok = {heif_error_Ok, heif_suberror_Unspecified, "Success"};
+
+heif_error loadY4M(const char *filename, InputImage *input_image)
+{
+
+  struct heif_image* image = nullptr;
+
+
+  // open input file
+
+  std::ifstream istr(filename, std::ios_base::binary);
+  if (istr.fail()) {
+    struct heif_error err = {
+      .code = heif_error_Invalid_input,
+      .subcode = heif_suberror_Unspecified,
+      .message = "Cannot open Y4M file"};
+    return err;
+  }
+
+
+  std::string header;
+  getline(istr, header);
+
+  if (header.find("YUV4MPEG2 ") != 0) {
+    struct heif_error err = {
+      .code = heif_error_Unsupported_feature,
+      .subcode = heif_suberror_Unspecified,
+      .message = "Input is not a Y4M file."};
+    return err;
+  }
+
+  int w = -1;
+  int h = -1;
+
+  size_t pos = 0;
+  for (;;) {
+    pos = header.find(' ', pos + 1) + 1;
+    if (pos == std::string::npos) {
+      break;
+    }
+
+    size_t end = header.find_first_of(" \n", pos + 1);
+    if (end == std::string::npos) {
+      break;
+    }
+
+    if (end - pos <= 1) {
+      struct heif_error err = {
+        .code = heif_error_Unsupported_feature,
+        .subcode = heif_suberror_Unspecified,
+        .message = "Header format error in Y4M file."};
+      return err;
+    }
+
+    char tag = header[pos];
+    std::string value = header.substr(pos + 1, end - pos - 1);
+    if (tag == 'W') {
+      w = atoi(value.c_str());
+    }
+    else if (tag == 'H') {
+      h = atoi(value.c_str());
+    }
+  }
+
+  std::string frameheader;
+  getline(istr, frameheader);
+
+  if (frameheader != "FRAME") {
+    struct heif_error err = {
+        .code = heif_error_Unsupported_feature,
+        .subcode = heif_suberror_Unspecified,
+        .message = "Y4M misses the frame header."};
+    return err;
+  }
+
+  if (w < 0 || h < 0) {
+    struct heif_error err = {
+        .code = heif_error_Unsupported_feature,
+        .subcode = heif_suberror_Unspecified,
+        .message = "Y4M has invalid frame size."};
+    return err;
+  }
+
+  struct heif_error err = heif_image_create(w, h,
+                                            heif_colorspace_YCbCr,
+                                            heif_chroma_420,
+                                            &image);
+  if (err.code != heif_error_Ok) {
+    return err;
+  }
+
+  heif_image_add_plane(image, heif_channel_Y, w, h, 8);
+  heif_image_add_plane(image, heif_channel_Cb, (w + 1) / 2, (h + 1) / 2, 8);
+  heif_image_add_plane(image, heif_channel_Cr, (w + 1) / 2, (h + 1) / 2, 8);
+
+  size_t y_stride, cb_stride, cr_stride;
+  uint8_t* py = heif_image_get_plane2(image, heif_channel_Y, &y_stride);
+  uint8_t* pcb = heif_image_get_plane2(image, heif_channel_Cb, &cb_stride);
+  uint8_t* pcr = heif_image_get_plane2(image, heif_channel_Cr, &cr_stride);
+
+  for (int y = 0; y < h; y++) {
+    istr.read((char*) (py + y * y_stride), w);
+  }
+
+  for (int y = 0; y < (h + 1) / 2; y++) {
+    istr.read((char*) (pcb + y * cb_stride), (w + 1) / 2);
+  }
+
+  for (int y = 0; y < (h + 1) / 2; y++) {
+    istr.read((char*) (pcr + y * cr_stride), (w + 1) / 2);
+  }
+
+  input_image->image = std::shared_ptr<heif_image>(image,
+                                                   [](heif_image* img) { heif_image_release(img); });
+
+  return heif_error_ok;
+}
diff --git a/heifio/decoder_y4m.h b/heifio/decoder_y4m.h
new file mode 100644
index 0000000000..91a7a5aadf
--- /dev/null
+++ b/heifio/decoder_y4m.h
@@ -0,0 +1,43 @@
+/*
+  libheif example application "heif".
+
+  MIT License
+
+  Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#ifndef LIBHEIF_DECODER_Y4M_H
+#define LIBHEIF_DECODER_Y4M_H
+
+#include "decoder.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+LIBHEIF_API
+heif_error loadY4M(const char *filename, InputImage *input_image);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif //LIBHEIF_DECODER_Y4M_H
diff --git a/examples/encoder.cc b/heifio/encoder.cc
similarity index 70%
rename from examples/encoder.cc
rename to heifio/encoder.cc
index 3ba70673ea..756696cba2 100644
--- a/examples/encoder.cc
+++ b/heifio/encoder.cc
@@ -1,6 +1,6 @@
 /*
-  libheif example application "convert".
-  This file is part of convert, an example application using libheif.
+  libheif example application.
+  This file is part of heif-dec, an example application using libheif.
 
   MIT License
 
@@ -24,11 +24,9 @@
   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
   SOFTWARE.
 */
-#if defined(HAVE_CONFIG_H)
-#include "config.h"
-#endif
 
 #include <stdlib.h>
+#include <cstring>
 
 #include "encoder.h"
 
@@ -70,3 +68,31 @@ uint8_t* Encoder::GetExifMetaData(const struct heif_image_handle* handle, size_t
 
   return nullptr;
 }
+
+
+std::vector<uint8_t> Encoder::get_xmp_metadata(const struct heif_image_handle* handle)
+{
+  std::vector<uint8_t> xmp;
+
+  heif_item_id metadata_ids[16];
+  int count = heif_image_handle_get_list_of_metadata_block_IDs(handle, nullptr, metadata_ids, 16);
+
+  for (int i = 0; i < count; i++) {
+    if (strcmp(heif_image_handle_get_metadata_type(handle, metadata_ids[i]), "mime") == 0 &&
+        strcmp(heif_image_handle_get_metadata_content_type(handle, metadata_ids[i]), "application/rdf+xml") == 0) {
+
+      size_t datasize = heif_image_handle_get_metadata_size(handle, metadata_ids[i]);
+      xmp.resize(datasize);
+
+      heif_error error = heif_image_handle_get_metadata(handle, metadata_ids[i], xmp.data());
+      if (error.code != heif_error_Ok) {
+        // TODO: return error
+        return {};
+      }
+
+      return xmp;
+    }
+  }
+
+  return {};
+}
diff --git a/examples/encoder.h b/heifio/encoder.h
similarity index 67%
rename from examples/encoder.h
rename to heifio/encoder.h
index e1afd35782..04579d3f17 100644
--- a/examples/encoder.h
+++ b/heifio/encoder.h
@@ -1,9 +1,10 @@
 /*
-  libheif example application "convert".
+  libheif example application.
 
   MIT License
 
   Copyright (c) 2017 struktur AG, Joachim Bauch <bauch@struktur.de>
+  Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
 
   Permission is hereby granted, free of charge, to any person obtaining a copy
   of this software and associated documentation files (the "Software"), to deal
@@ -29,31 +30,36 @@
 #include <string>
 #include <memory>
 
-#include <libheif/heif.h>
+#include "libheif/heif.h"
+#include <vector>
+
 
 class Encoder
 {
 public:
-  virtual ~Encoder()
-  {}
+  virtual ~Encoder() = default;
 
   virtual heif_colorspace colorspace(bool has_alpha) const = 0;
 
   virtual heif_chroma chroma(bool has_alpha, int bit_depth) const = 0;
 
-  virtual void UpdateDecodingOptions(const struct heif_image_handle* handle,
-                                     struct heif_decoding_options* options) const
+  virtual bool supports_alpha() const = 0;
+
+  virtual void UpdateDecodingOptions(const heif_image_handle* handle,
+                                     heif_decoding_options* options) const
   {
     // Override if necessary.
   }
 
-  virtual bool Encode(const struct heif_image_handle* handle,
-                      const struct heif_image* image, const std::string& filename) = 0;
+  virtual bool Encode(const heif_image_handle* handle,
+                      const heif_image* image, const std::string& filename) = 0;
 
 protected:
-  static bool HasExifMetaData(const struct heif_image_handle* handle);
+  static bool HasExifMetaData(const heif_image_handle* handle);
+
+  static uint8_t* GetExifMetaData(const heif_image_handle* handle, size_t* size);
 
-  static uint8_t* GetExifMetaData(const struct heif_image_handle* handle, size_t* size);
+  static std::vector<uint8_t> get_xmp_metadata(const heif_image_handle* handle);
 };
 
 #endif  // EXAMPLE_ENCODER_H
diff --git a/examples/encoder_jpeg.cc b/heifio/encoder_jpeg.cc
similarity index 57%
rename from examples/encoder_jpeg.cc
rename to heifio/encoder_jpeg.cc
index 64c772458f..c38d4cb4bc 100644
--- a/examples/encoder_jpeg.cc
+++ b/heifio/encoder_jpeg.cc
@@ -1,5 +1,5 @@
 /*
-  libheif example application "convert".
+  libheif example application.
 
   MIT License
 
@@ -23,17 +23,31 @@
   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
   SOFTWARE.
 */
-#if defined(HAVE_CONFIG_H)
-#include "config.h"
-#endif
 
-#include <assert.h>
-#include <errno.h>
-#include <string.h>
+#include <cerrno>
+#include <cstring>
 
-#include <iostream>
+#include <vector>
+#include <limits>
 
 #include "encoder_jpeg.h"
+#include "exif.h"
+
+#include <jpeglib.h>
+
+#include "common_utils.h"
+
+#define JPEG_XMP_MARKER  (JPEG_APP0+1)  /* JPEG marker code for XMP */
+#define JPEG_XMP_MARKER_ID "http://ns.adobe.com/xap/1.0/"
+
+
+struct ErrorHandler
+{
+  struct jpeg_error_mgr pub;  /* "public" fields */
+  jmp_buf setjmp_buffer;  /* for return to caller */
+};
+
+
 
 JpegEncoder::JpegEncoder(int quality) : quality_(quality)
 {
@@ -45,25 +59,22 @@ JpegEncoder::JpegEncoder(int quality) : quality_(quality)
 void JpegEncoder::UpdateDecodingOptions(const struct heif_image_handle* handle,
                                         struct heif_decoding_options* options) const
 {
-  if (HasExifMetaData(handle)) {
-    options->ignore_transformations = 1;
-  }
-
   options->convert_hdr_to_8bit = 1;
 }
 
 // static
-void JpegEncoder::OnJpegError(j_common_ptr cinfo)
+static void OnJpegError(j_common_ptr cinfo)
 {
   ErrorHandler* handler = reinterpret_cast<ErrorHandler*>(cinfo->err);
   longjmp(handler->setjmp_buffer, 1);
 }
 
+#define MAX_BYTES_IN_MARKER  65533      /* maximum data len of a JPEG marker */
+
 #if !defined(HAVE_JPEG_WRITE_ICC_PROFILE)
 
 #define ICC_MARKER  (JPEG_APP0 + 2)     /* JPEG marker code for ICC */
 #define ICC_OVERHEAD_LEN  14            /* size of non-profile data in APP2 */
-#define MAX_BYTES_IN_MARKER  65533      /* maximum data len of a JPEG marker */
 #define MAX_DATA_BYTES_IN_MARKER (MAX_BYTES_IN_MARKER - ICC_OVERHEAD_LEN)
 
 /*
@@ -143,7 +154,7 @@ bool JpegEncoder::Encode(const struct heif_image_handle* handle,
   struct jpeg_compress_struct cinfo;
   struct ErrorHandler jerr;
   cinfo.err = jpeg_std_error(reinterpret_cast<struct jpeg_error_mgr*>(&jerr));
-  jerr.pub.error_exit = &JpegEncoder::OnJpegError;
+  jerr.pub.error_exit = &OnJpegError;
   if (setjmp(jerr.setjmp_buffer)) {
     cinfo.err->output_message(reinterpret_cast<j_common_ptr>(&cinfo));
     jpeg_destroy_compress(&cinfo);
@@ -164,39 +175,123 @@ bool JpegEncoder::Encode(const struct heif_image_handle* handle,
   static const boolean kWriteAllTables = TRUE;
   jpeg_start_compress(&cinfo, kWriteAllTables);
 
-  size_t exifsize = 0;
-  uint8_t* exifdata = GetExifMetaData(handle, &exifsize);
-  if (exifdata && exifsize > 4) {
-    static const uint8_t kExifMarker = JPEG_APP0 + 1;
-    jpeg_write_marker(&cinfo, kExifMarker, exifdata + 4,
-                      static_cast<unsigned int>(exifsize - 4));
-    free(exifdata);
+  // --- Write EXIF
+
+  if (handle) {
+    size_t exifsize = 0;
+    uint8_t* exifdata = GetExifMetaData(handle, &exifsize);
+    if (exifdata) {
+      if (exifsize > 4) {
+        static const uint8_t kExifMarker = JPEG_APP0 + 1;
+
+        uint32_t skip = four_bytes_to_uint32(exifdata[0], exifdata[1], exifdata[2], exifdata[3]);
+        if (skip > (exifsize - 4)) {
+          fprintf(stderr, "Invalid EXIF data (offset too large)\n");
+          free(exifdata);
+          jpeg_destroy_compress(&cinfo);
+          fclose(fp);
+          return false;
+        }
+        skip += 4;
+
+        uint8_t* ptr = exifdata + skip;
+        size_t size = exifsize - skip;
+
+        if (size > std::numeric_limits<uint32_t>::max()) {
+          fprintf(stderr, "EXIF larger than 4GB is not supported");
+          free(exifdata);
+          jpeg_destroy_compress(&cinfo);
+          fclose(fp);
+          return false;
+        }
+
+        auto size32 = static_cast<uint32_t>(size);
+
+        // libheif by default normalizes the image orientation, so that we have to set the EXIF Orientation to "Horizontal (normal)"
+        modify_exif_orientation_tag_if_it_exists(ptr, size32, 1);
+        overwrite_exif_image_size_if_it_exists(ptr, size32, cinfo.image_width, cinfo.image_height);
+
+        // We have to limit the size for the memcpy, otherwise GCC warns that we exceed the maximum size.
+        if (size > 0x1000000) {
+          size = 0x1000000;
+        }
+
+        std::vector<uint8_t> jpegExifMarkerData(6 + size);
+        memcpy(jpegExifMarkerData.data() + 6, ptr, size);
+        jpegExifMarkerData[0] = 'E';
+        jpegExifMarkerData[1] = 'x';
+        jpegExifMarkerData[2] = 'i';
+        jpegExifMarkerData[3] = 'f';
+        jpegExifMarkerData[4] = 0;
+        jpegExifMarkerData[5] = 0;
+
+        ptr = jpegExifMarkerData.data();
+        size = jpegExifMarkerData.size();
+
+        while (size > MAX_BYTES_IN_MARKER) {
+          jpeg_write_marker(&cinfo, kExifMarker, ptr,
+                            static_cast<unsigned int>(MAX_BYTES_IN_MARKER));
+
+          ptr += MAX_BYTES_IN_MARKER;
+          size -= MAX_BYTES_IN_MARKER;
+        }
+
+        jpeg_write_marker(&cinfo, kExifMarker, ptr,
+                          static_cast<unsigned int>(size));
+      }
+
+      free(exifdata);
+    }
   }
 
-  size_t profile_size = heif_image_handle_get_raw_color_profile_size(handle);
-  if (profile_size > 0) {
-    uint8_t* profile_data = static_cast<uint8_t*>(malloc(profile_size));
-    heif_image_handle_get_raw_color_profile(handle, profile_data);
-    jpeg_write_icc_profile(&cinfo, profile_data, (unsigned int) profile_size);
-    free(profile_data);
-  }
+  // --- Write XMP
 
+  // spec: https://raw.githubusercontent.com/adobe/xmp-docs/master/XMPSpecifications/XMPSpecificationPart3.pdf
 
-  if (heif_image_get_bits_per_pixel(image, heif_channel_Y) != 8) {
-    fprintf(stderr, "JPEG writer cannot handle image with >8 bpp.\n");
-    return false;
+  if (handle) {
+    auto xmp = get_xmp_metadata(handle);
+    if (xmp.size() > 65502) {
+      fprintf(stderr, "XMP data too large, ExtendedXMP is not supported yet.\n");
+    }
+    else if (!xmp.empty()) {
+      std::vector<uint8_t> xmpWithId;
+      xmpWithId.resize(xmp.size() + strlen(JPEG_XMP_MARKER_ID) + 1);
+      strcpy((char*) xmpWithId.data(), JPEG_XMP_MARKER_ID);
+      memcpy(xmpWithId.data() + strlen(JPEG_XMP_MARKER_ID) + 1, xmp.data(), xmp.size());
+
+      jpeg_write_marker(&cinfo, JPEG_XMP_MARKER, xmpWithId.data(), static_cast<unsigned int>(xmpWithId.size()));
+    }
   }
 
+  // --- Write ICC
+
+  if (handle) {
+    size_t profile_size = heif_image_handle_get_raw_color_profile_size(handle);
+    if (profile_size > 0) {
+      uint8_t* profile_data = static_cast<uint8_t*>(malloc(profile_size));
+      heif_image_handle_get_raw_color_profile(handle, profile_data);
+      jpeg_write_icc_profile(&cinfo, profile_data, (unsigned int) profile_size);
+      free(profile_data);
+    }
+
+
+    if (heif_image_get_bits_per_pixel(image, heif_channel_Y) != 8) {
+      fprintf(stderr, "JPEG writer cannot handle image with >8 bpp.\n");
+      jpeg_destroy_compress(&cinfo);
+      fclose(fp);
+      return false;
+    }
+  }
 
-  int stride_y;
-  const uint8_t* row_y = heif_image_get_plane_readonly(image, heif_channel_Y,
-                                                       &stride_y);
-  int stride_u;
-  const uint8_t* row_u = heif_image_get_plane_readonly(image, heif_channel_Cb,
-                                                       &stride_u);
-  int stride_v;
-  const uint8_t* row_v = heif_image_get_plane_readonly(image, heif_channel_Cr,
-                                                       &stride_v);
+  size_t stride_y;
+  const uint8_t* row_y = heif_image_get_plane_readonly2(image, heif_channel_Y,
+                                                        &stride_y);
+  size_t stride_u;
+  const uint8_t* row_u = heif_image_get_plane_readonly2(image, heif_channel_Cb,
+                                                        &stride_u);
+  size_t stride_v;
+  const uint8_t* row_v = heif_image_get_plane_readonly2(image, heif_channel_Cr,
+                                                        &stride_v);
 
   JSAMPARRAY buffer = cinfo.mem->alloc_sarray(
       reinterpret_cast<j_common_ptr>(&cinfo), JPOOL_IMAGE,
diff --git a/examples/encoder_jpeg.h b/heifio/encoder_jpeg.h
similarity index 75%
rename from examples/encoder_jpeg.h
rename to heifio/encoder_jpeg.h
index c6b02966e6..a571ba901c 100644
--- a/examples/encoder_jpeg.h
+++ b/heifio/encoder_jpeg.h
@@ -1,9 +1,10 @@
 /*
-  libheif example application "convert".
+  libheif example application.
 
   MIT License
 
   Copyright (c) 2017 struktur AG, Joachim Bauch <bauch@struktur.de>
+  Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
 
   Permission is hereby granted, free of charge, to any person obtaining a copy
   of this software and associated documentation files (the "Software"), to deal
@@ -30,8 +31,6 @@
 #include <cstddef>
 #include <cstdio>
 
-#include <jpeglib.h>
-
 #include <string>
 
 #include "encoder.h"
@@ -51,23 +50,17 @@ class JpegEncoder : public Encoder
     return heif_chroma_420;
   }
 
-  void UpdateDecodingOptions(const struct heif_image_handle* handle,
-                             struct heif_decoding_options* options) const override;
+  bool supports_alpha() const override { return false; }
+
+  void UpdateDecodingOptions(const heif_image_handle* handle,
+                             heif_decoding_options* options) const override;
 
-  bool Encode(const struct heif_image_handle* handle,
-              const struct heif_image* image, const std::string& filename) override;
+  bool Encode(const heif_image_handle* handle,
+              const heif_image* image, const std::string& filename) override;
 
 private:
   static const int kDefaultQuality = 90;
 
-  struct ErrorHandler
-  {
-    struct jpeg_error_mgr pub;  /* "public" fields */
-    jmp_buf setjmp_buffer;  /* for return to caller */
-  };
-
-  static void OnJpegError(j_common_ptr cinfo);
-
   int quality_;
 };
 
diff --git a/heifio/encoder_png.cc b/heifio/encoder_png.cc
new file mode 100644
index 0000000000..9f82466ecf
--- /dev/null
+++ b/heifio/encoder_png.cc
@@ -0,0 +1,247 @@
+/*
+  libheif example application.
+
+  MIT License
+
+  Copyright (c) 2017 struktur AG, Joachim Bauch <bauch@struktur.de>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+#include <cerrno>
+#include <png.h>
+#include <cstring>
+#include <cstdlib>
+#include <vector>
+
+#include "encoder_png.h"
+
+#include "common_utils.h"
+#include "exif.h"
+
+PngEncoder::PngEncoder() = default;
+
+// Returns false if ICC profile recognized invalid and could not be fixed.
+bool fix_icc_profile(uint8_t* profile_data, uint32_t& profile_size)
+{
+  if (profile_size < 128) {
+    return false;
+  }
+
+
+  // --- check that profile size specified in header matches the real size
+
+  uint32_t size_in_header = four_bytes_to_uint32(profile_data[0],
+                                                 profile_data[1],
+                                                 profile_data[2],
+                                                 profile_data[3]);
+
+  if (size_in_header != profile_size) {
+
+    // Size in header is smaller than actual size, but alignment indicates that it might
+    // be correct. Replace real data length with size in header.
+    if (size_in_header < profile_size && (size_in_header & 3)==0) {
+      fprintf(stderr, "Input ICC profile has wrong size in header (%d instead of %d). Skipping extra bytes at the end. "
+              "Note that this may still be incorrect and the ICC profile may be broken.\n", size_in_header, profile_size);
+
+      profile_size = size_in_header;
+    }
+    else {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+
+bool PngEncoder::Encode(const heif_image_handle* handle,
+                        const heif_image* image, const std::string& filename)
+{
+  png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, nullptr,
+                                                nullptr, nullptr);
+  if (!png_ptr) {
+    fprintf(stderr, "libpng initialization failed (1)\n");
+    return false;
+  }
+
+  png_infop info_ptr = png_create_info_struct(png_ptr);
+  if (!info_ptr) {
+    png_destroy_write_struct(&png_ptr, nullptr);
+    fprintf(stderr, "libpng initialization failed (2)\n");
+    return false;
+  }
+
+  if (m_compression_level != -1) {
+    png_set_compression_level(png_ptr, m_compression_level);
+  }
+
+  FILE* fp = fopen(filename.c_str(), "wb");
+  if (!fp) {
+    fprintf(stderr, "Can't open %s: %s\n", filename.c_str(), strerror(errno));
+    png_destroy_write_struct(&png_ptr, &info_ptr);
+    return false;
+  }
+
+  if (setjmp(png_jmpbuf(png_ptr))) {
+    png_destroy_write_struct(&png_ptr, &info_ptr);
+    fclose(fp);
+    fprintf(stderr, "Error while encoding image\n");
+    return false;
+  }
+
+  png_init_io(png_ptr, fp);
+
+  bool withAlpha = (heif_image_get_chroma_format(image) == heif_chroma_interleaved_RGBA ||
+                    heif_image_get_chroma_format(image) == heif_chroma_interleaved_RRGGBBAA_BE);
+
+  int width = heif_image_get_width(image, heif_channel_interleaved);
+  int height = heif_image_get_height(image, heif_channel_interleaved);
+
+  int bitDepth;
+  int input_bpp = heif_image_get_bits_per_pixel_range(image, heif_channel_interleaved);
+  if (input_bpp > 8) {
+    bitDepth = 16;
+  }
+  else {
+    bitDepth = 8;
+  }
+
+  const int colorType = withAlpha ? PNG_COLOR_TYPE_RGBA : PNG_COLOR_TYPE_RGB;
+
+  png_set_IHDR(png_ptr, info_ptr, width, height, bitDepth, colorType,
+               PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
+
+  // --- write ICC profile
+
+  if (handle) {
+    uint32_t profile_size = static_cast<uint32_t>(heif_image_handle_get_raw_color_profile_size(handle));
+    if (profile_size > 0) {
+      uint8_t* profile_data = static_cast<uint8_t*>(malloc(profile_size));
+      heif_image_handle_get_raw_color_profile(handle, profile_data);
+      if (fix_icc_profile(profile_data, profile_size)) {
+        char profile_name[] = "unknown";
+        png_set_iCCP(png_ptr, info_ptr, profile_name, PNG_COMPRESSION_TYPE_BASE,
+#if PNG_LIBPNG_VER < 10500
+              (png_charp)profile_data,
+#else
+                     (png_const_bytep) profile_data,
+#endif
+                     (png_uint_32) profile_size);
+      }
+      else {
+        fprintf(stderr, "Invalid ICC profile. Writing PNG file without ICC.\n");
+      }
+      free(profile_data);
+    }
+  }
+
+  // --- write EXIF metadata
+
+#ifdef PNG_eXIf_SUPPORTED
+  if (handle) {
+    size_t exifsize = 0;
+    uint8_t* exifdata = GetExifMetaData(handle, &exifsize);
+    if (exifdata) {
+      if (exifsize > 4) {
+        uint32_t skip = four_bytes_to_uint32(exifdata[0], exifdata[1], exifdata[2], exifdata[3]);
+        if (skip < (exifsize - 4)) {
+          skip += 4;
+          uint8_t* ptr = exifdata + skip;
+          size_t size = exifsize - skip;
+
+          // libheif by default normalizes the image orientation, so that we have to set the EXIF Orientation to "Horizontal (normal)"
+          modify_exif_orientation_tag_if_it_exists(ptr, (int) size, 1);
+          overwrite_exif_image_size_if_it_exists(ptr, (int) size, width, height);
+
+          png_set_eXIf_1(png_ptr, info_ptr, (png_uint_32) size, ptr);
+        }
+      }
+
+      free(exifdata);
+    }
+  }
+#endif
+
+  // --- write XMP metadata
+
+#ifdef PNG_iTXt_SUPPORTED
+  if (handle) {
+    // spec: https://raw.githubusercontent.com/adobe/xmp-docs/master/XMPSpecifications/XMPSpecificationPart3.pdf
+    std::vector<uint8_t> xmp = get_xmp_metadata(handle);
+    if (!xmp.empty()) {
+      // make sure that XMP string is always null terminated.
+      if (xmp.back() != 0) {
+        xmp.push_back(0);
+      }
+
+      // compute XMP string length
+      size_t text_length = 0;
+      while (xmp[text_length] != 0) {
+        text_length++;
+      }
+
+      png_text xmp_text{}; // important to zero-initialize the structure so that the remaining fields are NULL !
+      xmp_text.compression = PNG_ITXT_COMPRESSION_NONE;
+      xmp_text.key = (char*) "XML:com.adobe.xmp";
+      xmp_text.text = (char*) xmp.data();
+      xmp_text.text_length = 0; // should be 0 for ITXT according the libpng documentation
+      xmp_text.itxt_length = text_length;
+      png_set_text(png_ptr, info_ptr, &xmp_text, 1);
+    }
+  }
+#endif
+
+  png_write_info(png_ptr, info_ptr);
+
+  uint8_t** row_pointers = new uint8_t* [height];
+
+  size_t stride_rgb;
+  const uint8_t* row_rgb = heif_image_get_plane_readonly2(image,
+                                                          heif_channel_interleaved, &stride_rgb);
+
+  for (int y = 0; y < height; ++y) {
+    row_pointers[y] = const_cast<uint8_t*>(&row_rgb[y * stride_rgb]);
+  }
+
+  if (bitDepth == 16) {
+    // shift image data to full 16bit range
+
+    int shift = 16 - input_bpp;
+    if (shift > 0) {
+      for (int y = 0; y < height; ++y) {
+        for (size_t x = 0; x < stride_rgb; x += 2) {
+          uint8_t* p = (&row_pointers[y][x]);
+          int v = (p[0] << 8) | p[1];
+          v = (v << shift) | (v >> (16 - shift));
+          p[0] = (uint8_t) (v >> 8);
+          p[1] = (uint8_t) (v & 0xFF);
+        }
+      }
+    }
+  }
+
+
+  png_write_image(png_ptr, row_pointers);
+
+  png_write_end(png_ptr, nullptr);
+  png_destroy_write_struct(&png_ptr, &info_ptr);
+  delete[] row_pointers;
+  fclose(fp);
+  return true;
+}
diff --git a/examples/encoder_png.h b/heifio/encoder_png.h
similarity index 78%
rename from examples/encoder_png.h
rename to heifio/encoder_png.h
index 61d794e927..ddc1afdea4 100644
--- a/examples/encoder_png.h
+++ b/heifio/encoder_png.h
@@ -1,9 +1,10 @@
 /*
-  libheif example application "convert".
+  libheif example application.
 
   MIT License
 
   Copyright (c) 2017 struktur AG, Joachim Bauch <bauch@struktur.de>
+  Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
 
   Permission is hereby granted, free of charge, to any person obtaining a copy
   of this software and associated documentation files (the "Software"), to deal
@@ -35,6 +36,13 @@ class PngEncoder : public Encoder
 public:
   PngEncoder();
 
+  // 0 = fastest compression
+  // 9 = best compression
+  // -1 = zlib default
+  void set_compression_level(int level) {
+    m_compression_level = level;
+  }
+
   heif_colorspace colorspace(bool has_alpha) const override
   {
     return heif_colorspace_RGB;
@@ -42,7 +50,7 @@ class PngEncoder : public Encoder
 
   heif_chroma chroma(bool has_alpha, int bit_depth) const override
   {
-    if (bit_depth == 8) {
+    if (bit_depth <= 8) {
       if (has_alpha)
         return heif_chroma_interleaved_RGBA;
       else
@@ -56,10 +64,13 @@ class PngEncoder : public Encoder
     }
   }
 
-  bool Encode(const struct heif_image_handle* handle,
-              const struct heif_image* image, const std::string& filename) override;
+  bool supports_alpha() const override { return true; }
+
+  bool Encode(const heif_image_handle* handle,
+              const heif_image* image, const std::string& filename) override;
 
 private:
+  int m_compression_level = -1;
 };
 
 #endif  // EXAMPLE_ENCODER_PNG_H
diff --git a/heifio/encoder_tiff.cc b/heifio/encoder_tiff.cc
new file mode 100644
index 0000000000..1dc51e3ca1
--- /dev/null
+++ b/heifio/encoder_tiff.cc
@@ -0,0 +1,77 @@
+/*
+  libheif example application.
+
+  MIT License
+
+  Copyright (c) 2024 Brad Hards <bradh@frogmouth.net>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+#include <cerrno>
+#include <tiff.h>
+#include <cstring>
+#include <cstdlib>
+#include <vector>
+
+#include "encoder_tiff.h"
+#include <tiffio.h>
+
+TiffEncoder::TiffEncoder() = default;
+
+bool TiffEncoder::Encode(const struct heif_image_handle *handle,
+                         const struct heif_image *image, const std::string &filename)
+{
+    TIFF *tif = TIFFOpen(filename.c_str(), "w");
+
+    // For now we write interleaved
+    int width = heif_image_get_width(image, heif_channel_interleaved);
+    int height = heif_image_get_height(image, heif_channel_interleaved);
+    bool hasAlpha = ((heif_image_get_chroma_format(image) == heif_chroma_interleaved_RGBA) ||
+                     (heif_image_get_chroma_format(image) == heif_chroma_interleaved_RRGGBBAA_BE));
+    int input_bpp = heif_image_get_bits_per_pixel_range(image, heif_channel_interleaved);
+
+    TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, width);
+    TIFFSetField(tif, TIFFTAG_IMAGELENGTH, height);
+    TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, input_bpp);
+    TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, hasAlpha ? 4 : 3);
+    if (hasAlpha)
+    {
+        // TODO: is alpha premultiplied?
+        uint16_t extra_samples[1] = {EXTRASAMPLE_UNASSALPHA};
+        TIFFSetField(tif, TIFFTAG_EXTRASAMPLES, 1, &extra_samples);
+    }
+    TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, 1);
+    TIFFSetField(tif, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
+    TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
+    TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
+    TIFFSetField(tif, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_UINT);
+    TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_NONE);
+
+    size_t stride_rgb;
+    const uint8_t *row_rgb = heif_image_get_plane_readonly2(image,
+                                                            heif_channel_interleaved, &stride_rgb);
+
+    for (int i = 0; i < height; i++)
+    {
+        // memcpy(scan_line, &buffer[i * width], width * sizeof(uint32));
+        TIFFWriteScanline(tif, (void *)(&(row_rgb[i * stride_rgb])), i, 0);
+    }
+    TIFFClose(tif);
+    return true;
+}
diff --git a/heifio/encoder_tiff.h b/heifio/encoder_tiff.h
new file mode 100644
index 0000000000..c9160940c9
--- /dev/null
+++ b/heifio/encoder_tiff.h
@@ -0,0 +1,66 @@
+/*
+  libheif example application.
+
+  MIT License
+
+  Copyright (c) 2024 Brad Hards <bradh@frogmouth.net>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+#ifndef EXAMPLE_ENCODER_TIFF_H
+#define EXAMPLE_ENCODER_TIFF_H
+
+#include <string>
+
+#include "encoder.h"
+
+class TiffEncoder : public Encoder
+{
+public:
+  TiffEncoder();
+
+
+  heif_colorspace colorspace(bool has_alpha) const override
+  {
+    return heif_colorspace_RGB;
+  }
+
+  heif_chroma chroma(bool has_alpha, int bit_depth) const override
+  {
+    if (bit_depth == 8) {
+      if (has_alpha)
+        return heif_chroma_interleaved_RGBA;
+      else
+        return heif_chroma_interleaved_RGB;
+    }
+    else {
+      if (has_alpha)
+        return heif_chroma_interleaved_RRGGBBAA_BE;
+      else
+        return heif_chroma_interleaved_RRGGBB_BE;
+    }
+  }
+
+  bool supports_alpha() const override { return true; }
+
+  bool Encode(const heif_image_handle* handle,
+              const heif_image* image, const std::string& filename) override;
+};
+
+#endif  // EXAMPLE_ENCODER_TIFF_H
diff --git a/examples/encoder_y4m.cc b/heifio/encoder_y4m.cc
similarity index 79%
rename from examples/encoder_y4m.cc
rename to heifio/encoder_y4m.cc
index a2340072ad..b672166fcf 100644
--- a/examples/encoder_y4m.cc
+++ b/heifio/encoder_y4m.cc
@@ -1,9 +1,9 @@
 /*
-  libheif example application "convert".
+  libheif example application.
 
   MIT License
 
-  Copyright (c) 2019 struktur AG, Dirk Farin <farin@struktur.de>
+  Copyright (c) 2019 Dirk Farin <dirk.farin@gmail.com>
 
   Permission is hereby granted, free of charge, to any person obtaining a copy
   of this software and associated documentation files (the "Software"), to deal
@@ -25,19 +25,18 @@
 */
 #include "encoder_y4m.h"
 
-#include <errno.h>
-#include <string.h>
-#include <assert.h>
+#include <cerrno>
+#include <cstring>
+#include <cassert>
 
 
-Y4MEncoder::Y4MEncoder()
-{
-}
+Y4MEncoder::Y4MEncoder() = default;
 
 
 void Y4MEncoder::UpdateDecodingOptions(const struct heif_image_handle* handle,
                                        struct heif_decoding_options* options) const
 {
+  options->convert_hdr_to_8bit = 1;
 }
 
 
@@ -51,10 +50,10 @@ bool Y4MEncoder::Encode(const struct heif_image_handle* handle,
     return false;
   }
 
-  int y_stride, cb_stride, cr_stride;
-  const uint8_t* yp = heif_image_get_plane_readonly(image, heif_channel_Y, &y_stride);
-  const uint8_t* cbp = heif_image_get_plane_readonly(image, heif_channel_Cb, &cb_stride);
-  const uint8_t* crp = heif_image_get_plane_readonly(image, heif_channel_Cr, &cr_stride);
+  size_t y_stride, cb_stride, cr_stride;
+  const uint8_t* yp = heif_image_get_plane_readonly2(image, heif_channel_Y, &y_stride);
+  const uint8_t* cbp = heif_image_get_plane_readonly2(image, heif_channel_Cb, &cb_stride);
+  const uint8_t* crp = heif_image_get_plane_readonly2(image, heif_channel_Cr, &cr_stride);
 
   assert(y_stride > 0);
   assert(cb_stride > 0);
@@ -65,6 +64,11 @@ bool Y4MEncoder::Encode(const struct heif_image_handle* handle,
   int cw = heif_image_get_width(image, heif_channel_Cb);
   int ch = heif_image_get_height(image, heif_channel_Cb);
 
+  if (yw < 0 || cw < 0) {
+    fclose(fp);
+    return false;
+  }
+
   fprintf(fp, "YUV4MPEG2 W%d H%d F30:1\nFRAME\n", yw, yh);
 
   for (int y = 0; y < yh; y++) {
diff --git a/examples/encoder_y4m.h b/heifio/encoder_y4m.h
similarity index 78%
rename from examples/encoder_y4m.h
rename to heifio/encoder_y4m.h
index d8d0e1dc66..54da8deb8e 100644
--- a/examples/encoder_y4m.h
+++ b/heifio/encoder_y4m.h
@@ -1,9 +1,9 @@
 /*
-  libheif example application "convert".
+  libheif example application.
 
   MIT License
 
-  Copyright (c) 2019 struktur AG, Dirk Farin <farin@struktur.de>
+  Copyright (c) 2019 Dirk Farin <dirk.farin@gmail.com>
 
   Permission is hereby granted, free of charge, to any person obtaining a copy
   of this software and associated documentation files (the "Software"), to deal
@@ -45,11 +45,13 @@ class Y4MEncoder : public Encoder
     return heif_chroma_420;
   }
 
-  void UpdateDecodingOptions(const struct heif_image_handle* handle,
-                             struct heif_decoding_options* options) const override;
+  bool supports_alpha() const override { return false; }
 
-  bool Encode(const struct heif_image_handle* handle,
-              const struct heif_image* image, const std::string& filename) override;
+  void UpdateDecodingOptions(const heif_image_handle* handle,
+                             heif_decoding_options* options) const override;
+
+  bool Encode(const heif_image_handle* handle,
+              const heif_image* image, const std::string& filename) override;
 
 private:
 };
diff --git a/heifio/exif.cc b/heifio/exif.cc
new file mode 100644
index 0000000000..e0ffd88946
--- /dev/null
+++ b/heifio/exif.cc
@@ -0,0 +1,263 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2022 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <cassert>
+#include "exif.h"
+
+#include "common_utils.h"
+
+#define EXIF_TYPE_SHORT 3
+#define EXIF_TYPE_LONG 4
+#define DEFAULT_EXIF_ORIENTATION 1
+#define EXIF_TAG_ORIENTATION 0x112
+#define EXIF_TAG_IMAGE_WIDTH ((uint16_t)0x0100)
+#define EXIF_TAG_IMAGE_HEIGHT ((uint16_t)0x0101)
+#define EXIF_TAG_VALID_IMAGE_WIDTH ((uint16_t)0xA002)
+#define EXIF_TAG_VALID_IMAGE_HEIGHT ((uint16_t)0xA003)
+#define EXIF_TAG_EXIF_IFD_POINTER ((uint16_t)0x8769)
+
+// Note: As far as I can see, it is not defined in the EXIF standard whether the offsets and counts of the IFD is signed or unsigned.
+// We assume that these are all unsigned.
+
+static uint32_t read32(const uint8_t* data, uint32_t size, uint32_t pos, bool littleEndian)
+{
+  assert(pos <= size - 4);
+
+  const uint8_t* p = data + pos;
+
+  if (littleEndian) {
+    return four_bytes_to_uint32(p[3], p[2], p[1], p[0]);
+  }
+  else {
+    return four_bytes_to_uint32(p[0], p[1], p[2], p[3]);
+  }
+}
+
+
+static uint16_t read16(const uint8_t* data, uint32_t size, uint32_t pos, bool littleEndian)
+{
+  assert(pos <= size - 2);
+
+  const uint8_t* p = data + pos;
+
+  if (littleEndian) {
+    return two_bytes_to_uint16(p[1], p[0]);
+  }
+  else {
+    return two_bytes_to_uint16(p[0], p[1]);
+  }
+}
+
+
+static void write16(uint8_t* data, uint32_t size, uint32_t pos, uint16_t value, bool littleEndian)
+{
+  assert(pos <= size - 2);
+
+  uint8_t* p = data + pos;
+
+  if (littleEndian) {
+    p[0] = (uint8_t) (value & 0xFF);
+    p[1] = (uint8_t) (value >> 8);
+  }
+  else {
+    p[0] = (uint8_t) (value >> 8);
+    p[1] = (uint8_t) (value & 0xFF);
+  }
+}
+
+
+static void write32(uint8_t* data, uint32_t size, uint32_t pos, uint32_t value, bool littleEndian)
+{
+  assert(pos <= size - 4);
+
+  uint8_t* p = data + pos;
+
+  if (littleEndian) {
+    p[0] = (uint8_t) (value & 0xFF);
+    p[1] = (uint8_t) ((value >> 8) & 0xFF);
+    p[2] = (uint8_t) ((value >> 16) & 0xFF);
+    p[3] = (uint8_t) ((value >> 24) & 0xFF);
+  } else {
+    p[0] = (uint8_t) ((value >> 24) & 0xFF);
+    p[1] = (uint8_t) ((value >> 16) & 0xFF);
+    p[2] = (uint8_t) ((value >> 8) & 0xFF);
+    p[3] = (uint8_t) (value & 0xFF);
+  }
+}
+
+
+// Returns 0 if the query_tag was not found.
+static uint32_t find_exif_tag_in_ifd(const uint8_t* exif, uint32_t size,
+                                     uint32_t ifd_offset,
+                                     uint16_t query_tag,
+                                     bool littleEndian,
+                                     int recursion_depth)
+{
+  const int MAX_IFD_TABLE_RECURSION_DEPTH = 5;
+
+  if (recursion_depth > MAX_IFD_TABLE_RECURSION_DEPTH) {
+    return 0;
+  }
+
+  uint32_t offset = ifd_offset;
+
+  // is offset valid (i.e. can we read at least the 'size' field and the pointer to the next IFD ?)
+  if (offset == 0) {
+    return 0;
+  }
+
+  if (size < 6 || size - 2 - 4 < offset) {
+    return 0;
+  }
+
+  uint16_t cnt = read16(exif, size, offset, littleEndian);
+
+  // Does the IFD table fit into our memory range? We need this check to prevent an underflow in the following statement.
+  uint32_t IFD_table_size = 2U + cnt * 12U + 4U;
+  if (IFD_table_size > size) {
+    return 0;
+  }
+
+  // end of IFD table would exceed the end of the EXIF data
+  // offset + IFD_table_size > size ?
+  if (size - IFD_table_size < offset) {
+    return 0;
+  }
+
+  for (int i = 0; i < cnt; i++) {
+    int tag = read16(exif, size, offset + 2 + i * 12, littleEndian);
+    if (tag == query_tag) {
+      return offset + 2 + i * 12;
+    }
+
+    if (tag == EXIF_TAG_EXIF_IFD_POINTER) {
+      uint32_t exifIFD_offset = read32(exif, size, offset + 2 + i * 12 + 8, littleEndian);
+      uint32_t tag_position = find_exif_tag_in_ifd(exif, size, exifIFD_offset, query_tag, littleEndian,
+                                                   recursion_depth + 1);
+      if (tag_position) {
+        return tag_position;
+      }
+    }
+  }
+
+  // continue with next IFD table
+
+  uint32_t pos = offset + 2 + cnt * 12;
+  uint32_t next_ifd_offset = read32(exif, size, pos, littleEndian);
+
+  return find_exif_tag_in_ifd(exif, size, next_ifd_offset, query_tag, littleEndian, recursion_depth + 1);
+}
+
+
+// Returns 0 if the query_tag was not found.
+static uint32_t find_exif_tag(const uint8_t* exif, uint32_t size, uint16_t query_tag, bool* out_littleEndian)
+{
+  // read TIFF header
+
+  if (size < 4) {
+    return 0;
+  }
+
+  if ((exif[0] != 'I' && exif[0] != 'M') ||
+      (exif[1] != 'I' && exif[1] != 'M')) {
+    return 0;
+  }
+
+  bool littleEndian = (exif[0] == 'I');
+
+  assert(out_littleEndian);
+  *out_littleEndian = littleEndian;
+
+
+  // read main IFD table
+
+  uint32_t offset;
+  offset = read32(exif, size, 4, littleEndian);
+
+  uint32_t tag_position = find_exif_tag_in_ifd(exif, size, offset, query_tag, littleEndian, 1);
+  return tag_position;
+}
+
+
+void overwrite_exif_image_size_if_it_exists(uint8_t* exif, uint32_t size, uint32_t width, uint32_t height)
+{
+  bool little_endian;
+  uint32_t pos;
+
+  for (uint16_t tag: {EXIF_TAG_IMAGE_WIDTH, EXIF_TAG_VALID_IMAGE_WIDTH}) {
+    pos = find_exif_tag(exif, size, tag, &little_endian);
+    if (pos != 0) {
+      write16(exif, size, pos + 2, EXIF_TYPE_LONG, little_endian);
+      write32(exif, size, pos + 4, 1, little_endian);
+      write32(exif, size, pos + 8, width, little_endian);
+    }
+  }
+
+  for (uint16_t tag: {EXIF_TAG_IMAGE_HEIGHT, EXIF_TAG_VALID_IMAGE_HEIGHT}) {
+    pos = find_exif_tag(exif, size, tag, &little_endian);
+    if (pos != 0) {
+      write16(exif, size, pos + 2, EXIF_TYPE_LONG, little_endian);
+      write32(exif, size, pos + 4, 1, little_endian);
+      write32(exif, size, pos + 8, height, little_endian);
+    }
+  }
+}
+
+
+void modify_exif_tag_if_it_exists(uint8_t* exif, uint32_t size, uint16_t modify_tag, uint16_t modify_value)
+{
+  bool little_endian;
+  uint32_t pos = find_exif_tag(exif, size, modify_tag, &little_endian);
+  if (pos == 0) {
+    return;
+  }
+
+  uint16_t type = read16(exif, size, pos + 2, little_endian);
+  uint32_t count = read32(exif, size, pos + 4, little_endian);
+
+  if (type == EXIF_TYPE_SHORT && count == 1) {
+    write16(exif, size, pos + 8, modify_value, little_endian);
+  }
+}
+
+
+void modify_exif_orientation_tag_if_it_exists(uint8_t* exifData, uint32_t size, uint16_t orientation)
+{
+  modify_exif_tag_if_it_exists(exifData, size, EXIF_TAG_ORIENTATION, orientation);
+}
+
+
+int read_exif_orientation_tag(const uint8_t* exif, uint32_t size)
+{
+  bool little_endian;
+  uint32_t pos = find_exif_tag(exif, size, EXIF_TAG_ORIENTATION, &little_endian);
+  if (pos == 0) {
+    return DEFAULT_EXIF_ORIENTATION;
+  }
+
+  uint16_t type = read16(exif, size, pos + 2, little_endian);
+  uint32_t count = read32(exif, size, pos + 4, little_endian);
+
+  if (type == EXIF_TYPE_SHORT && count == 1) {
+    return read16(exif, size, pos + 8, little_endian);
+  }
+
+  return DEFAULT_EXIF_ORIENTATION;
+}
diff --git a/heifio/exif.h b/heifio/exif.h
new file mode 100644
index 0000000000..2a4de22e89
--- /dev/null
+++ b/heifio/exif.h
@@ -0,0 +1,33 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2022 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_EXIF_H
+#define LIBHEIF_EXIF_H
+
+#include <vector>
+#include <cinttypes>
+
+int read_exif_orientation_tag(const uint8_t* exif, uint32_t size);
+
+void modify_exif_orientation_tag_if_it_exists(uint8_t* exifData, uint32_t size, uint16_t orientation);
+
+void overwrite_exif_image_size_if_it_exists(uint8_t* exif, uint32_t size, uint32_t width, uint32_t height);
+
+#endif //LIBHEIF_EXIF_H
diff --git a/heifio/stubs.cc b/heifio/stubs.cc
new file mode 100644
index 0000000000..b1facb614a
--- /dev/null
+++ b/heifio/stubs.cc
@@ -0,0 +1,64 @@
+/*
+  libheif example application "heif".
+
+  MIT License
+
+  Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#include "libheif/heif.h"
+#include "decoder.h"
+
+
+#if !HAVE_LIBJPEG
+heif_error loadJPEG(const char *filename, InputImage *input_image)
+{
+  struct heif_error err = {
+      .code = heif_error_Unsupported_feature,
+      .subcode = heif_suberror_Unspecified,
+      .message = "Cannot load JPEG because libjpeg support was not compiled."};
+  return err;
+}
+#endif
+
+
+#if !HAVE_LIBPNG
+heif_error loadPNG(const char* filename, int output_bit_depth, InputImage *input_image)
+{
+  struct heif_error err = {
+      .code = heif_error_Unsupported_feature,
+      .subcode = heif_suberror_Unspecified,
+      .message = "Cannot load PNG because libpng support was not compiled."};
+  return err;
+}
+#endif
+
+
+#if !HAVE_LIBTIFF
+heif_error loadTIFF(const char *filename, InputImage *input_image)
+{
+  struct heif_error err = {
+      .code = heif_error_Unsupported_feature,
+      .subcode = heif_suberror_Unspecified,
+      .message = "Cannot load TIFF because libtiff support was not compiled."};
+  return err;
+}
+#endif
diff --git a/libheif.pc.in b/libheif.pc.in
index e2a623c099..8a62403c88 100644
--- a/libheif.pc.in
+++ b/libheif.pc.in
@@ -2,17 +2,14 @@ prefix=@prefix@
 exec_prefix=@exec_prefix@
 libdir=@libdir@
 includedir=@includedir@
-builtin_h265_decoder=@have_libde265@
-builtin_h265_encoder=@have_x265@
-builtin_avif_decoder=@have_avif_decoder@
-builtin_avif_encoder=@have_avif_encoder@
 
 Name: libheif
 Description: HEIF image codec.
 URL: https://github.com/strukturag/libheif
-Version: @VERSION@
+Version: @PROJECT_VERSION@
 Requires:
 Requires.private: @REQUIRES_PRIVATE@
-Libs: -L@libdir@ -lheif
-Libs.private: @LIBS@ -lstdc++
-Cflags: -I@includedir@
+Libs: -L${libdir} -lheif
+Libs.private: @LIBS_PRIVATE@
+Cflags: -I${includedir}
+Cflags.private: -DLIBHEIF_STATIC_BUILD -DHEIF_WITH_OMAF=@WITH_OMAF@
diff --git a/libheif/CMakeLists.txt b/libheif/CMakeLists.txt
index 761271fe3f..e747083872 100644
--- a/libheif/CMakeLists.txt
+++ b/libheif/CMakeLists.txt
@@ -1,169 +1,371 @@
 include(CMakePackageConfigHelpers)
 
-configure_file(heif_version.h.in ${CMAKE_CURRENT_BINARY_DIR}/heif_version.h)
+configure_file(api/libheif/heif_version.h.in ${CMAKE_CURRENT_BINARY_DIR}/heif_version.h)
 
 set(libheif_headers
-    heif.h
-    heif_cxx.h
-    heif_plugin.h
-    ${CMAKE_CURRENT_BINARY_DIR}/heif_version.h)
-
-add_library(heif
-    bitstream.cc
-    box.cc
-    error.cc
-    heif.cc
-    heif_context.cc
-    heif_file.cc
-    heif_image.cc
-    heif_hevc.cc
-    heif_avif.cc
-    heif_colorconversion.cc
-    heif_plugin_registry.cc
-    heif_plugin.cc
-    nclx.cc
-    bitstream.h
-    box.h
-    error.h
-    heif_api_structs.h
-    heif_context.h
-    heif_file.h
-    heif_image.h
-    heif_hevc.h
-    heif_avif.h
-    heif_colorconversion.h
-    heif_plugin_registry.h
-    heif_limits.h
-    nclx.h
-    logging.h
-    ${libheif_headers}
-)
+        api/libheif/heif.h
+        api/libheif/heif_library.h
+        api/libheif/heif_image.h
+        api/libheif/heif_color.h
+        api/libheif/heif_error.h
+        api/libheif/heif_plugin.h
+        api/libheif/heif_properties.h
+        api/libheif/heif_regions.h
+        api/libheif/heif_items.h
+        api/libheif/heif_sequences.h
+        api/libheif/heif_tai_timestamps.h
+        api/libheif/heif_brands.h
+        api/libheif/heif_metadata.h
+        api/libheif/heif_aux_images.h
+        api/libheif/heif_entity_groups.h
+        api/libheif/heif_security.h
+        api/libheif/heif_encoding.h
+        api/libheif/heif_decoding.h
+        api/libheif/heif_image_handle.h
+        api/libheif/heif_context.h
+        api/libheif/heif_tiling.h
+        api/libheif/heif_uncompressed.h
+        api/libheif/heif_uncompressed_types.h
+        api/libheif/heif_text.h
+        api/libheif/heif_cxx.h
+        ${CMAKE_CURRENT_BINARY_DIR}/heif_version.h)
+
+set(libheif_sources
+        bitstream.cc
+        bitstream.h
+        box.cc
+        box.h
+        error.cc
+        error.h
+        context.cc
+        context.h
+        file.cc
+        file.h
+        file_layout.h
+        file_layout.cc
+        pixelimage.cc
+        pixelimage.h
+        plugin_registry.cc
+        nclx.cc
+        nclx.h
+        plugin_registry.h
+        security_limits.cc
+        security_limits.h
+        init.cc
+        init.h
+        logging.h
+        logging.cc
+        compression.h
+        compression.cc
+        compression_brotli.cc
+        compression_zlib.cc
+        common_utils.cc
+        common_utils.h
+        region.cc
+        region.h
+        brands.cc
+        brands.h
+        id_creator.cc
+        id_creator.h
+        text.cc
+        text.h
+        api_structs.h
+        api/libheif/heif.cc
+        api/libheif/heif_library.cc
+        api/libheif/heif_image.cc
+        api/libheif/heif_color.cc
+        api/libheif/heif_regions.cc
+        api/libheif/heif_plugin.cc
+        api/libheif/heif_properties.cc
+        api/libheif/heif_items.cc
+        api/libheif/heif_sequences.cc
+        api/libheif/heif_tai_timestamps.cc
+        api/libheif/heif_brands.cc
+        api/libheif/heif_metadata.cc
+        api/libheif/heif_aux_images.cc
+        api/libheif/heif_entity_groups.cc
+        api/libheif/heif_security.cc
+        api/libheif/heif_encoding.cc
+        api/libheif/heif_decoding.cc
+        api/libheif/heif_image_handle.cc
+        api/libheif/heif_context.cc
+        api/libheif/heif_tiling.cc
+        api/libheif/heif_uncompressed.cc
+        api/libheif/heif_text.cc
+        codecs/decoder.h
+        codecs/decoder.cc
+        codecs/encoder.h
+        codecs/encoder.cc
+        image-items/hevc.cc
+        image-items/hevc.h
+        codecs/hevc_boxes.cc
+        codecs/hevc_boxes.h
+        codecs/hevc_dec.cc
+        codecs/hevc_dec.h
+        codecs/hevc_enc.cc
+        codecs/hevc_enc.h
+        image-items/avif.cc
+        image-items/avif.h
+        codecs/avif_enc.cc
+        codecs/avif_enc.h
+        codecs/avif_dec.cc
+        codecs/avif_dec.h
+        codecs/avif_boxes.cc
+        codecs/avif_boxes.h
+        image-items/jpeg.h
+        image-items/jpeg.cc
+        codecs/jpeg_boxes.h
+        codecs/jpeg_boxes.cc
+        codecs/jpeg_dec.h
+        codecs/jpeg_dec.cc
+        codecs/jpeg_enc.h
+        codecs/jpeg_enc.cc
+        image-items/jpeg2000.h
+        image-items/jpeg2000.cc
+        codecs/jpeg2000_dec.h
+        codecs/jpeg2000_dec.cc
+        codecs/jpeg2000_enc.h
+        codecs/jpeg2000_enc.cc
+        codecs/jpeg2000_boxes.h
+        codecs/jpeg2000_boxes.cc
+        image-items/vvc.h
+        image-items/vvc.cc
+        codecs/vvc_dec.h
+        codecs/vvc_dec.cc
+        codecs/vvc_enc.h
+        codecs/vvc_enc.cc
+        codecs/vvc_boxes.h
+        codecs/vvc_boxes.cc
+        image-items/avc.h
+        image-items/avc.cc
+        codecs/avc_boxes.h
+        codecs/avc_boxes.cc
+        codecs/avc_dec.h
+        codecs/avc_dec.cc
+        codecs/avc_enc.h
+        codecs/avc_enc.cc
+        image-items/mask_image.h
+        image-items/mask_image.cc
+        image-items/image_item.h
+        image-items/image_item.cc
+        image-items/grid.h
+        image-items/grid.cc
+        image-items/overlay.h
+        image-items/overlay.cc
+        image-items/iden.h
+        image-items/iden.cc
+        image-items/tiled.h
+        image-items/tiled.cc
+        color-conversion/colorconversion.cc
+        color-conversion/colorconversion.h
+        color-conversion/rgb2yuv.cc
+        color-conversion/rgb2yuv.h
+        color-conversion/rgb2yuv_sharp.cc
+        color-conversion/rgb2yuv_sharp.h
+        color-conversion/yuv2rgb.cc
+        color-conversion/yuv2rgb.h
+        color-conversion/rgb2rgb.cc
+        color-conversion/rgb2rgb.h
+        color-conversion/monochrome.cc
+        color-conversion/monochrome.h
+        color-conversion/hdr_sdr.cc
+        color-conversion/hdr_sdr.h
+        color-conversion/alpha.cc
+        color-conversion/alpha.h
+        color-conversion/chroma_sampling.cc
+        color-conversion/chroma_sampling.h
+        color-conversion/bayer_bilinear.cc
+        color-conversion/bayer_bilinear.h
+        sequences/seq_boxes.h
+        sequences/seq_boxes.cc
+        sequences/chunk.h
+        sequences/chunk.cc
+        sequences/track.h
+        sequences/track.cc
+        sequences/track_visual.h
+        sequences/track_visual.cc
+        sequences/track_metadata.h
+        sequences/track_metadata.cc
+        ${libheif_headers})
+
+add_library(heif ${libheif_sources})
+
+if (ENABLE_PLUGIN_LOADING)
+    if (WIN32)
+        target_sources(heif PRIVATE plugins_windows.cc plugins_windows.h)
+    else ()
+        target_sources(heif PRIVATE plugins_unix.cc plugins_unix.h)
+    endif ()
+endif ()
+
+option(ENABLE_EXPERIMENTAL_FEATURES "Compile experimental features and install headers with unstable API" OFF)
+if (ENABLE_EXPERIMENTAL_FEATURES)
+    target_sources(heif PRIVATE api/libheif/heif_experimental.h api/libheif/heif_experimental.cc)
+
+    list(APPEND libheif_headers api/libheif/heif_experimental.h)
+
+    target_compile_definitions(heif PUBLIC HEIF_ENABLE_EXPERIMENTAL_FEATURES)
+endif()
 
 # Needed to find libheif/heif_version.h while compiling the library
-target_include_directories(heif PRIVATE ${libheif_BINARY_DIR} ${libheif_SOURCE_DIR})
+target_include_directories(heif PRIVATE ${libheif_BINARY_DIR} ${libheif_SOURCE_DIR}/libheif ${libheif_SOURCE_DIR}/libheif/api)
 
 # Propagate include/libheif to consume the headers from other projects
 target_include_directories(heif
-                           PUBLIC
-                               $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include/${PROJECT_NAME}>
-                               $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
-                               $<INSTALL_INTERFACE:include>)
+        PUBLIC
+        $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include/${PROJECT_NAME}>
+        $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
+        $<INSTALL_INTERFACE:include>)
 
 set_target_properties(heif
-                      PROPERTIES
-                          VERSION ${PROJECT_VERSION}
-                          SOVERSION ${PROJECT_VERSION_MAJOR})
+        PROPERTIES
+        VERSION ${PROJECT_VERSION}
+        SOVERSION ${PROJECT_VERSION_MAJOR})
 
-target_compile_definitions(heif
-                           PUBLIC
-                               LIBHEIF_EXPORTS
-                               HAVE_VISIBILITY)
-
-if(LIBDE265_FOUND)
-    target_compile_definitions(heif PRIVATE HAVE_LIBDE265=1)
-    target_sources(heif
-                   PRIVATE
-                       heif_decoder_libde265.cc
-                       heif_decoder_libde265.h)
+if (APPLE)
+    set_target_properties(heif PROPERTIES
+	    LINK_FLAGS "-Wl,-compatibility_version,${MACOS_COMPATIBLE_VERSION}")
+endif ()
 
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${LIBDE265_CFLAGS}")
+if (BUILD_FRAMEWORK) 
+  set_target_properties(heif PROPERTIES
+    FRAMEWORK TRUE
+    FRAMEWORK_VERSION "${PACKAGE_VERSION}"
+    PRODUCT_BUNDLE_IDENTIFIER "github.com/strukturag/libheif"
+    XCODE_ATTRIBUTE_INSTALL_PATH "@rpath"
+    # OUTPUT_NAME "heif"
+    XCODE_ATTRIBUTE_CODE_SIGN_IDENTITY ""
+    XCODE_ATTRIBUTE_CODE_SIGNING_ALLOWED "NO"
+    XCODE_ATTRIBUTE_CODE_SIGNING_REQUIRED "NO"
+    PUBLIC_HEADER "${libheif_headers}"
+    MACOSX_FRAMEWORK_IDENTIFIER "github.com/strukturag/libheif"
+    MACOSX_FRAMEWORK_BUNDLE_VERSION "${PACKAGE_VERSION}"
+    MACOSX_FRAMEWORK_SHORT_VERSION_STRING "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}"
+    MACOSX_RPATH TRUE)
+endif()
 
-    if (NOT "${LIBDE265_LIBRARY_DIRS}" STREQUAL "")
-        set(LIBDE265_LINKDIR "-L${LIBDE265_LIBRARY_DIRS}")
-    endif()
+target_compile_definitions(heif
+        PUBLIC
+        LIBHEIF_EXPORTS
+        HAVE_VISIBILITY)
 
-    include_directories(SYSTEM ${LIBDE265_INCLUDE_DIR})
-    target_link_libraries(heif PRIVATE ${LIBDE265_LIBRARIES} ${LIBDE265_LINKDIR})
-endif()
+if (PLUGIN_LOADING_SUPPORTED_AND_ENABLED)
+    target_compile_definitions(heif PRIVATE ENABLE_PLUGIN_LOADING=1)
+    target_link_libraries(heif PRIVATE ${CMAKE_DL_LIBS})
+endif ()
 
-if(X265_FOUND)
-    target_compile_definitions(heif PRIVATE HAVE_X265=1)
-    target_sources(heif PRIVATE
-        heif_encoder_x265.cc
-        heif_encoder_x265.h
-    )
+add_subdirectory(plugins)
 
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${X265_CFLAGS}")
+if (LIBSHARPYUV_FOUND)
+    message("Compiling in 'libsharpyuv'")
+    target_compile_definitions(heif PUBLIC HAVE_LIBSHARPYUV=1)
+    target_include_directories(heif PRIVATE ${LIBSHARPYUV_INCLUDE_DIRS})
+    target_link_libraries(heif PRIVATE ${LIBSHARPYUV_LIBRARIES})
+else ()
+    message("Not compiling 'libsharpyuv'")
+endif ()
 
-    if (NOT "${X265_LIBRARY_DIRS}" STREQUAL "")
-        set(X265_LINKDIR "-L${X265_LIBRARY_DIRS}")
-    endif()
+if (ZLIB_FOUND)
+    target_compile_definitions(heif PRIVATE HAVE_ZLIB=1)
+    target_link_libraries(heif PRIVATE ZLIB::ZLIB)
+endif ()
 
-    include_directories(SYSTEM ${X265_INCLUDE_DIR})
-    target_link_libraries(heif PRIVATE ${X265_LIBRARIES} ${X265_LINKDIR})
+if (Brotli_FOUND)
+    target_compile_definitions(heif PUBLIC HAVE_BROTLI=1)
+    target_include_directories(heif PRIVATE ${BROTLI_INCLUDE_DIRS})
+    target_link_libraries(heif PRIVATE ${BROTLI_LIBS})
 endif()
 
-if(AOM_ENCODER_FOUND OR AOM_DECODER_FOUND)
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${AOM_CFLAGS}")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${AOM_CFLAGS}")
+if (ENABLE_MULTITHREADING_SUPPORT)
+    find_package(Threads)
+    target_link_libraries(heif PRIVATE ${CMAKE_THREAD_LIBS_INIT})
 
-  if (NOT "${AOM_LIBRARY_DIRS}" STREQUAL "")
-    set(AOM_LINKDIR "-L${AOM_LIBRARY_DIRS}")
-  endif()
+    target_compile_definitions(heif PRIVATE ENABLE_MULTITHREADING_SUPPORT=1)
+    if (ENABLE_PARALLEL_TILE_DECODING)
+        target_compile_definitions(heif PRIVATE ENABLE_PARALLEL_TILE_DECODING=1)
+    endif ()
+endif ()
 
-  include_directories(SYSTEM ${AOM_INCLUDE_DIR})
-  target_link_libraries(heif PRIVATE ${AOM_LIBRARIES} ${AOM_LINKDIR})
-endif()
-if(AOM_ENCODER_FOUND)
-  target_compile_definitions(heif PRIVATE HAVE_AOM_ENCODER=1)
-  target_sources(heif PRIVATE
-    heif_encoder_aom.cc
-    heif_encoder_aom.h
-  )
-endif()
-if(AOM_DECODER_FOUND)
-  target_compile_definitions(heif PRIVATE HAVE_AOM_DECODER=1)
-  target_sources(heif PRIVATE
-    heif_decoder_aom.cc
-    heif_decoder_aom.h
-  )
-endif()
+if (WITH_UNCOMPRESSED_CODEC)
+    target_compile_definitions(heif PUBLIC WITH_UNCOMPRESSED_CODEC=1)
+    target_sources(heif PRIVATE
+            codecs/uncompressed/unc_boxes.h
+            codecs/uncompressed/unc_boxes.cc
+            image-items/unc_image.h
+            image-items/unc_image.cc
+            codecs/uncompressed/unc_codec.h
+            codecs/uncompressed/unc_codec.cc
+            codecs/uncompressed/unc_dec.h
+            codecs/uncompressed/unc_dec.cc
+            codecs/uncompressed/unc_enc.h
+            codecs/uncompressed/unc_enc.cc
+            codecs/uncompressed/unc_decoder.h
+            codecs/uncompressed/unc_decoder.cc
+            codecs/uncompressed/unc_decoder_legacybase.h
+            codecs/uncompressed/unc_decoder_legacybase.cc
+            codecs/uncompressed/unc_decoder_component_interleave.h
+            codecs/uncompressed/unc_decoder_component_interleave.cc
+            codecs/uncompressed/unc_decoder_pixel_interleave.h
+            codecs/uncompressed/unc_decoder_pixel_interleave.cc
+            codecs/uncompressed/unc_decoder_block_pixel_interleave.h
+            codecs/uncompressed/unc_decoder_block_pixel_interleave.cc
+            codecs/uncompressed/unc_decoder_bytealign_component_interleave.h
+            codecs/uncompressed/unc_decoder_bytealign_component_interleave.cc
+            codecs/uncompressed/unc_decoder_block_component_interleave.h
+            codecs/uncompressed/unc_decoder_block_component_interleave.cc
+            codecs/uncompressed/unc_decoder_mixed_interleave.h
+            codecs/uncompressed/unc_decoder_mixed_interleave.cc
+            codecs/uncompressed/unc_decoder_row_interleave.h
+            codecs/uncompressed/unc_decoder_row_interleave.cc
+            codecs/uncompressed/unc_encoder.h
+            codecs/uncompressed/unc_encoder.cc
+            codecs/uncompressed/unc_encoder_rgb_pixel_interleave.cc
+            codecs/uncompressed/unc_encoder_rgb_pixel_interleave.h
+            codecs/uncompressed/unc_encoder_rgb_bytealign_pixel_interleave.cc
+            codecs/uncompressed/unc_encoder_rgb_bytealign_pixel_interleave.h
+            codecs/uncompressed/unc_encoder_component_interleave.cc
+            codecs/uncompressed/unc_encoder_component_interleave.h
+            codecs/uncompressed/unc_encoder_rgb_block_pixel_interleave.cc
+            codecs/uncompressed/unc_encoder_rgb_block_pixel_interleave.h)
+endif ()
 
-if(RAV1E_FOUND)
-    target_compile_definitions(heif PRIVATE HAVE_RAV1E=1)
+if (ENABLE_EXPERIMENTAL_MINI_FORMAT)
+    target_compile_definitions(heif PUBLIC ENABLE_EXPERIMENTAL_MINI_FORMAT=1)
     target_sources(heif PRIVATE
-            heif_encoder_rav1e.cc
-            heif_encoder_rav1e.h
-            )
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${RAV1E_CFLAGS}")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${RAV1E_CFLAGS}")
-
-    if (NOT "${RAV1E_LIBRARY_DIRS}" STREQUAL "")
-        set(RAV1E_LINKDIR "-L${RAV1E_LIBRARY_DIRS}")
-    endif()
-
-    include_directories(SYSTEM ${RAV1E_INCLUDE_DIR})
-    target_link_libraries(heif PRIVATE ${RAV1E_LIBRARIES} ${RAV1E_LINKDIR})
-endif()
+            mini.h
+            mini.cc)
+endif ()
 
-if(DAV1D_FOUND)
-    target_compile_definitions(heif PRIVATE HAVE_DAV1D=1)
+if (HEIF_WITH_OMAF)
+    target_compile_definitions(heif PUBLIC HEIF_WITH_OMAF=1)
     target_sources(heif PRIVATE
-            heif_decoder_dav1d.cc
-            heif_decoder_dav1d.h
-            )
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${DAV1D_CFLAGS}")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${DAV1D_CFLAGS}")
-
-    if (NOT "${DAV1D_LIBRARY_DIRS}" STREQUAL "")
-        set(DAV1D_LINKDIR "-L${DAV1D_LIBRARY_DIRS}")
-    endif()
-
-    include_directories(SYSTEM ${DAV1D_INCLUDE_DIR})
-    target_link_libraries(heif PRIVATE ${DAV1D_LIBRARIES} ${DAV1D_LINKDIR})
+            omaf_boxes.h
+            omaf_boxes.cc)
 endif ()
 
 write_basic_package_version_file(${PROJECT_NAME}-config-version.cmake COMPATIBILITY ExactVersion)
 
 install(TARGETS heif EXPORT ${PROJECT_NAME}-config
-    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-)
+        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+        FRAMEWORK DESTINATION Library/Frameworks COMPONENT runtime OPTIONAL
+        )
 
 install(FILES ${libheif_headers} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME})
 
 install(EXPORT ${PROJECT_NAME}-config DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}")
 
 install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}-config-version.cmake DESTINATION
-    "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}")
+        "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}")
+
+
+# --- on Windows, copy the DLL into the executable directory for easier development
+
+if (WIN32 AND BUILD_SHARED_LIBS)
+    add_custom_command(TARGET heif POST_BUILD
+            COMMAND ${CMAKE_COMMAND} -E copy
+            $<TARGET_FILE:heif>
+            $<TARGET_FILE_DIR:heif>/../examples
+    )
+endif ()
diff --git a/libheif/CPPLINT.cfg b/libheif/CPPLINT.cfg
deleted file mode 100644
index 732f723d2c..0000000000
--- a/libheif/CPPLINT.cfg
+++ /dev/null
@@ -1 +0,0 @@
-# filter=-build/include_what_you_use
diff --git a/libheif/Doxyfile.in b/libheif/Doxyfile.in
new file mode 100644
index 0000000000..0d6c130852
--- /dev/null
+++ b/libheif/Doxyfile.in
@@ -0,0 +1,2562 @@
+# Doxyfile 1.9.1
+
+# This file describes the settings to be used by the documentation system
+# doxygen (www.doxygen.org) for a project.
+#
+# All text after a double hash (##) is considered a comment and is placed in
+# front of the TAG it is preceding.
+#
+# All text after a single hash (#) is considered a comment and will be ignored.
+# The format is:
+# TAG = value [value, ...]
+# For lists, items can also be appended using:
+# TAG += value [value, ...]
+# Values that contain spaces should be placed between quotes (\" \").
+
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+
+# This tag specifies the encoding used for all characters in the configuration
+# file that follow. The default is UTF-8 which is also the encoding used for all
+# text before the first occurrence of this tag. Doxygen uses libiconv (or the
+# iconv built into libc) for the transcoding. See
+# https://www.gnu.org/software/libiconv/ for the list of possible encodings.
+# The default value is: UTF-8.
+
+DOXYFILE_ENCODING      = UTF-8
+
+# The PROJECT_NAME tag is a single word (or a sequence of words surrounded by
+# double-quotes, unless you are using Doxywizard) that should identify the
+# project for which the documentation is generated. This name is used in the
+# title of most generated pages and in a few other places.
+# The default value is: My Project.
+
+PROJECT_NAME           = "libheif"
+
+# The PROJECT_NUMBER tag can be used to enter a project or revision number. This
+# could be handy for archiving the generated documentation or if some version
+# control system is used.
+
+PROJECT_NUMBER         =
+
+# Using the PROJECT_BRIEF tag one can provide an optional one line description
+# for a project that appears at the top of each page and should give viewer a
+# quick idea about the purpose of the project. Keep the description short.
+
+PROJECT_BRIEF          =
+
+# With the PROJECT_LOGO tag one can specify a logo or an icon that is included
+# in the documentation. The maximum height of the logo should not exceed 55
+# pixels and the maximum width should not exceed 200 pixels. Doxygen will copy
+# the logo to the output directory.
+
+PROJECT_LOGO           =
+
+# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path
+# into which the generated documentation will be written. If a relative path is
+# entered, it will be relative to the location where doxygen was started. If
+# left blank the current directory will be used.
+
+OUTPUT_DIRECTORY       = @CMAKE_CURRENT_BINARY_DIR@/apidoc/
+
+# If the CREATE_SUBDIRS tag is set to YES then doxygen will create 4096 sub-
+# directories (in 2 levels) under the output directory of each output format and
+# will distribute the generated files over these directories. Enabling this
+# option can be useful when feeding doxygen a huge amount of source files, where
+# putting all generated files in the same directory would otherwise causes
+# performance problems for the file system.
+# The default value is: NO.
+
+CREATE_SUBDIRS         = NO
+
+# If the ALLOW_UNICODE_NAMES tag is set to YES, doxygen will allow non-ASCII
+# characters to appear in the names of generated files. If set to NO, non-ASCII
+# characters will be escaped, for example _xE3_x81_x84 will be used for Unicode
+# U+3044.
+# The default value is: NO.
+
+ALLOW_UNICODE_NAMES    = NO
+
+# The OUTPUT_LANGUAGE tag is used to specify the language in which all
+# documentation generated by doxygen is written. Doxygen will use this
+# information to generate all constant output in the proper language.
+# Possible values are: Afrikaans, Arabic, Armenian, Brazilian, Catalan, Chinese,
+# Chinese-Traditional, Croatian, Czech, Danish, Dutch, English (United States),
+# Esperanto, Farsi (Persian), Finnish, French, German, Greek, Hungarian,
+# Indonesian, Italian, Japanese, Japanese-en (Japanese with English messages),
+# Korean, Korean-en (Korean with English messages), Latvian, Lithuanian,
+# Macedonian, Norwegian, Persian (Farsi), Polish, Portuguese, Romanian, Russian,
+# Serbian, Serbian-Cyrillic, Slovak, Slovene, Spanish, Swedish, Turkish,
+# Ukrainian and Vietnamese.
+# The default value is: English.
+
+OUTPUT_LANGUAGE        = English
+
+# If the BRIEF_MEMBER_DESC tag is set to YES, doxygen will include brief member
+# descriptions after the members that are listed in the file and class
+# documentation (similar to Javadoc). Set to NO to disable this.
+# The default value is: YES.
+
+BRIEF_MEMBER_DESC      = YES
+
+# If the REPEAT_BRIEF tag is set to YES, doxygen will prepend the brief
+# description of a member or function before the detailed description
+#
+# Note: If both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
+# brief descriptions will be completely suppressed.
+# The default value is: YES.
+
+REPEAT_BRIEF           = YES
+
+# This tag implements a quasi-intelligent brief description abbreviator that is
+# used to form the text in various listings. Each string in this list, if found
+# as the leading text of the brief description, will be stripped from the text
+# and the result, after processing the whole list, is used as the annotated
+# text. Otherwise, the brief description is used as-is. If left blank, the
+# following values are used ($name is automatically replaced with the name of
+# the entity):The $name class, The $name widget, The $name file, is, provides,
+# specifies, contains, represents, a, an and the.
+
+ABBREVIATE_BRIEF       = "The $name class" \
+                         "The $name widget" \
+                         "The $name file" \
+                         is \
+                         provides \
+                         specifies \
+                         contains \
+                         represents \
+                         a \
+                         an \
+                         the
+
+# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
+# doxygen will generate a detailed section even if there is only a brief
+# description.
+# The default value is: NO.
+
+ALWAYS_DETAILED_SEC    = NO
+
+# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
+# inherited members of a class in the documentation of that class as if those
+# members were ordinary class members. Constructors, destructors and assignment
+# operators of the base classes will not be shown.
+# The default value is: NO.
+
+INLINE_INHERITED_MEMB  = NO
+
+# If the FULL_PATH_NAMES tag is set to YES, doxygen will prepend the full path
+# before files name in the file list and in the header files. If set to NO the
+# shortest path that makes the file name unique will be used
+# The default value is: YES.
+
+FULL_PATH_NAMES        = YES
+
+# The STRIP_FROM_PATH tag can be used to strip a user-defined part of the path.
+# Stripping is only done if one of the specified strings matches the left-hand
+# part of the path. The tag can be used to show relative paths in the file list.
+# If left blank the directory from which doxygen is run is used as the path to
+# strip.
+#
+# Note that you can specify absolute paths here, but also relative paths, which
+# will be relative from the directory where doxygen is started.
+# This tag requires that the tag FULL_PATH_NAMES is set to YES.
+
+STRIP_FROM_PATH        = @CMAKE_CURRENT_SOURCE_DIR@
+
+# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the
+# path mentioned in the documentation of a class, which tells the reader which
+# header file to include in order to use a class. If left blank only the name of
+# the header file containing the class definition is used. Otherwise one should
+# specify the list of include paths that are normally passed to the compiler
+# using the -I flag.
+
+STRIP_FROM_INC_PATH    =
+
+# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter (but
+# less readable) file names. This can be useful is your file systems doesn't
+# support long names like on DOS, Mac, or CD-ROM.
+# The default value is: NO.
+
+SHORT_NAMES            = NO
+
+# If the JAVADOC_AUTOBRIEF tag is set to YES then doxygen will interpret the
+# first line (until the first dot) of a Javadoc-style comment as the brief
+# description. If set to NO, the Javadoc-style will behave just like regular Qt-
+# style comments (thus requiring an explicit @brief command for a brief
+# description.)
+# The default value is: NO.
+
+JAVADOC_AUTOBRIEF      = YES
+
+# If the JAVADOC_BANNER tag is set to YES then doxygen will interpret a line
+# such as
+# /***************
+# as being the beginning of a Javadoc-style comment "banner". If set to NO, the
+# Javadoc-style will behave just like regular comments and it will not be
+# interpreted by doxygen.
+# The default value is: NO.
+
+JAVADOC_BANNER         = NO
+
+# If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first
+# line (until the first dot) of a Qt-style comment as the brief description. If
+# set to NO, the Qt-style will behave just like regular Qt-style comments (thus
+# requiring an explicit \brief command for a brief description.)
+# The default value is: NO.
+
+QT_AUTOBRIEF           = NO
+
+# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make doxygen treat a
+# multi-line C++ special comment block (i.e. a block of //! or /// comments) as
+# a brief description. This used to be the default behavior. The new default is
+# to treat a multi-line C++ comment block as a detailed description. Set this
+# tag to YES if you prefer the old behavior instead.
+#
+# Note that setting this tag to YES also means that rational rose comments are
+# not recognized any more.
+# The default value is: NO.
+
+MULTILINE_CPP_IS_BRIEF = NO
+
+# By default Python docstrings are displayed as preformatted text and doxygen's
+# special commands cannot be used. By setting PYTHON_DOCSTRING to NO the
+# doxygen's special commands can be used and the contents of the docstring
+# documentation blocks is shown as doxygen documentation.
+# The default value is: YES.
+
+PYTHON_DOCSTRING       = YES
+
+# If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the
+# documentation from any documented member that it re-implements.
+# The default value is: YES.
+
+INHERIT_DOCS           = YES
+
+# If the SEPARATE_MEMBER_PAGES tag is set to YES then doxygen will produce a new
+# page for each member. If set to NO, the documentation of a member will be part
+# of the file/class/namespace that contains it.
+# The default value is: NO.
+
+SEPARATE_MEMBER_PAGES  = NO
+
+# The TAB_SIZE tag can be used to set the number of spaces in a tab. Doxygen
+# uses this value to replace tabs by spaces in code fragments.
+# Minimum value: 1, maximum value: 16, default value: 4.
+
+TAB_SIZE               = 4
+
+# This tag can be used to specify a number of aliases that act as commands in
+# the documentation. An alias has the form:
+# name=value
+# For example adding
+# "sideeffect=@par Side Effects:\n"
+# will allow you to put the command \sideeffect (or @sideeffect) in the
+# documentation, which will result in a user-defined paragraph with heading
+# "Side Effects:". You can put \n's in the value part of an alias to insert
+# newlines (in the resulting output). You can put ^^ in the value part of an
+# alias to insert a newline as if a physical newline was in the original file.
+# When you need a literal { or } or , in the value part of an alias you have to
+# escape them by means of a backslash (\), this can lead to conflicts with the
+# commands \{ and \} for these it is advised to use the version @{ and @} or use
+# a double escape (\\{ and \\})
+
+ALIASES                =
+
+# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources
+# only. Doxygen will then generate output that is more tailored for C. For
+# instance, some of the names that are used will be different. The list of all
+# members will be omitted, etc.
+# The default value is: NO.
+
+OPTIMIZE_OUTPUT_FOR_C  = YES
+
+# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java or
+# Python sources only. Doxygen will then generate output that is more tailored
+# for that language. For instance, namespaces will be presented as packages,
+# qualified scopes will look different, etc.
+# The default value is: NO.
+
+OPTIMIZE_OUTPUT_JAVA   = NO
+
+# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
+# sources. Doxygen will then generate output that is tailored for Fortran.
+# The default value is: NO.
+
+OPTIMIZE_FOR_FORTRAN   = NO
+
+# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
+# sources. Doxygen will then generate output that is tailored for VHDL.
+# The default value is: NO.
+
+OPTIMIZE_OUTPUT_VHDL   = NO
+
+# Set the OPTIMIZE_OUTPUT_SLICE tag to YES if your project consists of Slice
+# sources only. Doxygen will then generate output that is more tailored for that
+# language. For instance, namespaces will be presented as modules, types will be
+# separated into more groups, etc.
+# The default value is: NO.
+
+OPTIMIZE_OUTPUT_SLICE  = NO
+
+# Doxygen selects the parser to use depending on the extension of the files it
+# parses. With this tag you can assign which parser to use for a given
+# extension. Doxygen has a built-in mapping, but you can override or extend it
+# using this tag. The format is ext=language, where ext is a file extension, and
+# language is one of the parsers supported by doxygen: IDL, Java, JavaScript,
+# Csharp (C#), C, C++, D, PHP, md (Markdown), Objective-C, Python, Slice, VHDL,
+# Fortran (fixed format Fortran: FortranFixed, free formatted Fortran:
+# FortranFree, unknown formatted Fortran: Fortran. In the later case the parser
+# tries to guess whether the code is fixed or free formatted code, this is the
+# default for Fortran type files). For instance to make doxygen treat .inc files
+# as Fortran files (default is PHP), and .f files as C (default is Fortran),
+# use: inc=Fortran f=C.
+#
+# Note: For files without extension you can use no_extension as a placeholder.
+#
+# Note that for custom extensions you also need to set FILE_PATTERNS otherwise
+# the files are not read by doxygen. When specifying no_extension you should add
+# * to the FILE_PATTERNS.
+#
+# Note see also the list of default file extension mappings.
+
+EXTENSION_MAPPING      =
+
+# If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments
+# according to the Markdown format, which allows for more readable
+# documentation. See https://daringfireball.net/projects/markdown/ for details.
+# The output of markdown processing is further processed by doxygen, so you can
+# mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in
+# case of backward compatibilities issues.
+# The default value is: YES.
+
+MARKDOWN_SUPPORT       = YES
+
+# When the TOC_INCLUDE_HEADINGS tag is set to a non-zero value, all headings up
+# to that level are automatically included in the table of contents, even if
+# they do not have an id attribute.
+# Note: This feature currently applies only to Markdown headings.
+# Minimum value: 0, maximum value: 99, default value: 5.
+# This tag requires that the tag MARKDOWN_SUPPORT is set to YES.
+
+TOC_INCLUDE_HEADINGS   = 5
+
+# When enabled doxygen tries to link words that correspond to documented
+# classes, or namespaces to their corresponding documentation. Such a link can
+# be prevented in individual cases by putting a % sign in front of the word or
+# globally by setting AUTOLINK_SUPPORT to NO.
+# The default value is: YES.
+
+AUTOLINK_SUPPORT       = YES
+
+# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
+# to include (a tag file for) the STL sources as input, then you should set this
+# tag to YES in order to let doxygen match functions declarations and
+# definitions whose arguments contain STL classes (e.g. func(std::string);
+# versus func(std::string) {}). This also make the inheritance and collaboration
+# diagrams that involve STL classes more complete and accurate.
+# The default value is: NO.
+
+BUILTIN_STL_SUPPORT    = NO
+
+# If you use Microsoft's C++/CLI language, you should set this option to YES to
+# enable parsing support.
+# The default value is: NO.
+
+CPP_CLI_SUPPORT        = NO
+
+# Set the SIP_SUPPORT tag to YES if your project consists of sip (see:
+# https://www.riverbankcomputing.com/software/sip/intro) sources only. Doxygen
+# will parse them like normal C++ but will assume all classes use public instead
+# of private inheritance when no explicit protection keyword is present.
+# The default value is: NO.
+
+SIP_SUPPORT            = NO
+
+# For Microsoft's IDL there are propget and propput attributes to indicate
+# getter and setter methods for a property. Setting this option to YES will make
+# doxygen to replace the get and set methods by a property in the documentation.
+# This will only work if the methods are indeed getting or setting a simple
+# type. If this is not the case, or you want to show the methods anyway, you
+# should set this option to NO.
+# The default value is: YES.
+
+IDL_PROPERTY_SUPPORT   = YES
+
+# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
+# tag is set to YES then doxygen will reuse the documentation of the first
+# member in the group (if any) for the other members of the group. By default
+# all members of a group must be documented explicitly.
+# The default value is: NO.
+
+DISTRIBUTE_GROUP_DOC   = NO
+
+# If one adds a struct or class to a group and this option is enabled, then also
+# any nested class or struct is added to the same group. By default this option
+# is disabled and one has to add nested compounds explicitly via \ingroup.
+# The default value is: NO.
+
+GROUP_NESTED_COMPOUNDS = NO
+
+# Set the SUBGROUPING tag to YES to allow class member groups of the same type
+# (for instance a group of public functions) to be put as a subgroup of that
+# type (e.g. under the Public Functions section). Set it to NO to prevent
+# subgrouping. Alternatively, this can be done per class using the
+# \nosubgrouping command.
+# The default value is: YES.
+
+SUBGROUPING            = YES
+
+# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions
+# are shown inside the group in which they are included (e.g. using \ingroup)
+# instead of on a separate page (for HTML and Man pages) or section (for LaTeX
+# and RTF).
+#
+# Note that this feature does not work in combination with
+# SEPARATE_MEMBER_PAGES.
+# The default value is: NO.
+
+INLINE_GROUPED_CLASSES = NO
+
+# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and unions
+# with only public data fields or simple typedef fields will be shown inline in
+# the documentation of the scope in which they are defined (i.e. file,
+# namespace, or group documentation), provided this scope is documented. If set
+# to NO, structs, classes, and unions are shown on a separate page (for HTML and
+# Man pages) or section (for LaTeX and RTF).
+# The default value is: NO.
+
+INLINE_SIMPLE_STRUCTS  = NO
+
+# When TYPEDEF_HIDES_STRUCT tag is enabled, a typedef of a struct, union, or
+# enum is documented as struct, union, or enum with the name of the typedef. So
+# typedef struct TypeS {} TypeT, will appear in the documentation as a struct
+# with name TypeT. When disabled the typedef will appear as a member of a file,
+# namespace, or class. And the struct will be named TypeS. This can typically be
+# useful for C code in case the coding convention dictates that all compound
+# types are typedef'ed and only the typedef is referenced, never the tag name.
+# The default value is: NO.
+
+TYPEDEF_HIDES_STRUCT   = NO
+
+# The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This
+# cache is used to resolve symbols given their name and scope. Since this can be
+# an expensive process and often the same symbol appears multiple times in the
+# code, doxygen keeps a cache of pre-resolved symbols. If the cache is too small
+# doxygen will become slower. If the cache is too large, memory is wasted. The
+# cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range
+# is 0..9, the default is 0, corresponding to a cache size of 2^16=65536
+# symbols. At the end of a run doxygen will report the cache usage and suggest
+# the optimal cache size from a speed point of view.
+# Minimum value: 0, maximum value: 9, default value: 0.
+
+LOOKUP_CACHE_SIZE      = 0
+
+# The NUM_PROC_THREADS specifies the number threads doxygen is allowed to use
+# during processing. When set to 0 doxygen will based this on the number of
+# cores available in the system. You can set it explicitly to a value larger
+# than 0 to get more control over the balance between CPU load and processing
+# speed. At this moment only the input processing can be done using multiple
+# threads. Since this is still an experimental feature the default is set to 1,
+# which efficively disables parallel processing. Please report any issues you
+# encounter. Generating dot graphs in parallel is controlled by the
+# DOT_NUM_THREADS setting.
+# Minimum value: 0, maximum value: 32, default value: 1.
+
+NUM_PROC_THREADS       = 1
+
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+
+# If the EXTRACT_ALL tag is set to YES, doxygen will assume all entities in
+# documentation are documented, even if no documentation was available. Private
+# class members and static file members will be hidden unless the
+# EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES.
+# Note: This will also disable the warnings about undocumented members that are
+# normally produced when WARNINGS is set to YES.
+# The default value is: NO.
+
+EXTRACT_ALL            = YES
+
+# If the EXTRACT_PRIVATE tag is set to YES, all private members of a class will
+# be included in the documentation.
+# The default value is: NO.
+
+EXTRACT_PRIVATE        = NO
+
+# If the EXTRACT_PRIV_VIRTUAL tag is set to YES, documented private virtual
+# methods of a class will be included in the documentation.
+# The default value is: NO.
+
+EXTRACT_PRIV_VIRTUAL   = NO
+
+# If the EXTRACT_PACKAGE tag is set to YES, all members with package or internal
+# scope will be included in the documentation.
+# The default value is: NO.
+
+EXTRACT_PACKAGE        = NO
+
+# If the EXTRACT_STATIC tag is set to YES, all static members of a file will be
+# included in the documentation.
+# The default value is: NO.
+
+EXTRACT_STATIC         = NO
+
+# If the EXTRACT_LOCAL_CLASSES tag is set to YES, classes (and structs) defined
+# locally in source files will be included in the documentation. If set to NO,
+# only classes defined in header files are included. Does not have any effect
+# for Java sources.
+# The default value is: YES.
+
+EXTRACT_LOCAL_CLASSES  = YES
+
+# This flag is only useful for Objective-C code. If set to YES, local methods,
+# which are defined in the implementation section but not in the interface are
+# included in the documentation. If set to NO, only methods in the interface are
+# included.
+# The default value is: NO.
+
+EXTRACT_LOCAL_METHODS  = NO
+
+# If this flag is set to YES, the members of anonymous namespaces will be
+# extracted and appear in the documentation as a namespace called
+# 'anonymous_namespace{file}', where file will be replaced with the base name of
+# the file that contains the anonymous namespace. By default anonymous namespace
+# are hidden.
+# The default value is: NO.
+
+EXTRACT_ANON_NSPACES   = NO
+
+# If this flag is set to YES, the name of an unnamed parameter in a declaration
+# will be determined by the corresponding definition. By default unnamed
+# parameters remain unnamed in the output.
+# The default value is: YES.
+
+RESOLVE_UNNAMED_PARAMS = YES
+
+# If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all
+# undocumented members inside documented classes or files. If set to NO these
+# members will be included in the various overviews, but no documentation
+# section is generated. This option has no effect if EXTRACT_ALL is enabled.
+# The default value is: NO.
+
+HIDE_UNDOC_MEMBERS     = NO
+
+# If the HIDE_UNDOC_CLASSES tag is set to YES, doxygen will hide all
+# undocumented classes that are normally visible in the class hierarchy. If set
+# to NO, these classes will be included in the various overviews. This option
+# has no effect if EXTRACT_ALL is enabled.
+# The default value is: NO.
+
+HIDE_UNDOC_CLASSES     = NO
+
+# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend
+# declarations. If set to NO, these declarations will be included in the
+# documentation.
+# The default value is: NO.
+
+HIDE_FRIEND_COMPOUNDS  = NO
+
+# If the HIDE_IN_BODY_DOCS tag is set to YES, doxygen will hide any
+# documentation blocks found inside the body of a function. If set to NO, these
+# blocks will be appended to the function's detailed documentation block.
+# The default value is: NO.
+
+HIDE_IN_BODY_DOCS      = NO
+
+# The INTERNAL_DOCS tag determines if documentation that is typed after a
+# \internal command is included. If the tag is set to NO then the documentation
+# will be excluded. Set it to YES to include the internal documentation.
+# The default value is: NO.
+
+INTERNAL_DOCS          = NO
+
+# With the correct setting of option CASE_SENSE_NAMES doxygen will better be
+# able to match the capabilities of the underlying filesystem. In case the
+# filesystem is case sensitive (i.e. it supports files in the same directory
+# whose names only differ in casing), the option must be set to YES to properly
+# deal with such files in case they appear in the input. For filesystems that
+# are not case sensitive the option should be be set to NO to properly deal with
+# output files written for symbols that only differ in casing, such as for two
+# classes, one named CLASS and the other named Class, and to also support
+# references to files without having to specify the exact matching casing. On
+# Windows (including Cygwin) and MacOS, users should typically set this option
+# to NO, whereas on Linux or other Unix flavors it should typically be set to
+# YES.
+# The default value is: system dependent.
+
+CASE_SENSE_NAMES       = YES
+
+# If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with
+# their full class and namespace scopes in the documentation. If set to YES, the
+# scope will be hidden.
+# The default value is: NO.
+
+HIDE_SCOPE_NAMES       = NO
+
+# If the HIDE_COMPOUND_REFERENCE tag is set to NO (default) then doxygen will
+# append additional text to a page's title, such as Class Reference. If set to
+# YES the compound reference will be hidden.
+# The default value is: NO.
+
+HIDE_COMPOUND_REFERENCE= NO
+
+# If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of
+# the files that are included by a file in the documentation of that file.
+# The default value is: YES.
+
+SHOW_INCLUDE_FILES     = YES
+
+# If the SHOW_GROUPED_MEMB_INC tag is set to YES then Doxygen will add for each
+# grouped member an include statement to the documentation, telling the reader
+# which file to include in order to use the member.
+# The default value is: NO.
+
+SHOW_GROUPED_MEMB_INC  = NO
+
+# If the FORCE_LOCAL_INCLUDES tag is set to YES then doxygen will list include
+# files with double quotes in the documentation rather than with sharp brackets.
+# The default value is: NO.
+
+FORCE_LOCAL_INCLUDES   = NO
+
+# If the INLINE_INFO tag is set to YES then a tag [inline] is inserted in the
+# documentation for inline members.
+# The default value is: YES.
+
+INLINE_INFO            = YES
+
+# If the SORT_MEMBER_DOCS tag is set to YES then doxygen will sort the
+# (detailed) documentation of file and class members alphabetically by member
+# name. If set to NO, the members will appear in declaration order.
+# The default value is: YES.
+
+SORT_MEMBER_DOCS       = YES
+
+# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the brief
+# descriptions of file, namespace and class members alphabetically by member
+# name. If set to NO, the members will appear in declaration order. Note that
+# this will also influence the order of the classes in the class list.
+# The default value is: NO.
+
+SORT_BRIEF_DOCS        = NO
+
+# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the
+# (brief and detailed) documentation of class members so that constructors and
+# destructors are listed first. If set to NO the constructors will appear in the
+# respective orders defined by SORT_BRIEF_DOCS and SORT_MEMBER_DOCS.
+# Note: If SORT_BRIEF_DOCS is set to NO this option is ignored for sorting brief
+# member documentation.
+# Note: If SORT_MEMBER_DOCS is set to NO this option is ignored for sorting
+# detailed member documentation.
+# The default value is: NO.
+
+SORT_MEMBERS_CTORS_1ST = NO
+
+# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the hierarchy
+# of group names into alphabetical order. If set to NO the group names will
+# appear in their defined order.
+# The default value is: NO.
+
+SORT_GROUP_NAMES       = NO
+
+# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be sorted by
+# fully-qualified names, including namespaces. If set to NO, the class list will
+# be sorted only by class name, not including the namespace part.
+# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
+# Note: This option applies only to the class list, not to the alphabetical
+# list.
+# The default value is: NO.
+
+SORT_BY_SCOPE_NAME     = NO
+
+# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to do proper
+# type resolution of all parameters of a function it will reject a match between
+# the prototype and the implementation of a member function even if there is
+# only one candidate or it is obvious which candidate to choose by doing a
+# simple string match. By disabling STRICT_PROTO_MATCHING doxygen will still
+# accept a match between prototype and implementation in such cases.
+# The default value is: NO.
+
+STRICT_PROTO_MATCHING  = NO
+
+# The GENERATE_TODOLIST tag can be used to enable (YES) or disable (NO) the todo
+# list. This list is created by putting \todo commands in the documentation.
+# The default value is: YES.
+
+GENERATE_TODOLIST      = YES
+
+# The GENERATE_TESTLIST tag can be used to enable (YES) or disable (NO) the test
+# list. This list is created by putting \test commands in the documentation.
+# The default value is: YES.
+
+GENERATE_TESTLIST      = YES
+
+# The GENERATE_BUGLIST tag can be used to enable (YES) or disable (NO) the bug
+# list. This list is created by putting \bug commands in the documentation.
+# The default value is: YES.
+
+GENERATE_BUGLIST       = YES
+
+# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or disable (NO)
+# the deprecated list. This list is created by putting \deprecated commands in
+# the documentation.
+# The default value is: YES.
+
+GENERATE_DEPRECATEDLIST= YES
+
+# The ENABLED_SECTIONS tag can be used to enable conditional documentation
+# sections, marked by \if <section_label> ... \endif and \cond <section_label>
+# ... \endcond blocks.
+
+ENABLED_SECTIONS       =
+
+# The MAX_INITIALIZER_LINES tag determines the maximum number of lines that the
+# initial value of a variable or macro / define can have for it to appear in the
+# documentation. If the initializer consists of more lines than specified here
+# it will be hidden. Use a value of 0 to hide initializers completely. The
+# appearance of the value of individual variables and macros / defines can be
+# controlled using \showinitializer or \hideinitializer command in the
+# documentation regardless of this setting.
+# Minimum value: 0, maximum value: 10000, default value: 30.
+
+MAX_INITIALIZER_LINES  = 30
+
+# Set the SHOW_USED_FILES tag to NO to disable the list of files generated at
+# the bottom of the documentation of classes and structs. If set to YES, the
+# list will mention the files that were used to generate the documentation.
+# The default value is: YES.
+
+SHOW_USED_FILES        = YES
+
+# Set the SHOW_FILES tag to NO to disable the generation of the Files page. This
+# will remove the Files entry from the Quick Index and from the Folder Tree View
+# (if specified).
+# The default value is: YES.
+
+SHOW_FILES             = YES
+
+# Set the SHOW_NAMESPACES tag to NO to disable the generation of the Namespaces
+# page. This will remove the Namespaces entry from the Quick Index and from the
+# Folder Tree View (if specified).
+# The default value is: YES.
+
+SHOW_NAMESPACES        = YES
+
+# The FILE_VERSION_FILTER tag can be used to specify a program or script that
+# doxygen should invoke to get the current version for each file (typically from
+# the version control system). Doxygen will invoke the program by executing (via
+# popen()) the command command input-file, where command is the value of the
+# FILE_VERSION_FILTER tag, and input-file is the name of an input file provided
+# by doxygen. Whatever the program writes to standard output is used as the file
+# version. For an example see the documentation.
+
+FILE_VERSION_FILTER    =
+
+# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
+# by doxygen. The layout file controls the global structure of the generated
+# output files in an output format independent way. To create the layout file
+# that represents doxygen's defaults, run doxygen with the -l option. You can
+# optionally specify a file name after the option, if omitted DoxygenLayout.xml
+# will be used as the name of the layout file.
+#
+# Note that if you run doxygen from a directory containing a file called
+# DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE
+# tag is left empty.
+
+LAYOUT_FILE            =
+
+# The CITE_BIB_FILES tag can be used to specify one or more bib files containing
+# the reference definitions. This must be a list of .bib files. The .bib
+# extension is automatically appended if omitted. This requires the bibtex tool
+# to be installed. See also https://en.wikipedia.org/wiki/BibTeX for more info.
+# For LaTeX the style of the bibliography can be controlled using
+# LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the
+# search path. See also \cite for info how to create references.
+
+CITE_BIB_FILES         =
+
+#---------------------------------------------------------------------------
+# Configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+
+# The QUIET tag can be used to turn on/off the messages that are generated to
+# standard output by doxygen. If QUIET is set to YES this implies that the
+# messages are off.
+# The default value is: NO.
+
+QUIET                  = YES
+
+# The WARNINGS tag can be used to turn on/off the warning messages that are
+# generated to standard error (stderr) by doxygen. If WARNINGS is set to YES
+# this implies that the warnings are on.
+#
+# Tip: Turn warnings on while writing the documentation.
+# The default value is: YES.
+
+WARNINGS               = YES
+
+# If the WARN_IF_UNDOCUMENTED tag is set to YES then doxygen will generate
+# warnings for undocumented members. If EXTRACT_ALL is set to YES then this flag
+# will automatically be disabled.
+# The default value is: YES.
+
+WARN_IF_UNDOCUMENTED   = YES
+
+# If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for
+# potential errors in the documentation, such as not documenting some parameters
+# in a documented function, or documenting parameters that don't exist or using
+# markup commands wrongly.
+# The default value is: YES.
+
+WARN_IF_DOC_ERROR      = YES
+
+# This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that
+# are documented, but have no documentation for their parameters or return
+# value. If set to NO, doxygen will only warn about wrong or incomplete
+# parameter documentation, but not about the absence of documentation. If
+# EXTRACT_ALL is set to YES then this flag will automatically be disabled.
+# The default value is: NO.
+
+WARN_NO_PARAMDOC       = NO
+
+# If the WARN_AS_ERROR tag is set to YES then doxygen will immediately stop when
+# a warning is encountered. If the WARN_AS_ERROR tag is set to FAIL_ON_WARNINGS
+# then doxygen will continue running as if WARN_AS_ERROR tag is set to NO, but
+# at the end of the doxygen process doxygen will return with a non-zero status.
+# Possible values are: NO, YES and FAIL_ON_WARNINGS.
+# The default value is: NO.
+
+WARN_AS_ERROR          = NO
+
+# The WARN_FORMAT tag determines the format of the warning messages that doxygen
+# can produce. The string should contain the $file, $line, and $text tags, which
+# will be replaced by the file and line number from which the warning originated
+# and the warning text. Optionally the format may contain $version, which will
+# be replaced by the version of the file (if it could be obtained via
+# FILE_VERSION_FILTER)
+# The default value is: $file:$line: $text.
+
+WARN_FORMAT            = "$file:$line: $text"
+
+# The WARN_LOGFILE tag can be used to specify a file to which warning and error
+# messages should be written. If left blank the output is written to standard
+# error (stderr).
+
+WARN_LOGFILE           =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the input files
+#---------------------------------------------------------------------------
+
+# The INPUT tag is used to specify the files and/or directories that contain
+# documented source files. You may enter file names like myfile.cpp or
+# directories like /usr/src/myproject. Separate the files or directories with
+# spaces. See also FILE_PATTERNS and EXTENSION_MAPPING
+# Note: If this tag is empty the current directory is searched.
+
+INPUT = @CMAKE_CURRENT_SOURCE_DIR@/libheif/api/libheif/heif.h \
+@CMAKE_CURRENT_SOURCE_DIR@/libheif/api/libheif/heif_items.h \
+@CMAKE_CURRENT_SOURCE_DIR@/libheif/api/libheif/heif_regions.h \
+@CMAKE_CURRENT_SOURCE_DIR@/libheif/api/libheif/heif_text.h
+@CMAKE_CURRENT_SOURCE_DIR@/libheif/api/libheif/heif_library.h \
+@CMAKE_CURRENT_SOURCE_DIR@/libheif/api/libheif/heif_encoding.h \
+@CMAKE_CURRENT_SOURCE_DIR@/libheif/api/libheif/heif_sequences.h
+
+# This tag can be used to specify the character encoding of the source files
+# that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
+# libiconv (or the iconv built into libc) for the transcoding. See the libiconv
+# documentation (see:
+# https://www.gnu.org/software/libiconv/) for the list of possible encodings.
+# The default value is: UTF-8.
+
+INPUT_ENCODING         = UTF-8
+
+# If the value of the INPUT tag contains directories, you can use the
+# FILE_PATTERNS tag to specify one or more wildcard patterns (like *.cpp and
+# *.h) to filter out the source-files in the directories.
+#
+# Note that for custom extensions or not directly supported extensions you also
+# need to set EXTENSION_MAPPING for the extension otherwise the files are not
+# read by doxygen.
+#
+# Note the list of default checked file patterns might differ from the list of
+# default file extension mappings.
+#
+# If left blank the following patterns are tested:*.c, *.cc, *.cxx, *.cpp,
+# *.c++, *.java, *.ii, *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h,
+# *.hh, *.hxx, *.hpp, *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc,
+# *.m, *.markdown, *.md, *.mm, *.dox (to be provided as doxygen C comment),
+# *.py, *.pyw, *.f90, *.f95, *.f03, *.f08, *.f18, *.f, *.for, *.vhd, *.vhdl,
+# *.ucf, *.qsf and *.ice.
+
+FILE_PATTERNS          = *.c \
+                         *.cc \
+                         *.cxx \
+                         *.cpp \
+                         *.c++ \
+                         *.java \
+                         *.ii \
+                         *.ixx \
+                         *.ipp \
+                         *.i++ \
+                         *.inl \
+                         *.idl \
+                         *.ddl \
+                         *.odl \
+                         *.h \
+                         *.hh \
+                         *.hxx \
+                         *.hpp \
+                         *.h++ \
+                         *.cs \
+                         *.d \
+                         *.php \
+                         *.php4 \
+                         *.php5 \
+                         *.phtml \
+                         *.inc \
+                         *.m \
+                         *.markdown \
+                         *.md \
+                         *.mm \
+                         *.dox \
+                         *.py \
+                         *.pyw \
+                         *.f90 \
+                         *.f95 \
+                         *.f03 \
+                         *.f08 \
+                         *.f18 \
+                         *.f \
+                         *.for \
+                         *.vhd \
+                         *.vhdl \
+                         *.ucf \
+                         *.qsf \
+                         *.ice
+
+# The RECURSIVE tag can be used to specify whether or not subdirectories should
+# be searched for input files as well.
+# The default value is: NO.
+
+RECURSIVE              = NO
+
+# The EXCLUDE tag can be used to specify files and/or directories that should be
+# excluded from the INPUT source files. This way you can easily exclude a
+# subdirectory from a directory tree whose root is specified with the INPUT tag.
+#
+# Note that relative paths are relative to the directory from which doxygen is
+# run.
+
+EXCLUDE                =
+
+# The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
+# directories that are symbolic links (a Unix file system feature) are excluded
+# from the input.
+# The default value is: NO.
+
+EXCLUDE_SYMLINKS       = NO
+
+# If the value of the INPUT tag contains directories, you can use the
+# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
+# certain files from those directories.
+#
+# Note that the wildcards are matched against the file with absolute path, so to
+# exclude all test directories for example use the pattern */test/*
+
+EXCLUDE_PATTERNS       =
+
+# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
+# (namespaces, classes, functions, etc.) that should be excluded from the
+# output. The symbol name can be a fully qualified name, a word, or if the
+# wildcard * is used, a substring. Examples: ANamespace, AClass,
+# AClass::ANamespace, ANamespace::*Test
+#
+# Note that the wildcards are matched against the file with absolute path, so to
+# exclude all test directories use the pattern */test/*
+
+EXCLUDE_SYMBOLS        =
+
+# The EXAMPLE_PATH tag can be used to specify one or more files or directories
+# that contain example code fragments that are included (see the \include
+# command).
+
+EXAMPLE_PATH           =
+
+# If the value of the EXAMPLE_PATH tag contains directories, you can use the
+# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and
+# *.h) to filter out the source-files in the directories. If left blank all
+# files are included.
+
+EXAMPLE_PATTERNS       = *
+
+# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
+# searched for input files to be used with the \include or \dontinclude commands
+# irrespective of the value of the RECURSIVE tag.
+# The default value is: NO.
+
+EXAMPLE_RECURSIVE      = NO
+
+# The IMAGE_PATH tag can be used to specify one or more files or directories
+# that contain images that are to be included in the documentation (see the
+# \image command).
+
+IMAGE_PATH             =
+
+# The INPUT_FILTER tag can be used to specify a program that doxygen should
+# invoke to filter for each input file. Doxygen will invoke the filter program
+# by executing (via popen()) the command:
+#
+# <filter> <input-file>
+#
+# where <filter> is the value of the INPUT_FILTER tag, and <input-file> is the
+# name of an input file. Doxygen will then use the output that the filter
+# program writes to standard output. If FILTER_PATTERNS is specified, this tag
+# will be ignored.
+#
+# Note that the filter must not add or remove lines; it is applied before the
+# code is scanned, but not when the output code is generated. If lines are added
+# or removed, the anchors will not be placed correctly.
+#
+# Note that for custom extensions or not directly supported extensions you also
+# need to set EXTENSION_MAPPING for the extension otherwise the files are not
+# properly processed by doxygen.
+
+INPUT_FILTER           =
+
+# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
+# basis. Doxygen will compare the file name with each pattern and apply the
+# filter if there is a match. The filters are a list of the form: pattern=filter
+# (like *.cpp=my_cpp_filter). See INPUT_FILTER for further information on how
+# filters are used. If the FILTER_PATTERNS tag is empty or if none of the
+# patterns match the file name, INPUT_FILTER is applied.
+#
+# Note that for custom extensions or not directly supported extensions you also
+# need to set EXTENSION_MAPPING for the extension otherwise the files are not
+# properly processed by doxygen.
+
+FILTER_PATTERNS        =
+
+# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
+# INPUT_FILTER) will also be used to filter the input files that are used for
+# producing the source files to browse (i.e. when SOURCE_BROWSER is set to YES).
+# The default value is: NO.
+
+FILTER_SOURCE_FILES    = NO
+
+# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file
+# pattern. A pattern will override the setting for FILTER_PATTERN (if any) and
+# it is also possible to disable source filtering for a specific pattern using
+# *.ext= (so without naming a filter).
+# This tag requires that the tag FILTER_SOURCE_FILES is set to YES.
+
+FILTER_SOURCE_PATTERNS =
+
+# If the USE_MDFILE_AS_MAINPAGE tag refers to the name of a markdown file that
+# is part of the input, its contents will be placed on the main page
+# (index.html). This can be useful if you have a project on for instance GitHub
+# and want to reuse the introduction page also for the doxygen output.
+
+USE_MDFILE_AS_MAINPAGE =
+
+#---------------------------------------------------------------------------
+# Configuration options related to source browsing
+#---------------------------------------------------------------------------
+
+# If the SOURCE_BROWSER tag is set to YES then a list of source files will be
+# generated. Documented entities will be cross-referenced with these sources.
+#
+# Note: To get rid of all source code in the generated output, make sure that
+# also VERBATIM_HEADERS is set to NO.
+# The default value is: NO.
+
+SOURCE_BROWSER         = NO
+
+# Setting the INLINE_SOURCES tag to YES will include the body of functions,
+# classes and enums directly into the documentation.
+# The default value is: NO.
+
+INLINE_SOURCES         = NO
+
+# Setting the STRIP_CODE_COMMENTS tag to YES will instruct doxygen to hide any
+# special comment blocks from generated source code fragments. Normal C, C++ and
+# Fortran comments will always remain visible.
+# The default value is: YES.
+
+STRIP_CODE_COMMENTS    = YES
+
+# If the REFERENCED_BY_RELATION tag is set to YES then for each documented
+# entity all documented functions referencing it will be listed.
+# The default value is: NO.
+
+REFERENCED_BY_RELATION = NO
+
+# If the REFERENCES_RELATION tag is set to YES then for each documented function
+# all documented entities called/used by that function will be listed.
+# The default value is: NO.
+
+REFERENCES_RELATION    = NO
+
+# If the REFERENCES_LINK_SOURCE tag is set to YES and SOURCE_BROWSER tag is set
+# to YES then the hyperlinks from functions in REFERENCES_RELATION and
+# REFERENCED_BY_RELATION lists will link to the source code. Otherwise they will
+# link to the documentation.
+# The default value is: YES.
+
+REFERENCES_LINK_SOURCE = YES
+
+# If SOURCE_TOOLTIPS is enabled (the default) then hovering a hyperlink in the
+# source code will show a tooltip with additional information such as prototype,
+# brief description and links to the definition and documentation. Since this
+# will make the HTML file larger and loading of large files a bit slower, you
+# can opt to disable this feature.
+# The default value is: YES.
+# This tag requires that the tag SOURCE_BROWSER is set to YES.
+
+SOURCE_TOOLTIPS        = YES
+
+# If the USE_HTAGS tag is set to YES then the references to source code will
+# point to the HTML generated by the htags(1) tool instead of doxygen built-in
+# source browser. The htags tool is part of GNU's global source tagging system
+# (see https://www.gnu.org/software/global/global.html). You will need version
+# 4.8.6 or higher.
+#
+# To use it do the following:
+# - Install the latest version of global
+# - Enable SOURCE_BROWSER and USE_HTAGS in the configuration file
+# - Make sure the INPUT points to the root of the source tree
+# - Run doxygen as normal
+#
+# Doxygen will invoke htags (and that will in turn invoke gtags), so these
+# tools must be available from the command line (i.e. in the search path).
+#
+# The result: instead of the source browser generated by doxygen, the links to
+# source code will now point to the output of htags.
+# The default value is: NO.
+# This tag requires that the tag SOURCE_BROWSER is set to YES.
+
+USE_HTAGS              = NO
+
+# If the VERBATIM_HEADERS tag is set the YES then doxygen will generate a
+# verbatim copy of the header file for each class for which an include is
+# specified. Set to NO to disable this.
+# See also: Section \class.
+# The default value is: YES.
+
+VERBATIM_HEADERS       = YES
+
+# If the CLANG_ASSISTED_PARSING tag is set to YES then doxygen will use the
+# clang parser (see:
+# http://clang.llvm.org/) for more accurate parsing at the cost of reduced
+# performance. This can be particularly helpful with template rich C++ code for
+# which doxygen's built-in parser lacks the necessary type information.
+# Note: The availability of this option depends on whether or not doxygen was
+# generated with the -Duse_libclang=ON option for CMake.
+# The default value is: NO.
+
+CLANG_ASSISTED_PARSING = NO
+
+# If clang assisted parsing is enabled and the CLANG_ADD_INC_PATHS tag is set to
+# YES then doxygen will add the directory of each input to the include path.
+# The default value is: YES.
+
+CLANG_ADD_INC_PATHS    = YES
+
+# If clang assisted parsing is enabled you can provide the compiler with command
+# line options that you would normally use when invoking the compiler. Note that
+# the include paths will already be set by doxygen for the files and directories
+# specified with INPUT and INCLUDE_PATH.
+# This tag requires that the tag CLANG_ASSISTED_PARSING is set to YES.
+
+CLANG_OPTIONS          =
+
+# If clang assisted parsing is enabled you can provide the clang parser with the
+# path to the directory containing a file called compile_commands.json. This
+# file is the compilation database (see:
+# http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html) containing the
+# options used when the source files were built. This is equivalent to
+# specifying the -p option to a clang tool, such as clang-check. These options
+# will then be passed to the parser. Any options specified with CLANG_OPTIONS
+# will be added as well.
+# Note: The availability of this option depends on whether or not doxygen was
+# generated with the -Duse_libclang=ON option for CMake.
+
+CLANG_DATABASE_PATH    =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+
+# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index of all
+# compounds will be generated. Enable this if the project contains a lot of
+# classes, structs, unions or interfaces.
+# The default value is: YES.
+
+ALPHABETICAL_INDEX     = YES
+
+# In case all classes in a project start with a common prefix, all classes will
+# be put under the same header in the alphabetical index. The IGNORE_PREFIX tag
+# can be used to specify a prefix (or a list of prefixes) that should be ignored
+# while generating the index headers.
+# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
+
+IGNORE_PREFIX          =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the HTML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_HTML tag is set to YES, doxygen will generate HTML output
+# The default value is: YES.
+
+GENERATE_HTML          = YES
+
+# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: html.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_OUTPUT            = html
+
+# The HTML_FILE_EXTENSION tag can be used to specify the file extension for each
+# generated HTML page (for example: .htm, .php, .asp).
+# The default value is: .html.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_FILE_EXTENSION    = .html
+
+# The HTML_HEADER tag can be used to specify a user-defined HTML header file for
+# each generated HTML page. If the tag is left blank doxygen will generate a
+# standard header.
+#
+# To get valid HTML the header file that includes any scripts and style sheets
+# that doxygen needs, which is dependent on the configuration options used (e.g.
+# the setting GENERATE_TREEVIEW). It is highly recommended to start with a
+# default header using
+# doxygen -w html new_header.html new_footer.html new_stylesheet.css
+# YourConfigFile
+# and then modify the file new_header.html. See also section "Doxygen usage"
+# for information on how to generate the default header that doxygen normally
+# uses.
+# Note: The header is subject to change so you typically have to regenerate the
+# default header when upgrading to a newer version of doxygen. For a description
+# of the possible markers and block names see the documentation.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_HEADER            =
+
+# The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each
+# generated HTML page. If the tag is left blank doxygen will generate a standard
+# footer. See HTML_HEADER for more information on how to generate a default
+# footer and what special commands can be used inside the footer. See also
+# section "Doxygen usage" for information on how to generate the default footer
+# that doxygen normally uses.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_FOOTER            =
+
+# The HTML_STYLESHEET tag can be used to specify a user-defined cascading style
+# sheet that is used by each HTML page. It can be used to fine-tune the look of
+# the HTML output. If left blank doxygen will generate a default style sheet.
+# See also section "Doxygen usage" for information on how to generate the style
+# sheet that doxygen normally uses.
+# Note: It is recommended to use HTML_EXTRA_STYLESHEET instead of this tag, as
+# it is more robust and this tag (HTML_STYLESHEET) will in the future become
+# obsolete.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_STYLESHEET        =
+
+# The HTML_EXTRA_STYLESHEET tag can be used to specify additional user-defined
+# cascading style sheets that are included after the standard style sheets
+# created by doxygen. Using this option one can overrule certain style aspects.
+# This is preferred over using HTML_STYLESHEET since it does not replace the
+# standard style sheet and is therefore more robust against future updates.
+# Doxygen will copy the style sheet files to the output directory.
+# Note: The order of the extra style sheet files is of importance (e.g. the last
+# style sheet in the list overrules the setting of the previous ones in the
+# list). For an example see the documentation.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_EXTRA_STYLESHEET  =
+
+# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
+# other source files which should be copied to the HTML output directory. Note
+# that these files will be copied to the base HTML output directory. Use the
+# $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these
+# files. In the HTML_STYLESHEET file, use the file name only. Also note that the
+# files will be copied as-is; there are no commands or markers available.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_EXTRA_FILES       =
+
+# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen
+# will adjust the colors in the style sheet and background images according to
+# this color. Hue is specified as an angle on a colorwheel, see
+# https://en.wikipedia.org/wiki/Hue for more information. For instance the value
+# 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300
+# purple, and 360 is red again.
+# Minimum value: 0, maximum value: 359, default value: 220.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_COLORSTYLE_HUE    = 220
+
+# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors
+# in the HTML output. For a value of 0 the output will use grayscales only. A
+# value of 255 will produce the most vivid colors.
+# Minimum value: 0, maximum value: 255, default value: 100.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_COLORSTYLE_SAT    = 100
+
+# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to the
+# luminance component of the colors in the HTML output. Values below 100
+# gradually make the output lighter, whereas values above 100 make the output
+# darker. The value divided by 100 is the actual gamma applied, so 80 represents
+# a gamma of 0.8, The value 220 represents a gamma of 2.2, and 100 does not
+# change the gamma.
+# Minimum value: 40, maximum value: 240, default value: 80.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_COLORSTYLE_GAMMA  = 80
+
+# If the HTML_DYNAMIC_MENUS tag is set to YES then the generated HTML
+# documentation will contain a main index with vertical navigation menus that
+# are dynamically created via JavaScript. If disabled, the navigation index will
+# consists of multiple levels of tabs that are statically embedded in every HTML
+# page. Disable this option to support browsers that do not have JavaScript,
+# like the Qt help browser.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_DYNAMIC_MENUS     = YES
+
+# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
+# documentation will contain sections that can be hidden and shown after the
+# page has loaded.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_DYNAMIC_SECTIONS  = NO
+
+# With HTML_INDEX_NUM_ENTRIES one can control the preferred number of entries
+# shown in the various tree structured indices initially; the user can expand
+# and collapse entries dynamically later on. Doxygen will expand the tree to
+# such a level that at most the specified number of entries are visible (unless
+# a fully collapsed tree already exceeds this amount). So setting the number of
+# entries 1 will produce a full collapsed tree by default. 0 is a special value
+# representing an infinite number of entries and will result in a full expanded
+# tree by default.
+# Minimum value: 0, maximum value: 9999, default value: 100.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_INDEX_NUM_ENTRIES = 100
+
+# If the GENERATE_DOCSET tag is set to YES, additional index files will be
+# generated that can be used as input for Apple's Xcode 3 integrated development
+# environment (see:
+# https://developer.apple.com/xcode/), introduced with OSX 10.5 (Leopard). To
+# create a documentation set, doxygen will generate a Makefile in the HTML
+# output directory. Running make will produce the docset in that directory and
+# running make install will install the docset in
+# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at
+# startup. See https://developer.apple.com/library/archive/featuredarticles/Doxy
+# genXcode/_index.html for more information.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_DOCSET        = NO
+
+# This tag determines the name of the docset feed. A documentation feed provides
+# an umbrella under which multiple documentation sets from a single provider
+# (such as a company or product suite) can be grouped.
+# The default value is: Doxygen generated docs.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_FEEDNAME        = "Doxygen generated docs"
+
+# This tag specifies a string that should uniquely identify the documentation
+# set bundle. This should be a reverse domain-name style string, e.g.
+# com.mycompany.MyDocSet. Doxygen will append .docset to the name.
+# The default value is: org.doxygen.Project.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_BUNDLE_ID       = org.doxygen.Project
+
+# The DOCSET_PUBLISHER_ID tag specifies a string that should uniquely identify
+# the documentation publisher. This should be a reverse domain-name style
+# string, e.g. com.mycompany.MyDocSet.documentation.
+# The default value is: org.doxygen.Publisher.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
+
+# The DOCSET_PUBLISHER_NAME tag identifies the documentation publisher.
+# The default value is: Publisher.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_PUBLISHER_NAME  = Publisher
+
+# If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three
+# additional HTML index files: index.hhp, index.hhc, and index.hhk. The
+# index.hhp is a project file that can be read by Microsoft's HTML Help Workshop
+# (see:
+# https://www.microsoft.com/en-us/download/details.aspx?id=21138) on Windows.
+#
+# The HTML Help Workshop contains a compiler that can convert all HTML output
+# generated by doxygen into a single compiled HTML file (.chm). Compiled HTML
+# files are now used as the Windows 98 help format, and will replace the old
+# Windows help format (.hlp) on all Windows platforms in the future. Compressed
+# HTML files also contain an index, a table of contents, and you can search for
+# words in the documentation. The HTML workshop also contains a viewer for
+# compressed HTML files.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_HTMLHELP      = NO
+
+# The CHM_FILE tag can be used to specify the file name of the resulting .chm
+# file. You can add a path in front of the file if the result should not be
+# written to the html output directory.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+CHM_FILE               =
+
+# The HHC_LOCATION tag can be used to specify the location (absolute path
+# including file name) of the HTML help compiler (hhc.exe). If non-empty,
+# doxygen will try to run the HTML help compiler on the generated index.hhp.
+# The file has to be specified with full path.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+HHC_LOCATION           =
+
+# The GENERATE_CHI flag controls if a separate .chi index file is generated
+# (YES) or that it should be included in the main .chm file (NO).
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+GENERATE_CHI           = NO
+
+# The CHM_INDEX_ENCODING is used to encode HtmlHelp index (hhk), content (hhc)
+# and project file content.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+CHM_INDEX_ENCODING     =
+
+# The BINARY_TOC flag controls whether a binary table of contents is generated
+# (YES) or a normal table of contents (NO) in the .chm file. Furthermore it
+# enables the Previous and Next buttons.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+BINARY_TOC             = NO
+
+# The TOC_EXPAND flag can be set to YES to add extra items for group members to
+# the table of contents of the HTML help documentation and to the tree view.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+TOC_EXPAND             = NO
+
+# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
+# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated that
+# can be used as input for Qt's qhelpgenerator to generate a Qt Compressed Help
+# (.qch) of the generated HTML documentation.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_QHP           = NO
+
+# If the QHG_LOCATION tag is specified, the QCH_FILE tag can be used to specify
+# the file name of the resulting .qch file. The path specified is relative to
+# the HTML output folder.
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QCH_FILE               =
+
+# The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help
+# Project output. For more information please see Qt Help Project / Namespace
+# (see:
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#namespace).
+# The default value is: org.doxygen.Project.
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_NAMESPACE          = org.doxygen.Project
+
+# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt
+# Help Project output. For more information please see Qt Help Project / Virtual
+# Folders (see:
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#virtual-folders).
+# The default value is: doc.
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_VIRTUAL_FOLDER     = doc
+
+# If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom
+# filter to add. For more information please see Qt Help Project / Custom
+# Filters (see:
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom-filters).
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_CUST_FILTER_NAME   =
+
+# The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the
+# custom filter to add. For more information please see Qt Help Project / Custom
+# Filters (see:
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom-filters).
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_CUST_FILTER_ATTRS  =
+
+# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
+# project's filter section matches. Qt Help Project / Filter Attributes (see:
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#filter-attributes).
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_SECT_FILTER_ATTRS  =
+
+# The QHG_LOCATION tag can be used to specify the location (absolute path
+# including file name) of Qt's qhelpgenerator. If non-empty doxygen will try to
+# run qhelpgenerator on the generated .qhp file.
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHG_LOCATION           =
+
+# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files will be
+# generated, together with the HTML files, they form an Eclipse help plugin. To
+# install this plugin and make it available under the help contents menu in
+# Eclipse, the contents of the directory containing the HTML and XML files needs
+# to be copied into the plugins directory of eclipse. The name of the directory
+# within the plugins directory should be the same as the ECLIPSE_DOC_ID value.
+# After copying Eclipse needs to be restarted before the help appears.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_ECLIPSEHELP   = NO
+
+# A unique identifier for the Eclipse help plugin. When installing the plugin
+# the directory name containing the HTML and XML files should also have this
+# name. Each documentation set should have its own identifier.
+# The default value is: org.doxygen.Project.
+# This tag requires that the tag GENERATE_ECLIPSEHELP is set to YES.
+
+ECLIPSE_DOC_ID         = org.doxygen.Project
+
+# If you want full control over the layout of the generated HTML pages it might
+# be necessary to disable the index and replace it with your own. The
+# DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs) at top
+# of each HTML page. A value of NO enables the index and the value YES disables
+# it. Since the tabs in the index contain the same information as the navigation
+# tree, you can set this option to YES if you also set GENERATE_TREEVIEW to YES.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+DISABLE_INDEX          = NO
+
+# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
+# structure should be generated to display hierarchical information. If the tag
+# value is set to YES, a side panel will be generated containing a tree-like
+# index structure (just like the one that is generated for HTML Help). For this
+# to work a browser that supports JavaScript, DHTML, CSS and frames is required
+# (i.e. any modern browser). Windows users are probably better off using the
+# HTML help feature. Via custom style sheets (see HTML_EXTRA_STYLESHEET) one can
+# further fine-tune the look of the index. As an example, the default style
+# sheet generated by doxygen has an example that shows how to put an image at
+# the root of the tree instead of the PROJECT_NAME. Since the tree basically has
+# the same information as the tab index, you could consider setting
+# DISABLE_INDEX to YES when enabling this option.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_TREEVIEW      = NO
+
+# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that
+# doxygen will group on one line in the generated HTML documentation.
+#
+# Note that a value of 0 will completely suppress the enum values from appearing
+# in the overview section.
+# Minimum value: 0, maximum value: 20, default value: 4.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+ENUM_VALUES_PER_LINE   = 4
+
+# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be used
+# to set the initial width (in pixels) of the frame in which the tree is shown.
+# Minimum value: 0, maximum value: 1500, default value: 250.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+TREEVIEW_WIDTH         = 250
+
+# If the EXT_LINKS_IN_WINDOW option is set to YES, doxygen will open links to
+# external symbols imported via tag files in a separate window.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+EXT_LINKS_IN_WINDOW    = NO
+
+# If the HTML_FORMULA_FORMAT option is set to svg, doxygen will use the pdf2svg
+# tool (see https://github.com/dawbarton/pdf2svg) or inkscape (see
+# https://inkscape.org) to generate formulas as SVG images instead of PNGs for
+# the HTML output. These images will generally look nicer at scaled resolutions.
+# Possible values are: png (the default) and svg (looks nicer but requires the
+# pdf2svg or inkscape tool).
+# The default value is: png.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_FORMULA_FORMAT    = png
+
+# Use this tag to change the font size of LaTeX formulas included as images in
+# the HTML documentation. When you change the font size after a successful
+# doxygen run you need to manually remove any form_*.png images from the HTML
+# output directory to force them to be regenerated.
+# Minimum value: 8, maximum value: 50, default value: 10.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+FORMULA_FONTSIZE       = 10
+
+# The FORMULA_MACROFILE can contain LaTeX \newcommand and \renewcommand commands
+# to create new LaTeX commands to be used in formulas as building blocks. See
+# the section "Including formulas" for details.
+
+FORMULA_MACROFILE      =
+
+# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see
+# https://www.mathjax.org) which uses client side JavaScript for the rendering
+# instead of using pre-rendered bitmaps. Use this if you do not have LaTeX
+# installed or if you want to formulas look prettier in the HTML output. When
+# enabled you may also need to install MathJax separately and configure the path
+# to it using the MATHJAX_RELPATH option.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+USE_MATHJAX            = NO
+
+# When MathJax is enabled you can set the default output format to be used for
+# the MathJax output. See the MathJax site (see:
+# http://docs.mathjax.org/en/v2.7-latest/output.html) for more details.
+# Possible values are: HTML-CSS (which is slower, but has the best
+# compatibility), NativeMML (i.e. MathML) and SVG.
+# The default value is: HTML-CSS.
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_FORMAT         = HTML-CSS
+
+# When MathJax is enabled you need to specify the location relative to the HTML
+# output directory using the MATHJAX_RELPATH option. The destination directory
+# should contain the MathJax.js script. For instance, if the mathjax directory
+# is located at the same level as the HTML output directory, then
+# 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 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://cdn.jsdelivr.net/npm/mathjax@2
+
+# The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax
+# extension names that should be enabled during MathJax rendering. For example
+# MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_EXTENSIONS     =
+
+# The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces
+# of code that will be used on startup of the MathJax code. See the MathJax site
+# (see:
+# http://docs.mathjax.org/en/v2.7-latest/output.html) for more details. For an
+# example see the documentation.
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_CODEFILE       =
+
+# When the SEARCHENGINE tag is enabled doxygen will generate a search box for
+# the HTML output. The underlying search engine uses javascript and DHTML and
+# should work on any modern browser. Note that when using HTML help
+# (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets (GENERATE_DOCSET)
+# there is already a search function so this one should typically be disabled.
+# For large projects the javascript based search engine can be slow, then
+# enabling SERVER_BASED_SEARCH may provide a better solution. It is possible to
+# search using the keyboard; to jump to the search box use <access key> + S
+# (what the <access key> is depends on the OS and browser, but it is typically
+# <CTRL>, <ALT>/<option>, or both). Inside the search box use the <cursor down
+# key> to jump into the search results window, the results can be navigated
+# using the <cursor keys>. Press <Enter> to select an item or <escape> to cancel
+# the search. The filter options can be selected when the cursor is inside the
+# search box by pressing <Shift>+<cursor down>. Also here use the <cursor keys>
+# to select a filter and <Enter> or <escape> to activate or cancel the filter
+# option.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+SEARCHENGINE           = YES
+
+# When the SERVER_BASED_SEARCH tag is enabled the search engine will be
+# implemented using a web server instead of a web client using JavaScript. There
+# are two flavors of web server based searching depending on the EXTERNAL_SEARCH
+# setting. When disabled, doxygen will generate a PHP script for searching and
+# an index file used by the script. When EXTERNAL_SEARCH is enabled the indexing
+# and searching needs to be provided by external tools. See the section
+# "External Indexing and Searching" for details.
+# The default value is: NO.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+SERVER_BASED_SEARCH    = NO
+
+# When EXTERNAL_SEARCH tag is enabled doxygen will no longer generate the PHP
+# script for searching. Instead the search results are written to an XML file
+# which needs to be processed by an external indexer. Doxygen will invoke an
+# external search engine pointed to by the SEARCHENGINE_URL option to obtain the
+# search results.
+#
+# Doxygen ships with an example indexer (doxyindexer) and search engine
+# (doxysearch.cgi) which are based on the open source search engine library
+# Xapian (see:
+# https://xapian.org/).
+#
+# See the section "External Indexing and Searching" for details.
+# The default value is: NO.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+EXTERNAL_SEARCH        = NO
+
+# The SEARCHENGINE_URL should point to a search engine hosted by a web server
+# which will return the search results when EXTERNAL_SEARCH is enabled.
+#
+# Doxygen ships with an example indexer (doxyindexer) and search engine
+# (doxysearch.cgi) which are based on the open source search engine library
+# Xapian (see:
+# https://xapian.org/). See the section "External Indexing and Searching" for
+# details.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+SEARCHENGINE_URL       =
+
+# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the unindexed
+# search data is written to a file for indexing by an external tool. With the
+# SEARCHDATA_FILE tag the name of this file can be specified.
+# The default file is: searchdata.xml.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+SEARCHDATA_FILE        = searchdata.xml
+
+# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the
+# EXTERNAL_SEARCH_ID tag can be used as an identifier for the project. This is
+# useful in combination with EXTRA_SEARCH_MAPPINGS to search through multiple
+# projects and redirect the results back to the right project.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+EXTERNAL_SEARCH_ID     =
+
+# The EXTRA_SEARCH_MAPPINGS tag can be used to enable searching through doxygen
+# projects other than the one defined by this configuration file, but that are
+# all added to the same external search index. Each project needs to have a
+# unique id set via EXTERNAL_SEARCH_ID. The search mapping then maps the id of
+# to a relative location where the documentation can be found. The format is:
+# EXTRA_SEARCH_MAPPINGS = tagname1=loc1 tagname2=loc2 ...
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+EXTRA_SEARCH_MAPPINGS  =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_LATEX tag is set to YES, doxygen will generate LaTeX output.
+# The default value is: YES.
+
+GENERATE_LATEX         = NO
+
+# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: latex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_OUTPUT           = latex
+
+# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
+# invoked.
+#
+# Note that when not enabling USE_PDFLATEX the default is latex when enabling
+# USE_PDFLATEX the default is pdflatex and when in the later case latex is
+# chosen this is overwritten by pdflatex. For specific output languages the
+# default can have been set differently, this depends on the implementation of
+# the output language.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_CMD_NAME         =
+
+# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to generate
+# index for LaTeX.
+# Note: This tag is used in the Makefile / make.bat.
+# See also: LATEX_MAKEINDEX_CMD for the part in the generated output file
+# (.tex).
+# The default file is: makeindex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+MAKEINDEX_CMD_NAME     = makeindex
+
+# The LATEX_MAKEINDEX_CMD tag can be used to specify the command name to
+# generate index for LaTeX. In case there is no backslash (\) as first character
+# it will be automatically added in the LaTeX code.
+# Note: This tag is used in the generated output file (.tex).
+# See also: MAKEINDEX_CMD_NAME for the part in the Makefile / make.bat.
+# The default value is: makeindex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_MAKEINDEX_CMD    = makeindex
+
+# If the COMPACT_LATEX tag is set to YES, doxygen generates more compact LaTeX
+# documents. This may be useful for small projects and may help to save some
+# trees in general.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+COMPACT_LATEX          = NO
+
+# The PAPER_TYPE tag can be used to set the paper type that is used by the
+# printer.
+# Possible values are: a4 (210 x 297 mm), letter (8.5 x 11 inches), legal (8.5 x
+# 14 inches) and executive (7.25 x 10.5 inches).
+# The default value is: a4.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+PAPER_TYPE             = a4
+
+# The EXTRA_PACKAGES tag can be used to specify one or more LaTeX package names
+# that should be included in the LaTeX output. The package can be specified just
+# by its name or with the correct syntax as to be used with the LaTeX
+# \usepackage command. To get the times font for instance you can specify :
+# EXTRA_PACKAGES=times or EXTRA_PACKAGES={times}
+# To use the option intlimits with the amsmath package you can specify:
+# EXTRA_PACKAGES=[intlimits]{amsmath}
+# If left blank no extra packages will be included.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+EXTRA_PACKAGES         =
+
+# The LATEX_HEADER tag can be used to specify a personal LaTeX header for the
+# generated LaTeX document. The header should contain everything until the first
+# chapter. If it is left blank doxygen will generate a standard header. See
+# section "Doxygen usage" for information on how to let doxygen write the
+# default header to a separate file.
+#
+# Note: Only use a user-defined header if you know what you are doing! The
+# following commands have a special meaning inside the header: $title,
+# $datetime, $date, $doxygenversion, $projectname, $projectnumber,
+# $projectbrief, $projectlogo. Doxygen will replace $title with the empty
+# string, for the replacement values of the other commands the user is referred
+# to HTML_HEADER.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_HEADER           =
+
+# The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for the
+# generated LaTeX document. The footer should contain everything after the last
+# chapter. If it is left blank doxygen will generate a standard footer. See
+# LATEX_HEADER for more information on how to generate a default footer and what
+# special commands can be used inside the footer.
+#
+# Note: Only use a user-defined footer if you know what you are doing!
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_FOOTER           =
+
+# The LATEX_EXTRA_STYLESHEET tag can be used to specify additional user-defined
+# LaTeX style sheets that are included after the standard style sheets created
+# by doxygen. Using this option one can overrule certain style aspects. Doxygen
+# will copy the style sheet files to the output directory.
+# Note: The order of the extra style sheet files is of importance (e.g. the last
+# style sheet in the list overrules the setting of the previous ones in the
+# list).
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_EXTRA_STYLESHEET =
+
+# The LATEX_EXTRA_FILES tag can be used to specify one or more extra images or
+# other source files which should be copied to the LATEX_OUTPUT output
+# directory. Note that the files will be copied as-is; there are no commands or
+# markers available.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_EXTRA_FILES      =
+
+# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated is
+# prepared for conversion to PDF (using ps2pdf or pdflatex). The PDF file will
+# contain links (just like the HTML output) instead of page references. This
+# makes the output suitable for online browsing using a PDF viewer.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+PDF_HYPERLINKS         = YES
+
+# If the USE_PDFLATEX tag is set to YES, doxygen will use the engine as
+# specified with LATEX_CMD_NAME to generate the PDF file directly from the LaTeX
+# files. Set this option to YES, to get a higher quality PDF documentation.
+#
+# See also section LATEX_CMD_NAME for selecting the engine.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+USE_PDFLATEX           = YES
+
+# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \batchmode
+# command to the generated LaTeX files. This will instruct LaTeX to keep running
+# if errors occur, instead of asking the user for help. This option is also used
+# when generating formulas in HTML.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_BATCHMODE        = NO
+
+# If the LATEX_HIDE_INDICES tag is set to YES then doxygen will not include the
+# index chapters (such as File Index, Compound Index, etc.) in the output.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_HIDE_INDICES     = NO
+
+# The LATEX_BIB_STYLE tag can be used to specify the style to use for the
+# bibliography, e.g. plainnat, or ieeetr. See
+# https://en.wikipedia.org/wiki/BibTeX and \cite for more info.
+# The default value is: plain.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_BIB_STYLE        = plain
+
+# The LATEX_EMOJI_DIRECTORY tag is used to specify the (relative or absolute)
+# path from which the emoji images will be read. If a relative path is entered,
+# it will be relative to the LATEX_OUTPUT directory. If left blank the
+# LATEX_OUTPUT directory will be used.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_EMOJI_DIRECTORY  =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the RTF output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_RTF tag is set to YES, doxygen will generate RTF output. The
+# RTF output is optimized for Word 97 and may not look too pretty with other RTF
+# readers/editors.
+# The default value is: NO.
+
+GENERATE_RTF           = NO
+
+# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: rtf.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_OUTPUT             = rtf
+
+# If the COMPACT_RTF tag is set to YES, doxygen generates more compact RTF
+# documents. This may be useful for small projects and may help to save some
+# trees in general.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+COMPACT_RTF            = NO
+
+# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated will
+# contain hyperlink fields. The RTF file will contain links (just like the HTML
+# output) instead of page references. This makes the output suitable for online
+# browsing using Word or some other Word compatible readers that support those
+# fields.
+#
+# Note: WordPad (write) and others do not support links.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_HYPERLINKS         = NO
+
+# Load stylesheet definitions from file. Syntax is similar to doxygen's
+# configuration file, i.e. a series of assignments. You only have to provide
+# replacements, missing definitions are set to their default value.
+#
+# See also section "Doxygen usage" for information on how to generate the
+# default style sheet that doxygen normally uses.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_STYLESHEET_FILE    =
+
+# Set optional variables used in the generation of an RTF document. Syntax is
+# similar to doxygen's configuration file. A template extensions file can be
+# generated using doxygen -e rtf extensionFile.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_EXTENSIONS_FILE    =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the man page output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_MAN tag is set to YES, doxygen will generate man pages for
+# classes and files.
+# The default value is: NO.
+
+GENERATE_MAN           = YES
+
+# The MAN_OUTPUT tag is used to specify where the man pages will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it. A directory man3 will be created inside the directory specified by
+# MAN_OUTPUT.
+# The default directory is: man.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_OUTPUT             = man
+
+# The MAN_EXTENSION tag determines the extension that is added to the generated
+# man pages. In case the manual section does not start with a number, the number
+# 3 is prepended. The dot (.) at the beginning of the MAN_EXTENSION tag is
+# optional.
+# The default value is: .3.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_EXTENSION          = .3
+
+# The MAN_SUBDIR tag determines the name of the directory created within
+# MAN_OUTPUT in which the man pages are placed. If defaults to man followed by
+# MAN_EXTENSION with the initial . removed.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_SUBDIR             =
+
+# If the MAN_LINKS tag is set to YES and doxygen generates man output, then it
+# will generate one additional man file for each entity documented in the real
+# man page(s). These additional files only source the real man page, but without
+# them the man command would be unable to find the correct page.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_LINKS              = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the XML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_XML tag is set to YES, doxygen will generate an XML file that
+# captures the structure of the code including all documentation.
+# The default value is: NO.
+
+GENERATE_XML           = NO
+
+# The XML_OUTPUT tag is used to specify where the XML pages will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: xml.
+# This tag requires that the tag GENERATE_XML is set to YES.
+
+XML_OUTPUT             = xml
+
+# If the XML_PROGRAMLISTING tag is set to YES, doxygen will dump the program
+# listings (including syntax highlighting and cross-referencing information) to
+# the XML output. Note that enabling this will significantly increase the size
+# of the XML output.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_XML is set to YES.
+
+XML_PROGRAMLISTING     = YES
+
+# If the XML_NS_MEMB_FILE_SCOPE tag is set to YES, doxygen will include
+# namespace members in file scope as well, matching the HTML output.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_XML is set to YES.
+
+XML_NS_MEMB_FILE_SCOPE = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the DOCBOOK output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_DOCBOOK tag is set to YES, doxygen will generate Docbook files
+# that can be used to generate PDF.
+# The default value is: NO.
+
+GENERATE_DOCBOOK       = NO
+
+# The DOCBOOK_OUTPUT tag is used to specify where the Docbook pages will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be put in
+# front of it.
+# The default directory is: docbook.
+# This tag requires that the tag GENERATE_DOCBOOK is set to YES.
+
+DOCBOOK_OUTPUT         = docbook
+
+#---------------------------------------------------------------------------
+# Configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_AUTOGEN_DEF tag is set to YES, doxygen will generate an
+# AutoGen Definitions (see http://autogen.sourceforge.net/) file that captures
+# the structure of the code including all documentation. Note that this feature
+# is still experimental and incomplete at the moment.
+# The default value is: NO.
+
+GENERATE_AUTOGEN_DEF   = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the Perl module output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_PERLMOD tag is set to YES, doxygen will generate a Perl module
+# file that captures the structure of the code including all documentation.
+#
+# Note that this feature is still experimental and incomplete at the moment.
+# The default value is: NO.
+
+GENERATE_PERLMOD       = NO
+
+# If the PERLMOD_LATEX tag is set to YES, doxygen will generate the necessary
+# Makefile rules, Perl scripts and LaTeX code to be able to generate PDF and DVI
+# output from the Perl module output.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_PERLMOD is set to YES.
+
+PERLMOD_LATEX          = NO
+
+# If the PERLMOD_PRETTY tag is set to YES, the Perl module output will be nicely
+# formatted so it can be parsed by a human reader. This is useful if you want to
+# understand what is going on. On the other hand, if this tag is set to NO, the
+# size of the Perl module output will be much smaller and Perl will parse it
+# just the same.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_PERLMOD is set to YES.
+
+PERLMOD_PRETTY         = YES
+
+# The names of the make variables in the generated doxyrules.make file are
+# prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. This is useful
+# so different doxyrules.make files included by the same Makefile don't
+# overwrite each other's variables.
+# This tag requires that the tag GENERATE_PERLMOD is set to YES.
+
+PERLMOD_MAKEVAR_PREFIX =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor
+#---------------------------------------------------------------------------
+
+# If the ENABLE_PREPROCESSING tag is set to YES, doxygen will evaluate all
+# C-preprocessor directives found in the sources and include files.
+# The default value is: YES.
+
+ENABLE_PREPROCESSING   = YES
+
+# If the MACRO_EXPANSION tag is set to YES, doxygen will expand all macro names
+# in the source code. If set to NO, only conditional compilation will be
+# performed. Macro expansion can be done in a controlled way by setting
+# EXPAND_ONLY_PREDEF to YES.
+# The default value is: NO.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+MACRO_EXPANSION        = YES
+
+# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES then
+# the macro expansion is limited to the macros specified with the PREDEFINED and
+# EXPAND_AS_DEFINED tags.
+# The default value is: NO.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+EXPAND_ONLY_PREDEF     = YES
+
+# If the SEARCH_INCLUDES tag is set to YES, the include files in the
+# INCLUDE_PATH will be searched if a #include is found.
+# The default value is: YES.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+SEARCH_INCLUDES        = YES
+
+# The INCLUDE_PATH tag can be used to specify one or more directories that
+# contain include files that are not input files but should be processed by the
+# preprocessor.
+# This tag requires that the tag SEARCH_INCLUDES is set to YES.
+
+INCLUDE_PATH           =
+
+# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
+# patterns (like *.h and *.hpp) to filter out the header-files in the
+# directories. If left blank, the patterns specified with FILE_PATTERNS will be
+# used.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+INCLUDE_FILE_PATTERNS  =
+
+# The PREDEFINED tag can be used to specify one or more macro names that are
+# defined before the preprocessor is started (similar to the -D option of e.g.
+# gcc). The argument of the tag is a list of macros of the form: name or
+# name=definition (no spaces). If the definition and the "=" are omitted, "=1"
+# is assumed. To prevent a macro definition from being undefined via #undef or
+# recursively expanded use the := operator instead of the = operator.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+PREDEFINED             = LIBHEIF_API
+
+# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this
+# tag can be used to specify a list of macro names that should be expanded. The
+# macro definition that is found in the sources will be used. Use the PREDEFINED
+# tag if you want to use a different macro definition that overrules the
+# definition found in the source code.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+EXPAND_AS_DEFINED      =
+
+# If the SKIP_FUNCTION_MACROS tag is set to YES then doxygen's preprocessor will
+# remove all references to function-like macros that are alone on a line, have
+# an all uppercase name, and do not end with a semicolon. Such function macros
+# are typically used for boiler-plate code, and will confuse the parser if not
+# removed.
+# The default value is: YES.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+SKIP_FUNCTION_MACROS   = YES
+
+#---------------------------------------------------------------------------
+# Configuration options related to external references
+#---------------------------------------------------------------------------
+
+# The TAGFILES tag can be used to specify one or more tag files. For each tag
+# file the location of the external documentation should be added. The format of
+# a tag file without this location is as follows:
+# TAGFILES = file1 file2 ...
+# Adding location for the tag files is done as follows:
+# TAGFILES = file1=loc1 "file2 = loc2" ...
+# where loc1 and loc2 can be relative or absolute paths or URLs. See the
+# section "Linking to external documentation" for more information about the use
+# of tag files.
+# Note: Each tag file must have a unique name (where the name does NOT include
+# the path). If a tag file is not located in the directory in which doxygen is
+# run, you must also specify the path to the tagfile here.
+
+TAGFILES               =
+
+# When a file name is specified after GENERATE_TAGFILE, doxygen will create a
+# tag file that is based on the input files it reads. See section "Linking to
+# external documentation" for more information about the usage of tag files.
+
+GENERATE_TAGFILE       =
+
+# If the ALLEXTERNALS tag is set to YES, all external class will be listed in
+# the class index. If set to NO, only the inherited external classes will be
+# listed.
+# The default value is: NO.
+
+ALLEXTERNALS           = NO
+
+# If the EXTERNAL_GROUPS tag is set to YES, all external groups will be listed
+# in the modules index. If set to NO, only the current project's groups will be
+# listed.
+# The default value is: YES.
+
+EXTERNAL_GROUPS        = YES
+
+# If the EXTERNAL_PAGES tag is set to YES, all external pages will be listed in
+# the related pages index. If set to NO, only the current project's pages will
+# be listed.
+# The default value is: YES.
+
+EXTERNAL_PAGES         = YES
+
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool
+#---------------------------------------------------------------------------
+
+# You can include diagrams made with dia in doxygen documentation. Doxygen will
+# then run dia to produce the diagram and insert it in the documentation. The
+# DIA_PATH tag allows you to specify the directory where the dia binary resides.
+# If left empty dia is assumed to be found in the default search path.
+
+DIA_PATH               =
+
+# If set to YES the inheritance and collaboration graphs will hide inheritance
+# and usage relations if the target is undocumented or is not a class.
+# The default value is: YES.
+
+HIDE_UNDOC_RELATIONS   = YES
+
+# 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. The other options in this section have no effect if this option is
+# set to NO
+# The default value is: YES.
+
+HAVE_DOT               = YES
+
+# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is allowed
+# to run in parallel. When set to 0 doxygen will base this on the number of
+# processors available in the system. You can set it explicitly to a value
+# larger than 0 to get control over the balance between CPU load and processing
+# speed.
+# Minimum value: 0, maximum value: 32, default value: 0.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_NUM_THREADS        = 0
+
+
+# By default doxygen will tell dot to use the default font as specified with
+# DOT_FONTNAME. If you specify a different font using DOT_FONTNAME you can set
+# the path where dot can find it using this tag.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_FONTPATH           =
+
+# If the CLASS_GRAPH tag is set to YES then doxygen will generate a graph for
+# each documented class showing the direct and indirect inheritance relations.
+# Setting this tag to YES will force the CLASS_DIAGRAMS tag to NO.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+CLASS_GRAPH            = YES
+
+# If the COLLABORATION_GRAPH tag is set to YES then doxygen will generate a
+# graph for each documented class showing the direct and indirect implementation
+# dependencies (inheritance, containment, and class references variables) of the
+# class with other documented classes.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+COLLABORATION_GRAPH    = YES
+
+# If the GROUP_GRAPHS tag is set to YES then doxygen will generate a graph for
+# groups, showing the direct groups dependencies.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+GROUP_GRAPHS           = YES
+
+# If the UML_LOOK tag is set to YES, doxygen will generate inheritance and
+# collaboration diagrams in a style similar to the OMG's Unified Modeling
+# Language.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+UML_LOOK               = NO
+
+# If the UML_LOOK tag is enabled, the fields and methods are shown inside the
+# class node. If there are many fields or methods and many nodes the graph may
+# become too big to be useful. The UML_LIMIT_NUM_FIELDS threshold limits the
+# number of items for each type to make the size more manageable. Set this to 0
+# for no limit. Note that the threshold may be exceeded by 50% before the limit
+# is enforced. So when you set the threshold to 10, up to 15 fields may appear,
+# but if the number exceeds 15, the total amount of fields shown is limited to
+# 10.
+# Minimum value: 0, maximum value: 100, default value: 10.
+# This tag requires that the tag UML_LOOK is set to YES.
+
+UML_LIMIT_NUM_FIELDS   = 10
+
+# If the DOT_UML_DETAILS tag is set to NO, doxygen will show attributes and
+# methods without types and arguments in the UML graphs. If the DOT_UML_DETAILS
+# tag is set to YES, doxygen will add type and arguments for attributes and
+# methods in the UML graphs. If the DOT_UML_DETAILS tag is set to NONE, doxygen
+# will not generate fields with class member information in the UML graphs. The
+# class diagrams will look similar to the default class diagrams but using UML
+# notation for the relationships.
+# Possible values are: NO, YES and NONE.
+# The default value is: NO.
+# This tag requires that the tag UML_LOOK is set to YES.
+
+DOT_UML_DETAILS        = NO
+
+# The DOT_WRAP_THRESHOLD tag can be used to set the maximum number of characters
+# to display on a single line. If the actual line length exceeds this threshold
+# significantly it will wrapped across multiple lines. Some heuristics are apply
+# to avoid ugly line breaks.
+# Minimum value: 0, maximum value: 1000, default value: 17.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_WRAP_THRESHOLD     = 17
+
+# If the TEMPLATE_RELATIONS tag is set to YES then the inheritance and
+# collaboration graphs will show the relations between templates and their
+# instances.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+TEMPLATE_RELATIONS     = NO
+
+# If the INCLUDE_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are set to
+# YES then doxygen will generate a graph for each documented file showing the
+# direct and indirect include dependencies of the file with other documented
+# files.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+INCLUDE_GRAPH          = YES
+
+# If the INCLUDED_BY_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are
+# set to YES then doxygen will generate a graph for each documented file showing
+# the direct and indirect include dependencies of the file with other documented
+# files.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+INCLUDED_BY_GRAPH      = YES
+
+# If the CALL_GRAPH tag is set to YES then doxygen will generate a call
+# dependency graph for every global function or class method.
+#
+# Note that enabling this option will significantly increase the time of a run.
+# So in most cases it will be better to enable call graphs for selected
+# functions only using the \callgraph command. Disabling a call graph can be
+# accomplished by means of the command \hidecallgraph.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+CALL_GRAPH             = NO
+
+# If the CALLER_GRAPH tag is set to YES then doxygen will generate a caller
+# dependency graph for every global function or class method.
+#
+# Note that enabling this option will significantly increase the time of a run.
+# So in most cases it will be better to enable caller graphs for selected
+# functions only using the \callergraph command. Disabling a caller graph can be
+# accomplished by means of the command \hidecallergraph.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+CALLER_GRAPH           = NO
+
+# If the GRAPHICAL_HIERARCHY tag is set to YES then doxygen will graphical
+# hierarchy of all classes instead of a textual one.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+GRAPHICAL_HIERARCHY    = YES
+
+# If the DIRECTORY_GRAPH tag is set to YES then doxygen will show the
+# dependencies a directory has on other directories in a graphical way. The
+# dependency relations are determined by the #include relations between the
+# files in the directories.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DIRECTORY_GRAPH        = YES
+
+# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
+# generated by dot. For an explanation of the image formats see the section
+# output formats in the documentation of the dot tool (Graphviz (see:
+# http://www.graphviz.org/)).
+# Note: If you choose svg you need to set HTML_FILE_EXTENSION to xhtml in order
+# to make the SVG files visible in IE 9+ (other browsers do not have this
+# requirement).
+# Possible values are: png, png:cairo, png:cairo:cairo, png:cairo:gd, png:gd,
+# png:gd:gd, jpg, jpg:cairo, jpg:cairo:gd, jpg:gd, jpg:gd:gd, gif, gif:cairo,
+# gif:cairo:gd, gif:gd, gif:gd:gd, svg, png:gd, png:gd:gd, png:cairo,
+# png:cairo:gd, png:cairo:cairo, png:cairo:gdiplus, png:gdiplus and
+# png:gdiplus:gdiplus.
+# The default value is: png.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_IMAGE_FORMAT       = png
+
+# If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
+# enable generation of interactive SVG images that allow zooming and panning.
+#
+# Note that this requires a modern browser other than Internet Explorer. Tested
+# and working are Firefox, Chrome, Safari, and Opera.
+# Note: For IE 9+ you need to set HTML_FILE_EXTENSION to xhtml in order to make
+# the SVG files visible. Older versions of IE do not have SVG support.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+INTERACTIVE_SVG        = NO
+
+# The DOT_PATH tag can be used to specify the path where the dot tool can be
+# found. If left blank, it is assumed the dot tool can be found in the path.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_PATH               =
+
+# The DOTFILE_DIRS tag can be used to specify one or more directories that
+# contain dot files that are included in the documentation (see the \dotfile
+# command).
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOTFILE_DIRS           =
+
+# The MSCFILE_DIRS tag can be used to specify one or more directories that
+# contain msc files that are included in the documentation (see the \mscfile
+# command).
+
+MSCFILE_DIRS           =
+
+# The DIAFILE_DIRS tag can be used to specify one or more directories that
+# contain dia files that are included in the documentation (see the \diafile
+# command).
+
+DIAFILE_DIRS           =
+
+# When using plantuml, the PLANTUML_JAR_PATH tag should be used to specify the
+# path where java can find the plantuml.jar file. If left blank, it is assumed
+# PlantUML is not used or called during a preprocessing step. Doxygen will
+# generate a warning when it encounters a \startuml command in this case and
+# will not generate output for the diagram.
+
+PLANTUML_JAR_PATH      =
+
+# When using plantuml, the PLANTUML_CFG_FILE tag can be used to specify a
+# configuration file for plantuml.
+
+PLANTUML_CFG_FILE      =
+
+# When using plantuml, the specified paths are searched for files specified by
+# the !include statement in a plantuml block.
+
+PLANTUML_INCLUDE_PATH  =
+
+# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of nodes
+# that will be shown in the graph. If the number of nodes in a graph becomes
+# larger than this value, doxygen will truncate the graph, which is visualized
+# by representing a node as a red box. Note that doxygen if the number of direct
+# children of the root node in a graph is already larger than
+# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note that
+# the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
+# Minimum value: 0, maximum value: 10000, default value: 50.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_GRAPH_MAX_NODES    = 50
+
+# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the graphs
+# generated by dot. A depth value of 3 means that only nodes reachable from the
+# root by following a path via at most 3 edges will be shown. Nodes that lay
+# further from the root node will be omitted. Note that setting this option to 1
+# or 2 may greatly reduce the computation time needed for large code bases. Also
+# note that the size of a graph can be further restricted by
+# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
+# Minimum value: 0, maximum value: 1000, default value: 0.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+MAX_DOT_GRAPH_DEPTH    = 0
+
+# Set the DOT_MULTI_TARGETS tag to YES to allow dot to generate multiple output
+# files in one run (i.e. multiple -o and -T options on the command line). This
+# makes dot run faster, but since only newer versions of dot (>1.8.10) support
+# this, this feature is disabled by default.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_MULTI_TARGETS      = NO
+
+# If the GENERATE_LEGEND tag is set to YES doxygen will generate a legend page
+# explaining the meaning of the various boxes and arrows in the dot generated
+# graphs.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+GENERATE_LEGEND        = YES
+
+# If the DOT_CLEANUP tag is set to YES, doxygen will remove the intermediate
+# files that are used to generate the various graphs.
+#
+# Note: This setting is not only used for dot files but also for msc and
+# plantuml temporary files.
+# The default value is: YES.
+
+DOT_CLEANUP            = YES
diff --git a/libheif/Makefile.am b/libheif/Makefile.am
deleted file mode 100644
index eabc60ee5c..0000000000
--- a/libheif/Makefile.am
+++ /dev/null
@@ -1,176 +0,0 @@
-AUTOMAKE_OPTIONS = subdir-objects
-
-bin_PROGRAMS =
-lib_LTLIBRARIES =
-
-lib_LTLIBRARIES += libheif.la
-
-libheif_ladir = \
-        $(includedir)/libheif
-
-ADDITIONAL_LIBS =
-if HAVE_AOM
-ADDITIONAL_LIBS += $(aom_LIBS)
-endif
-
-if HAVE_LIBDE265
-ADDITIONAL_LIBS += $(libde265_LIBS)
-endif
-
-if HAVE_X265
-ADDITIONAL_LIBS += $(x265_LIBS)
-endif
-
-if HAVE_RAV1E
-ADDITIONAL_LIBS += $(rav1e_LIBS)
-endif
-
-if HAVE_DAV1D
-ADDITIONAL_LIBS += $(dav1d_LIBS)
-endif
-
-libheif_la_CPPFLAGS =
-libheif_la_CFLAGS = \
-  $(CFLAG_VISIBILITY) \
-  -DLIBHEIF_EXPORTS
-libheif_la_CXXFLAGS = \
-  $(CFLAG_VISIBILITY) \
-  $(aom_CFLAGS) \
-  $(libde265_CFLAGS) \
-  $(x265_CFLAGS) \
-  $(dav1d_CFLAGS) \
-  $(rav1e_CFLAGS) \
-  -DLIBHEIF_EXPORTS -I$(top_srcdir)
-libheif_la_LIBADD = $(ADDITIONAL_LIBS)
-
-libheif_la_LDFLAGS = -version-info $(LIBHEIF_CURRENT):$(LIBHEIF_REVISION):$(LIBHEIF_AGE)
-if MINGW
-libheif_la_LDFLAGS += -no-undefined
-endif
-
-libheif_la_SOURCES = \
-  bitstream.h \
-  bitstream.cc \
-  box.h \
-  box.cc \
-  error.h \
-  error.cc \
-  heif_api_structs.h \
-  heif_file.h \
-  heif_file.cc \
-  heif_image.h \
-  heif_image.cc \
-  heif_limits.h \
-  heif.h \
-  heif.cc \
-  heif_context.h \
-  heif_context.cc \
-  heif_hevc.h \
-  heif_hevc.cc \
-  heif_avif.h \
-  heif_avif.cc \
-  heif_plugin_registry.h \
-  heif_plugin_registry.cc \
-  heif_plugin.h \
-  heif_plugin.cc \
-  heif_colorconversion.h \
-  heif_colorconversion.cc \
-  logging.h \
-  nclx.cc \
-  nclx.h
-
-if HAVE_AOM_DECODER
-libheif_la_SOURCES += \
-  heif_decoder_aom.cc \
-  heif_decoder_aom.h
-endif
-
-if HAVE_AOM_ENCODER
-libheif_la_SOURCES += \
-  heif_encoder_aom.cc \
-  heif_encoder_aom.h
-endif
-
-if HAVE_LIBDE265
-libheif_la_SOURCES += \
-  heif_decoder_libde265.cc \
-  heif_decoder_libde265.h
-endif
-
-if HAVE_RAV1E
-libheif_la_SOURCES += \
-  heif_encoder_rav1e.cc \
-  heif_encoder_rav1e.h
-endif
-
-if HAVE_DAV1D
-libheif_la_SOURCES += \
-  heif_decoder_dav1d.cc \
-  heif_decoder_dav1d.h
-endif
-
-
-if HAVE_X265
-libheif_la_SOURCES += \
-  heif_encoder_x265.cc \
-  heif_encoder_x265.h
-endif
-
-libheif_la_HEADERS = \
-  heif.h \
-  heif_plugin.h \
-  heif_version.h \
-  heif_cxx.h
-
-noinst_HEADERS = \
-  heif_emscripten.h
-
-if HAVE_VISIBILITY
-libheif_la_CFLAGS += -DHAVE_VISIBILITY
-libheif_la_CXXFLAGS += -DHAVE_VISIBILITY
-endif
-
-if ENABLE_LIBFUZZER
-bin_PROGRAMS += box-fuzzer \
-  color-conversion-fuzzer
-if HAVE_LIBDE265
-bin_PROGRAMS += file-fuzzer
-endif
-if HAVE_X265
-bin_PROGRAMS += encoder-fuzzer
-endif
-else
-noinst_LIBRARIES = libfuzzers.a
-libfuzzers_a_SOURCES = \
-  box_fuzzer.cc \
-  color_conversion_fuzzer.cc \
-  encoder_fuzzer.cc \
-  file_fuzzer.cc
-endif
-
-box_fuzzer_DEPENDENCIES =
-box_fuzzer_CXXFLAGS = $(libde265_CFLAGS)
-box_fuzzer_LDFLAGS = $(FUZZING_ENGINE)
-box_fuzzer_LDADD = $(ADDITIONAL_LIBS)
-box_fuzzer_SOURCES = $(libheif_la_SOURCES) box_fuzzer.cc
-
-color_conversion_fuzzer_DEPENDENCIES =
-color_conversion_fuzzer_CXXFLAGS = $(libde265_CFLAGS)
-color_conversion_fuzzer_LDFLAGS = $(FUZZING_ENGINE)
-color_conversion_fuzzer_LDADD = $(ADDITIONAL_LIBS)
-color_conversion_fuzzer_SOURCES = $(libheif_la_SOURCES) color_conversion_fuzzer.cc
-
-encoder_fuzzer_DEPENDENCIES =
-encoder_fuzzer_CXXFLAGS = $(libde265_CFLAGS)
-encoder_fuzzer_LDFLAGS = $(FUZZING_ENGINE)
-encoder_fuzzer_LDADD = $(ADDITIONAL_LIBS)
-encoder_fuzzer_SOURCES = $(libheif_la_SOURCES) encoder_fuzzer.cc
-
-file_fuzzer_DEPENDENCIES =
-file_fuzzer_CXXFLAGS = $(libde265_CFLAGS)
-file_fuzzer_LDFLAGS = $(FUZZING_ENGINE)
-file_fuzzer_LDADD = $(ADDITIONAL_LIBS)
-file_fuzzer_SOURCES = $(libheif_la_SOURCES) file_fuzzer.cc
-
-EXTRA_DIST = \
-  CMakeLists.txt
diff --git a/libheif/api/libheif/heif.cc b/libheif/api/libheif/heif.cc
new file mode 100644
index 0000000000..a8de3f03d3
--- /dev/null
+++ b/libheif/api/libheif/heif.cc
@@ -0,0 +1,31 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017-2025 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "heif.h"
+
+#if defined(__EMSCRIPTEN__) && !defined(__EMSCRIPTEN_STANDALONE_WASM__)
+#include "api_structs.h"
+#include "heif_emscripten.h"
+#endif
+
+
+#include "error.h"
+
+const heif_error heif_error_success = {heif_error_Ok, heif_suberror_Unspecified, Error::kSuccess};
diff --git a/libheif/heif_avif.h b/libheif/api/libheif/heif.h
similarity index 53%
rename from libheif/heif_avif.h
rename to libheif/api/libheif/heif.h
index c9744f131d..dfbe5ba47a 100644
--- a/libheif/heif_avif.h
+++ b/libheif/api/libheif/heif.h
@@ -1,6 +1,6 @@
 /*
  * HEIF codec.
- * Copyright (c) 2017 struktur AG, Dirk Farin <farin@struktur.de>
+ * Copyright (c) 2017-2025 Dirk Farin <dirk.farin@gmail.com>
  *
  * This file is part of libheif.
  *
@@ -18,26 +18,24 @@
  * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef HEIF_AVIF_H
-#define HEIF_AVIF_H
-
-#include <cassert>
-#include <cmath>
-#include <memory>
-
-#include "heif.h"
-#include "box.h"
-#include "error.h"
-
-
-namespace heif {
-
-  class HeifPixelImage;
-
-  Error fill_av1C_configuration(Box_av1C::configuration* inout_config, std::shared_ptr<HeifPixelImage>);
-
-  bool fill_av1C_configuration_from_stream(Box_av1C::configuration* out_config, const uint8_t* data, int dataSize);
-
-}
+#ifndef LIBHEIF_HEIF_H
+#define LIBHEIF_HEIF_H
+
+#include <libheif/heif_library.h>
+#include <libheif/heif_version.h>
+#include <libheif/heif_image.h>
+#include <libheif/heif_color.h>
+#include <libheif/heif_error.h>
+#include <libheif/heif_brands.h>
+
+#include <libheif/heif_metadata.h>
+#include <libheif/heif_aux_images.h>
+#include <libheif/heif_entity_groups.h>
+#include <libheif/heif_security.h>
+#include <libheif/heif_encoding.h>
+#include <libheif/heif_decoding.h>
+#include <libheif/heif_context.h>
+#include <libheif/heif_image_handle.h>
+#include <libheif/heif_tiling.h>
 
 #endif
diff --git a/libheif/api/libheif/heif_aux_images.cc b/libheif/api/libheif/heif_aux_images.cc
new file mode 100644
index 0000000000..e7ec67ef2c
--- /dev/null
+++ b/libheif/api/libheif/heif_aux_images.cc
@@ -0,0 +1,336 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017-2025 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "heif_aux_images.h"
+#include "api_structs.h"
+
+#include <cassert>
+#include <cstring>
+#include <memory>
+#include <algorithm>
+
+
+// ------------------------- depth images -------------------------
+
+
+int heif_image_handle_has_depth_image(const heif_image_handle* handle)
+{
+  return handle->image->get_depth_channel() != nullptr;
+}
+
+
+int heif_image_handle_get_number_of_depth_images(const heif_image_handle* handle)
+{
+  auto depth_image = handle->image->get_depth_channel();
+
+  if (depth_image) {
+    return 1;
+  }
+  else {
+    return 0;
+  }
+}
+
+
+int heif_image_handle_get_list_of_depth_image_IDs(const heif_image_handle* handle,
+                                                  heif_item_id* ids, int count)
+{
+  auto depth_image = handle->image->get_depth_channel();
+
+  if (count == 0) {
+    return 0;
+  }
+
+  if (depth_image) {
+    ids[0] = depth_image->get_id();
+    return 1;
+  }
+  else {
+    return 0;
+  }
+}
+
+
+heif_error heif_image_handle_get_depth_image_handle(const heif_image_handle* handle,
+                                                    heif_item_id depth_id,
+                                                    heif_image_handle** out_depth_handle)
+{
+  if (out_depth_handle == nullptr) {
+    return heif_error_null_pointer_argument;
+  }
+
+  auto depth_image = handle->image->get_depth_channel();
+
+  if (depth_image->get_id() != depth_id) {
+    *out_depth_handle = nullptr;
+
+    Error err(heif_error_Usage_error, heif_suberror_Nonexisting_item_referenced);
+    return err.error_struct(handle->image.get());
+  }
+
+  *out_depth_handle = new heif_image_handle();
+  (*out_depth_handle)->image = depth_image;
+  (*out_depth_handle)->context = handle->context;
+
+  return Error::Ok.error_struct(handle->image.get());
+}
+
+
+void heif_depth_representation_info_free(const heif_depth_representation_info* info)
+{
+  delete info;
+}
+
+
+int heif_image_handle_get_depth_image_representation_info(const heif_image_handle* handle,
+                                                          heif_item_id depth_image_id,
+                                                          const heif_depth_representation_info** out)
+{
+  std::shared_ptr<ImageItem> depth_image;
+
+  if (out) {
+    if (handle->image->is_depth_channel()) {
+      // Because of an API bug before v1.11.0, the input handle may be the depth image (#422).
+      depth_image = handle->image;
+    }
+    else {
+      depth_image = handle->image->get_depth_channel();
+    }
+
+    if (depth_image->has_depth_representation_info()) {
+      auto info = new heif_depth_representation_info;
+      *info = depth_image->get_depth_representation_info();
+      *out = info;
+      return true;
+    }
+    else {
+      *out = nullptr;
+    }
+  }
+
+  return false;
+}
+
+
+// ------------------------- thumbnails -------------------------
+
+
+int heif_image_handle_get_number_of_thumbnails(const heif_image_handle* handle)
+{
+  return (int) handle->image->get_thumbnails().size();
+}
+
+
+int heif_image_handle_get_list_of_thumbnail_IDs(const heif_image_handle* handle,
+                                                heif_item_id* ids, int count)
+{
+  if (ids == nullptr) {
+    return 0;
+  }
+
+  auto thumbnails = handle->image->get_thumbnails();
+  int n = (int) std::min(count, (int) thumbnails.size());
+
+  for (int i = 0; i < n; i++) {
+    ids[i] = thumbnails[i]->get_id();
+  }
+
+  return n;
+}
+
+
+heif_error heif_image_handle_get_thumbnail(const heif_image_handle* handle,
+                                           heif_item_id thumbnail_id,
+                                           heif_image_handle** out_thumbnail_handle)
+{
+  if (!out_thumbnail_handle) {
+    return heif_error_null_pointer_argument;
+  }
+
+  auto thumbnails = handle->image->get_thumbnails();
+  for (const auto& thumb : thumbnails) {
+    if (thumb->get_id() == thumbnail_id) {
+      *out_thumbnail_handle = new heif_image_handle();
+      (*out_thumbnail_handle)->image = thumb;
+      (*out_thumbnail_handle)->context = handle->context;
+
+      return Error::Ok.error_struct(handle->image.get());
+    }
+  }
+
+  Error err(heif_error_Usage_error, heif_suberror_Nonexisting_item_referenced);
+  return err.error_struct(handle->image.get());
+}
+
+
+heif_error heif_context_encode_thumbnail(heif_context* ctx,
+                                         const heif_image* image,
+                                         const heif_image_handle* image_handle,
+                                         heif_encoder* encoder,
+                                         const heif_encoding_options* input_options,
+                                         int bbox_size,
+                                         heif_image_handle** out_image_handle)
+{
+  heif_encoding_options* options = heif_encoding_options_alloc();
+  heif_encoding_options_copy(options, input_options);
+
+  auto encodingResult = ctx->context->encode_thumbnail(image->image,
+                                                       encoder,
+                                                       *options,
+                                                       bbox_size);
+  heif_encoding_options_free(options);
+
+  if (!encodingResult) {
+    return encodingResult.error_struct(ctx->context.get());
+  }
+
+  std::shared_ptr<ImageItem> thumbnail_image = *encodingResult;
+
+  if (!thumbnail_image) {
+    Error err(heif_error_Usage_error,
+              heif_suberror_Invalid_parameter_value,
+              "Thumbnail images must be smaller than the original image.");
+    return err.error_struct(ctx->context.get());
+  }
+
+  Error error = ctx->context->assign_thumbnail(image_handle->image, thumbnail_image);
+  if (error != Error::Ok) {
+    return error.error_struct(ctx->context.get());
+  }
+
+
+  if (out_image_handle) {
+    *out_image_handle = new heif_image_handle;
+    (*out_image_handle)->image = thumbnail_image;
+    (*out_image_handle)->context = ctx->context;
+  }
+
+  return heif_error_success;
+}
+
+
+heif_error heif_context_assign_thumbnail(heif_context* ctx,
+                                         const heif_image_handle* master_image,
+                                         const heif_image_handle* thumbnail_image)
+{
+  Error error = ctx->context->assign_thumbnail(thumbnail_image->image, master_image->image);
+  return error.error_struct(ctx->context.get());
+}
+
+
+// ------------------------- auxiliary images -------------------------
+
+
+int heif_image_handle_get_number_of_auxiliary_images(const heif_image_handle* handle,
+                                                     int include_alpha_image)
+{
+  return (int) handle->image->get_aux_images(include_alpha_image).size();
+}
+
+
+int heif_image_handle_get_list_of_auxiliary_image_IDs(const heif_image_handle* handle,
+                                                      int include_alpha_image,
+                                                      heif_item_id* ids, int count)
+{
+  if (ids == nullptr) {
+    return 0;
+  }
+
+  auto auxImages = handle->image->get_aux_images(include_alpha_image);
+  int n = (int) std::min(count, (int) auxImages.size());
+
+  for (int i = 0; i < n; i++) {
+    ids[i] = auxImages[i]->get_id();
+  }
+
+  return n;
+}
+
+
+heif_error heif_image_handle_get_auxiliary_type(const heif_image_handle* handle,
+                                                const char** out_type)
+{
+  if (out_type == nullptr) {
+    return heif_error_null_pointer_argument;
+  }
+
+  *out_type = nullptr;
+
+  const auto& auxType = handle->image->get_aux_type();
+
+  char* buf = (char*) malloc(auxType.length() + 1);
+
+  if (buf == nullptr) {
+    return Error(heif_error_Memory_allocation_error,
+                 heif_suberror_Unspecified,
+                 "Failed to allocate memory for the type string").error_struct(handle->image.get());
+  }
+
+  strcpy(buf, auxType.c_str());
+  *out_type = buf;
+
+  return heif_error_success;
+}
+
+
+void heif_image_handle_release_auxiliary_type(const heif_image_handle* handle,
+                                              const char** out_type)
+{
+  if (out_type && *out_type) {
+    free((void*) *out_type);
+    *out_type = nullptr;
+  }
+}
+
+
+heif_error heif_image_handle_get_auxiliary_image_handle(const heif_image_handle* main_image_handle,
+                                                        heif_item_id auxiliary_id,
+                                                        heif_image_handle** out_auxiliary_handle)
+{
+  if (!out_auxiliary_handle) {
+    return heif_error_null_pointer_argument;
+  }
+
+  *out_auxiliary_handle = nullptr;
+
+  auto auxImages = main_image_handle->image->get_aux_images();
+  for (const auto& aux : auxImages) {
+    if (aux->get_id() == auxiliary_id) {
+      *out_auxiliary_handle = new heif_image_handle();
+      (*out_auxiliary_handle)->image = aux;
+      (*out_auxiliary_handle)->context = main_image_handle->context;
+
+      return Error::Ok.error_struct(main_image_handle->image.get());
+    }
+  }
+
+  Error err(heif_error_Usage_error, heif_suberror_Nonexisting_item_referenced);
+  return err.error_struct(main_image_handle->image.get());
+}
+
+
+// ===================== DEPRECATED =====================
+
+// DEPRECATED (typo)
+void heif_image_handle_free_auxiliary_types(const heif_image_handle* handle,
+                                            const char** out_type)
+{
+  heif_image_handle_release_auxiliary_type(handle, out_type);
+}
diff --git a/libheif/api/libheif/heif_aux_images.h b/libheif/api/libheif/heif_aux_images.h
new file mode 100644
index 0000000000..ad239e63fc
--- /dev/null
+++ b/libheif/api/libheif/heif_aux_images.h
@@ -0,0 +1,182 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017-2025 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_HEIF_AUX_IMAGES_H
+#define LIBHEIF_HEIF_AUX_IMAGES_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <libheif/heif_library.h>
+#include <libheif/heif_image.h>
+#include <libheif/heif_error.h>
+
+typedef struct heif_encoder heif_encoder;
+typedef struct heif_encoding_options heif_encoding_options;
+
+
+// ------------------------- depth images -------------------------
+
+LIBHEIF_API
+int heif_image_handle_has_depth_image(const heif_image_handle*);
+
+LIBHEIF_API
+int heif_image_handle_get_number_of_depth_images(const heif_image_handle* handle);
+
+LIBHEIF_API
+int heif_image_handle_get_list_of_depth_image_IDs(const heif_image_handle* handle,
+                                                  heif_item_id* ids, int count);
+
+LIBHEIF_API
+heif_error heif_image_handle_get_depth_image_handle(const heif_image_handle* handle,
+                                                    heif_item_id depth_image_id,
+                                                    heif_image_handle** out_depth_handle);
+
+
+typedef enum heif_depth_representation_type {
+  heif_depth_representation_type_uniform_inverse_Z = 0,
+  heif_depth_representation_type_uniform_disparity = 1,
+  heif_depth_representation_type_uniform_Z = 2,
+  heif_depth_representation_type_nonuniform_disparity = 3
+} heif_depth_representation_type;
+
+typedef struct heif_depth_representation_info {
+  uint8_t version;
+
+  // version 1 fields
+
+  uint8_t has_z_near;
+  uint8_t has_z_far;
+  uint8_t has_d_min;
+  uint8_t has_d_max;
+
+  double z_near;
+  double z_far;
+  double d_min;
+  double d_max;
+
+  enum heif_depth_representation_type depth_representation_type;
+  uint32_t disparity_reference_view;
+
+  uint32_t depth_nonlinear_representation_model_size;
+  uint8_t* depth_nonlinear_representation_model;
+
+  // version 2 fields below
+} heif_depth_representation_info;
+
+
+LIBHEIF_API
+void heif_depth_representation_info_free(const heif_depth_representation_info* info);
+
+// Returns true when there is depth_representation_info available
+// Note 1: depth_image_id is currently unused because we support only one depth channel per image, but
+// you should still provide the correct ID for future compatibility.
+// Note 2: Because of an API bug before v1.11.0, the function also works when 'handle' is the handle of the depth image.
+// However, you should pass the handle of the main image. Please adapt your code if needed.
+LIBHEIF_API
+int heif_image_handle_get_depth_image_representation_info(const heif_image_handle* handle,
+                                                          heif_item_id depth_image_id,
+                                                          const heif_depth_representation_info** out);
+
+
+
+// ------------------------- thumbnails -------------------------
+
+// List the number of thumbnails assigned to this image handle. Usually 0 or 1.
+LIBHEIF_API
+int heif_image_handle_get_number_of_thumbnails(const heif_image_handle* handle);
+
+LIBHEIF_API
+int heif_image_handle_get_list_of_thumbnail_IDs(const heif_image_handle* handle,
+                                                heif_item_id* ids, int count);
+
+// Get the image handle of a thumbnail image.
+LIBHEIF_API
+heif_error heif_image_handle_get_thumbnail(const heif_image_handle* main_image_handle,
+                                           heif_item_id thumbnail_id,
+                                           heif_image_handle** out_thumbnail_handle);
+
+
+// Encode the 'image' as a scaled down thumbnail image.
+// The image is scaled down to fit into a square area of width 'bbox_size'.
+// If the input image is already so small that it fits into this bounding box, no thumbnail
+// image is encoded and NULL is returned in 'out_thumb_image_handle'.
+// No error is returned in this case.
+// The encoded thumbnail is automatically assigned to the 'master_image_handle'. Hence, you
+// do not have to call heif_context_assign_thumbnail().
+LIBHEIF_API
+heif_error heif_context_encode_thumbnail(heif_context*,
+                                         const heif_image* image,
+                                         const heif_image_handle* master_image_handle,
+                                         heif_encoder* encoder,
+                                         const heif_encoding_options* options,
+                                         int bbox_size,
+                                         heif_image_handle** out_thumb_image_handle);
+
+// Assign 'thumbnail_image' as the thumbnail image of 'master_image'.
+LIBHEIF_API
+heif_error heif_context_assign_thumbnail(struct heif_context*,
+                                         const heif_image_handle* master_image,
+                                         const heif_image_handle* thumbnail_image);
+
+
+// ------------------------- auxiliary images -------------------------
+
+#define LIBHEIF_AUX_IMAGE_FILTER_OMIT_ALPHA (1UL<<1)
+#define LIBHEIF_AUX_IMAGE_FILTER_OMIT_DEPTH (2UL<<1)
+
+// List the number of auxiliary images assigned to this image handle.
+LIBHEIF_API
+int heif_image_handle_get_number_of_auxiliary_images(const heif_image_handle* handle,
+                                                     int aux_filter);
+
+LIBHEIF_API
+int heif_image_handle_get_list_of_auxiliary_image_IDs(const heif_image_handle* handle,
+                                                      int aux_filter,
+                                                      heif_item_id* ids, int count);
+
+// You are responsible to deallocate the returned buffer with heif_image_handle_release_auxiliary_type().
+LIBHEIF_API
+heif_error heif_image_handle_get_auxiliary_type(const heif_image_handle* handle,
+                                                const char** out_type);
+
+LIBHEIF_API
+void heif_image_handle_release_auxiliary_type(const heif_image_handle* handle,
+                                              const char** out_type);
+
+// Get the image handle of an auxiliary image.
+LIBHEIF_API
+heif_error heif_image_handle_get_auxiliary_image_handle(const heif_image_handle* main_image_handle,
+                                                        heif_item_id auxiliary_id,
+                                                        heif_image_handle** out_auxiliary_handle);
+
+// ===================== DEPRECATED =====================
+
+// DEPRECATED (because typo in function name). Use heif_image_handle_release_auxiliary_type() instead.
+LIBHEIF_API
+void heif_image_handle_free_auxiliary_types(const heif_image_handle* handle,
+                                            const char** out_type);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/libheif/api/libheif/heif_brands.cc b/libheif/api/libheif/heif_brands.cc
new file mode 100644
index 0000000000..f5d14ed705
--- /dev/null
+++ b/libheif/api/libheif/heif_brands.cc
@@ -0,0 +1,473 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "heif_brands.h"
+#include "heif_error.h"
+#include "error.h"
+#include "common_utils.h"
+#include "bitstream.h"
+#include "box.h"
+
+#include <cstring>
+#include <set>
+#include <memory>
+
+
+
+heif_brand2 heif_read_main_brand(const uint8_t* data, int len)
+{
+  if (len < 12) {
+    return heif_unknown_brand;
+  }
+
+  return heif_fourcc_to_brand((char*) (data + 8));
+}
+
+
+heif_brand2 heif_read_minor_version_brand(const uint8_t* data, int len)
+{
+  if (len < 16) {
+    return heif_unknown_brand;
+  }
+  return heif_fourcc_to_brand((char*) (data + 12));
+}
+
+
+heif_brand2 heif_fourcc_to_brand(const char* fourcc_string)
+{
+  if (fourcc_string == nullptr || !fourcc_string[0] || !fourcc_string[1] || !fourcc_string[2] || !fourcc_string[3]) {
+    return 0;
+  }
+
+  return fourcc(fourcc_string);
+}
+
+void heif_brand_to_fourcc(heif_brand2 brand, char* out_fourcc)
+{
+  if (out_fourcc) {
+    out_fourcc[0] = (char) ((brand >> 24) & 0xFF);
+    out_fourcc[1] = (char) ((brand >> 16) & 0xFF);
+    out_fourcc[2] = (char) ((brand >> 8) & 0xFF);
+    out_fourcc[3] = (char) ((brand >> 0) & 0xFF);
+  }
+}
+
+
+int heif_has_compatible_brand(const uint8_t* data, int len, const char* brand_fourcc)
+{
+  if (data == nullptr || len <= 0 || brand_fourcc == nullptr || !brand_fourcc[0] || !brand_fourcc[1] || !brand_fourcc[2] || !brand_fourcc[3]) {
+    return -1;
+  }
+
+  auto stream = std::make_shared<StreamReader_memory>(data, len, false);
+  BitstreamRange range(stream, len);
+
+  std::shared_ptr<Box> box;
+  Error err = Box::read(range, &box, heif_get_global_security_limits());
+  if (err) {
+    if (err.sub_error_code == heif_suberror_End_of_data) {
+      return -1;
+    }
+
+    return -2;
+  }
+
+  auto ftyp = std::dynamic_pointer_cast<Box_ftyp>(box);
+  if (!ftyp) {
+    return -2;
+  }
+
+  return ftyp->has_compatible_brand(fourcc(brand_fourcc)) ? 1 : 0;
+}
+
+
+heif_error heif_list_compatible_brands(const uint8_t* data, int len, heif_brand2** out_brands, int* out_size)
+{
+  if (data == nullptr || out_brands == nullptr || out_size == nullptr) {
+    return heif_error_null_pointer_argument;
+  }
+
+  if (len <= 0) {
+    return {heif_error_Usage_error, heif_suberror_Invalid_parameter_value, "data length must be positive"};
+  }
+
+  const heif_security_limits* security_limits = heif_get_global_security_limits();
+
+
+  // --- check that file begins with ftyp box
+
+  {
+    auto stream = std::make_shared<StreamReader_memory>(data, len, false);
+    BitstreamRange range(stream, len);
+
+    BoxHeader hdr;
+    Error err = hdr.parse_header(range);
+    if (err) {
+      return {err.error_code, err.sub_error_code, "error reading ftype box header"};
+    }
+
+    if (hdr.get_short_type() != fourcc("ftyp")) {
+      return {
+        heif_error_Invalid_input,
+        heif_suberror_Unspecified,
+        "File does not begin with 'ftyp' box."
+      };
+    }
+  }
+
+  auto stream = std::make_shared<StreamReader_memory>(data, len, false);
+  BitstreamRange range(stream, len);
+
+  std::shared_ptr<Box> box;
+  Error err = Box::read(range, &box, security_limits);
+  if (err) {
+    if (err.sub_error_code == heif_suberror_End_of_data) {
+      return {err.error_code, err.sub_error_code, "insufficient input data"};
+    }
+
+    return {err.error_code, err.sub_error_code, "error reading ftyp box"};
+  }
+
+  auto ftyp = std::dynamic_pointer_cast<Box_ftyp>(box);
+  if (!ftyp) {
+    return {heif_error_Invalid_input, heif_suberror_No_ftyp_box, "input is not a ftyp box"};
+  }
+
+  auto brands = ftyp->list_brands();
+  size_t nBrands = brands.size();
+
+  if (nBrands > security_limits->max_number_of_file_brands) {
+    return {
+      heif_error_Memory_allocation_error,
+      heif_suberror_Security_limit_exceeded,
+      "File contains more brands than allowed by security limits."
+    };
+  }
+
+  *out_brands = (heif_brand2*) malloc(sizeof(heif_brand2) * nBrands);
+  *out_size = (int)nBrands;
+
+  for (size_t i = 0; i < nBrands; i++) {
+    (*out_brands)[i] = brands[i];
+  }
+
+  return heif_error_success;
+}
+
+
+void heif_free_list_of_compatible_brands(heif_brand2* brands_list)
+{
+  if (brands_list) {
+    free(brands_list);
+  }
+}
+
+
+enum class TriBool
+{
+  No, Yes, Unknown
+};
+
+static TriBool is_jpeg(const uint8_t* data, int len)
+{
+  if (len < 12) {
+    return TriBool::Unknown;
+  }
+
+  if (data[0] == 0xFF && data[1] == 0xD8 && data[2] == 0xFF && data[3] == 0xE0 &&
+      data[4] == 0x00 && data[5] == 0x10 && data[6] == 0x4A && data[7] == 0x46 &&
+      data[8] == 0x49 && data[9] == 0x46 && data[10] == 0x00 && data[11] == 0x01) {
+    return TriBool::Yes;
+  }
+  if (data[0] == 0xFF && data[1] == 0xD8 && data[2] == 0xFF && data[3] == 0xE1 &&
+      data[6] == 0x45 && data[7] == 0x78 && data[8] == 0x69 && data[9] == 0x66 &&
+      data[10] == 0x00 && data[11] == 0x00) {
+    return TriBool::Yes;
+  }
+  else {
+    return TriBool::No;
+  }
+}
+
+
+static TriBool is_png(const uint8_t* data, int len)
+{
+  if (len < 8) {
+    return TriBool::Unknown;
+  }
+
+  if (data[0] == 0x89 && data[1] == 0x50 && data[2] == 0x4E && data[3] == 0x47 &&
+      data[4] == 0x0D && data[5] == 0x0A && data[6] == 0x1A && data[7] == 0x0A) {
+    return TriBool::Yes;
+  }
+  else {
+    return TriBool::No;
+  }
+}
+
+
+const char* heif_get_file_mime_type(const uint8_t* data, int len)
+{
+  heif_brand2 mainBrand = heif_read_main_brand(data, len);
+
+  if (mainBrand == heif_brand2_heic ||
+      mainBrand == heif_brand2_heix ||
+      mainBrand == heif_brand2_heim ||
+      mainBrand == heif_brand2_heis) {
+    return "image/heic";
+  }
+  else if (mainBrand == heif_brand2_mif1) {
+    return "image/heif";
+  }
+  else if (mainBrand == heif_brand2_hevc ||
+           mainBrand == heif_brand2_hevx ||
+           mainBrand == heif_brand2_hevm ||
+           mainBrand == heif_brand2_hevs) {
+    return "image/heic-sequence";
+  }
+  else if (mainBrand == heif_brand2_msf1) {
+    return "image/heif-sequence";
+  }
+  else if (mainBrand == heif_brand2_avif) {
+    return "image/avif";
+  }
+  else if (mainBrand == heif_brand2_avis) {
+    return "image/avif-sequence";
+  }
+  else if (mainBrand == heif_brand2_avci) {
+    return "image/avci";
+  }
+  else if (mainBrand == heif_brand2_avcs) {
+    return "image/avcs";
+  }
+#if ENABLE_EXPERIMENTAL_MINI_FORMAT
+  else if (mainBrand == heif_brand2_mif3) {
+    heif_brand2 minorBrand = heif_read_minor_version_brand(data, len);
+    if (minorBrand == heif_brand2_avif) {
+      return "image/avif";
+    }
+    if (minorBrand == heif_brand2_heic ||
+        minorBrand == heif_brand2_heix ||
+        minorBrand == heif_brand2_heim ||
+        minorBrand == heif_brand2_heis) {
+      return "image/heic";
+    }
+    // There could be other options in here, like VVC or J2K
+    return "image/heif";
+  }
+#endif
+  else if (mainBrand == heif_brand2_j2ki) {
+    return "image/hej2k";
+  }
+  else if (mainBrand == heif_brand2_j2is) {
+    return "image/j2is";
+  }
+  else if (is_jpeg(data, len) == TriBool::Yes) {
+    return "image/jpeg";
+  }
+  else if (is_png(data, len) == TriBool::Yes) {
+    return "image/png";
+  }
+  else {
+    return "";
+  }
+}
+
+heif_filetype_result heif_check_filetype(const uint8_t* data, int len)
+{
+  if (len < 8) {
+    return heif_filetype_maybe;
+  }
+
+  if (data[4] != 'f' ||
+      data[5] != 't' ||
+      data[6] != 'y' ||
+      data[7] != 'p') {
+    return heif_filetype_no;
+  }
+
+  if (len >= 12) {
+    heif_brand2 brand = heif_read_main_brand(data, len);
+
+    if (brand == heif_brand2_heic) {
+      return heif_filetype_yes_supported;
+    }
+    else if (brand == heif_brand2_heix) {
+      return heif_filetype_yes_supported;
+    }
+    else if (brand == heif_brand2_avif) {
+      return heif_filetype_yes_supported;
+    }
+    else if (brand == heif_brand2_jpeg) {
+      return heif_filetype_yes_supported;
+    }
+    else if (brand == heif_brand2_j2ki) {
+      return heif_filetype_yes_supported;
+    }
+    else if (brand == heif_brand2_mif1) {
+      return heif_filetype_maybe;
+    }
+    else if (brand == heif_brand2_mif2) {
+      return heif_filetype_maybe;
+    }
+    else {
+      return heif_filetype_yes_unsupported;
+    }
+  }
+
+  return heif_filetype_maybe;
+}
+
+
+heif_error heif_has_compatible_filetype(const uint8_t* data, int len)
+{
+  // Get compatible brands first, because that does validity checks
+  heif_brand2* compatible_brands = nullptr;
+  int nBrands = 0;
+  struct heif_error err = heif_list_compatible_brands(data, len, &compatible_brands, &nBrands);
+  if (err.code) {
+    assert(compatible_brands == nullptr); // NOLINT(clang-analyzer-unix.Malloc)
+    return err;
+  }
+
+  heif_brand2 main_brand = heif_read_main_brand(data, len);
+
+  std::set<heif_brand2> supported_brands{
+      heif_brand2_avif,
+      heif_brand2_heic,
+      heif_brand2_heix,
+      heif_brand2_j2ki,
+      heif_brand2_jpeg,
+      heif_brand2_miaf,
+      heif_brand2_mif1,
+      heif_brand2_mif2
+#if ENABLE_EXPERIMENTAL_MINI_FORMAT
+      , heif_brand2_mif3
+#endif
+      ,heif_brand2_msf1,
+    heif_brand2_isom,
+    heif_brand2_mp41,
+    heif_brand2_mp42
+  };
+
+  auto it = supported_brands.find(main_brand);
+  if (it != supported_brands.end()) {
+    heif_free_list_of_compatible_brands(compatible_brands);
+    return heif_error_success;
+  }
+
+  for (int i = 0; i < nBrands; i++) {
+    heif_brand2 compatible_brand = compatible_brands[i];
+    it = supported_brands.find(compatible_brand);
+    if (it != supported_brands.end()) {
+      heif_free_list_of_compatible_brands(compatible_brands);
+      return heif_error_success;
+    }
+  }
+  heif_free_list_of_compatible_brands(compatible_brands);
+  return {heif_error_Invalid_input, heif_suberror_Unsupported_image_type, "No supported brands found."};;
+}
+
+
+int heif_check_jpeg_filetype(const uint8_t* data, int len)
+{
+  if (len < 4 || data == nullptr) {
+    return -1;
+  }
+
+  return (data[0] == 0xFF &&
+	  data[1] == 0xD8 &&
+	  data[2] == 0xFF &&
+	  (data[3] & 0xF0) == 0xE0);
+}
+
+
+static heif_brand heif_fourcc_to_brand_enum(const char* fourcc)
+{
+  if (fourcc == nullptr || !fourcc[0] || !fourcc[1] || !fourcc[2] || !fourcc[3]) {
+    return heif_unknown_brand;
+  }
+
+  char brand[5];
+  brand[0] = fourcc[0];
+  brand[1] = fourcc[1];
+  brand[2] = fourcc[2];
+  brand[3] = fourcc[3];
+  brand[4] = 0;
+
+  if (strcmp(brand, "heic") == 0) {
+    return heif_heic;
+  }
+  else if (strcmp(brand, "heix") == 0) {
+    return heif_heix;
+  }
+  else if (strcmp(brand, "hevc") == 0) {
+    return heif_hevc;
+  }
+  else if (strcmp(brand, "hevx") == 0) {
+    return heif_hevx;
+  }
+  else if (strcmp(brand, "heim") == 0) {
+    return heif_heim;
+  }
+  else if (strcmp(brand, "heis") == 0) {
+    return heif_heis;
+  }
+  else if (strcmp(brand, "hevm") == 0) {
+    return heif_hevm;
+  }
+  else if (strcmp(brand, "hevs") == 0) {
+    return heif_hevs;
+  }
+  else if (strcmp(brand, "mif1") == 0) {
+    return heif_mif1;
+  }
+  else if (strcmp(brand, "msf1") == 0) {
+    return heif_msf1;
+  }
+  else if (strcmp(brand, "avif") == 0) {
+    return heif_avif;
+  }
+  else if (strcmp(brand, "avis") == 0) {
+    return heif_avis;
+  }
+  else if (strcmp(brand, "vvic") == 0) {
+    return heif_vvic;
+  }
+  else if (strcmp(brand, "j2ki") == 0) {
+    return heif_j2ki;
+  }
+  else if (strcmp(brand, "j2is") == 0) {
+    return heif_j2is;
+  }
+  else {
+    return heif_unknown_brand;
+  }
+}
+
+
+enum heif_brand heif_main_brand(const uint8_t* data, int len)
+{
+  if (len < 12) {
+    return heif_unknown_brand;
+  }
+
+  return heif_fourcc_to_brand_enum((char*) (data + 8));
+}
diff --git a/libheif/api/libheif/heif_brands.h b/libheif/api/libheif/heif_brands.h
new file mode 100644
index 0000000000..68cd89f9ba
--- /dev/null
+++ b/libheif/api/libheif/heif_brands.h
@@ -0,0 +1,385 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017-2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_HEIF_BRANDS_H
+#define LIBHEIF_HEIF_BRANDS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <libheif/heif_library.h>
+
+
+
+typedef uint32_t heif_brand2;
+
+/**
+ * HEVC image (`heic`) brand.
+ *
+ * Image conforms to HEVC (H.265) Main or Main Still profile.
+ *
+ * See ISO/IEC 23008-12:2022 Section B.4.1.
+ */
+#define heif_brand2_heic   heif_fourcc('h','e','i','c')
+
+/**
+ * HEVC image (`heix`) brand.
+ *
+ * Image conforms to HEVC (H.265) Main 10 profile.
+ *
+ * See ISO/IEC 23008-12:2022 Section B.4.1.
+ */
+#define heif_brand2_heix   heif_fourcc('h','e','i','x')
+
+/**
+ * HEVC image sequence (`hevc`) brand.
+ *
+ * Image sequence conforms to HEVC (H.265) Main profile.
+ *
+ * See ISO/IEC 23008-12:2022 Section B.4.2.
+ */
+#define heif_brand2_hevc   heif_fourcc('h','e','v','c')
+
+/**
+ * HEVC image sequence (`hevx`) brand.
+ *
+ * Image sequence conforms to HEVC (H.265) Main 10 profile.
+ *
+ * See ISO/IEC 23008-12:2022 Section B.4.2.
+ */
+#define heif_brand2_hevx   heif_fourcc('h','e','v','x')
+
+/**
+ * HEVC layered image (`heim`) brand.
+ *
+ * Image layers conform to HEVC (H.265) Main or Multiview Main profile.
+ *
+ * See ISO/IEC 23008-12:2022 Section B.4.3.
+ */
+#define heif_brand2_heim   heif_fourcc('h','e','i','m')
+
+/**
+ * HEVC layered image (`heis`) brand.
+ *
+ * Image layers conform to HEVC (H.265) Main, Main 10, Scalable Main
+ * or Scalable Main 10 profile.
+ *
+ * See ISO/IEC 23008-12:2022 Section B.4.3.
+ */
+#define heif_brand2_heis   heif_fourcc('h','e','i','s')
+
+/**
+ * HEVC layered image sequence (`hevm`) brand.
+ *
+ * Image sequence layers conform to HEVC (H.265) Main or Multiview Main profile.
+ *
+ * See ISO/IEC 23008-12:2022 Section B.4.4.
+ */
+#define heif_brand2_hevm   heif_fourcc('h','e','v','m')
+
+/**
+ * HEVC layered image sequence (`hevs`) brand.
+ *
+ * Image sequence layers conform to HEVC (H.265) Main, Main 10, Scalable Main
+ * or Scalable Main 10 profile.
+ *
+ * See ISO/IEC 23008-12:2022 Section B.4.4.
+ */
+#define heif_brand2_hevs   heif_fourcc('h','e','v','s')
+
+/**
+ * AV1 image (`avif`) brand.
+ *
+ * See https://aomediacodec.github.io/av1-avif/#image-and-image-collection-brand
+ */
+#define heif_brand2_avif   heif_fourcc('a','v','i','f')
+
+/**
+ * AV1 image sequence (`avis`) brand.
+ *
+ * See https://aomediacodec.github.io/av1-avif/#image-sequence-brand
+ */
+#define heif_brand2_avis   heif_fourcc('a','v','i','s') // AVIF sequence
+
+/**
+ * HEIF image structural brand (`mif1`).
+ *
+ * This does not imply a specific coding algorithm.
+ *
+ * See ISO/IEC 23008-12:2022 Section 10.2.2.
+ */
+#define heif_brand2_mif1   heif_fourcc('m','i','f','1')
+
+/**
+ * HEIF image structural brand (`mif2`).
+ *
+ * This does not imply a specific coding algorithm. `mif2` extends
+ * the requirements of `mif1` to include the `rref` and `iscl` item
+ * properties.
+ *
+ * See ISO/IEC 23008-12:2022 Section 10.2.3.
+ */
+#define heif_brand2_mif2   heif_fourcc('m','i','f','2')
+
+/**
+ * HEIF image structural brand (`mif3`).
+ *
+ * This indicates the low-overhead (ftyp+mini) structure.
+ */
+#define heif_brand2_mif3   heif_fourcc('m','i','f','3')
+
+/**
+ * HEIF image sequence structural brand (`msf1`).
+ *
+ * This does not imply a specific coding algorithm.
+ *
+ * See ISO/IEC 23008-12:2022 Section 10.3.1.
+ */
+#define heif_brand2_msf1   heif_fourcc('m','s','f','1')
+
+/**
+ * VVC image (`vvic`) brand.
+ *
+ * See ISO/IEC 23008-12:2022 Section L.4.1.
+ */
+#define heif_brand2_vvic   heif_fourcc('v','v','i','c')
+
+/**
+ * VVC image sequence (`vvis`) brand.
+ *
+ * See ISO/IEC 23008-12:2022 Section L.4.2.
+ */
+#define heif_brand2_vvis   heif_fourcc('v','v','i','s')
+
+/**
+ * EVC baseline image (`evbi`) brand.
+ *
+ * See ISO/IEC 23008-12:2022 Section M.4.1.
+ */
+#define heif_brand2_evbi   heif_fourcc('e','v','b','i')
+
+/**
+ * EVC main profile image (`evmi`) brand.
+ *
+ * See ISO/IEC 23008-12:2022 Section M.4.2.
+ */
+#define heif_brand2_evmi   heif_fourcc('e','v','m','i')
+
+/**
+ * EVC baseline image sequence (`evbs`) brand.
+ *
+ * See ISO/IEC 23008-12:2022 Section M.4.3.
+ */
+#define heif_brand2_evbs   heif_fourcc('e','v','b','s')
+
+/**
+ * EVC main profile image sequence (`evms`) brand.
+ *
+ * See ISO/IEC 23008-12:2022 Section M.4.4.
+ */
+#define heif_brand2_evms   heif_fourcc('e','v','m','s')
+
+/**
+ * JPEG image (`jpeg`) brand.
+ *
+ * See ISO/IEC 23008-12:2022 Annex H.4
+ */
+#define heif_brand2_jpeg   heif_fourcc('j','p','e','g')
+
+/**
+ * JPEG image sequence (`jpgs`) brand.
+ *
+ * See ISO/IEC 23008-12:2022 Annex H.5
+ */
+#define heif_brand2_jpgs   heif_fourcc('j','p','g','s')
+
+/**
+ * JPEG 2000 image (`j2ki`) brand.
+ *
+ * See ISO/IEC 15444-16:2021 Section 6.5 
+ */
+#define heif_brand2_j2ki   heif_fourcc('j','2','k','i')
+
+/**
+ * JPEG 2000 image sequence (`j2is`) brand.
+ *
+ * See ISO/IEC 15444-16:2021 Section 7.6
+ */
+#define heif_brand2_j2is   heif_fourcc('j','2','i','s')
+
+/**
+ * Multi-image application format (MIAF) brand.
+ *
+ * This is HEIF with additional constraints for interoperability.
+ *
+ * See ISO/IEC 23000-22.
+ */
+#define heif_brand2_miaf   heif_fourcc('m','i','a','f')
+
+/**
+ * Single picture file brand.
+ *
+ * This is a compatible brand indicating the file contains a single intra-coded picture.
+ *
+ * See ISO/IEC 23008-12:2022 Section 10.2.5.
+*/
+#define heif_brand2_1pic   heif_fourcc('1','p','i','c')
+
+// H.264
+#define heif_brand2_avci   heif_fourcc('a','v','c','i')
+#define heif_brand2_avcs   heif_fourcc('a','v','c','s')
+
+/**
+ * Unified ID namespace (`unif`) brand.
+ *
+ * All IDs (item, track, entity group) share a single global namespace.
+ *
+ * See ISO/IEC 14496-12.
+ */
+#define heif_brand2_unif   heif_fourcc('u','n','i','f')
+
+#define heif_brand2_iso8   heif_fourcc('i','s','o','8')
+#define heif_brand2_isom   heif_fourcc('i','s','o','m')
+#define heif_brand2_mp41   heif_fourcc('m','p','4','1')
+#define heif_brand2_mp42   heif_fourcc('m','p','4','2')
+
+// input data should be at least 12 bytes
+LIBHEIF_API
+heif_brand2 heif_read_main_brand(const uint8_t* data, int len);
+
+// input data should be at least 16 bytes
+LIBHEIF_API
+heif_brand2 heif_read_minor_version_brand(const uint8_t* data, int len);
+
+// 'brand_fourcc' must be 4 character long, but need not be 0-terminated
+LIBHEIF_API
+heif_brand2 heif_fourcc_to_brand(const char* brand_fourcc);
+
+// the output buffer must be at least 4 bytes long
+LIBHEIF_API
+void heif_brand_to_fourcc(heif_brand2 brand, char* out_fourcc);
+
+// 'brand_fourcc' must be 4 character long, but need not be 0-terminated
+// returns 1 if file includes the brand, and 0 if it does not
+// returns -1 if the provided data is not sufficient
+//            (you should input at least as many bytes as indicated in the first 4 bytes of the file, usually ~50 bytes will do)
+// returns -2 on other errors
+LIBHEIF_API
+int heif_has_compatible_brand(const uint8_t* data, int len, const char* brand_fourcc);
+
+// Returns an array of compatible brands. The array is allocated by this function and has to be freed with 'heif_free_list_of_compatible_brands()'.
+// The number of entries is returned in out_size.
+LIBHEIF_API
+struct heif_error heif_list_compatible_brands(const uint8_t* data, int len, heif_brand2** out_brands, int* out_size);
+
+LIBHEIF_API
+void heif_free_list_of_compatible_brands(heif_brand2* brands_list);
+
+
+
+// Returns one of these MIME types:
+// - image/heic           HEIF file using h265 compression
+// - image/heif           HEIF file using any other compression
+// - image/heic-sequence  HEIF image sequence using h265 compression
+// - image/heif-sequence  HEIF image sequence using any other compression
+// - image/avif           AVIF image
+// - image/avif-sequence  AVIF sequence
+// - image/jpeg    JPEG image
+// - image/png     PNG image
+// If the format could not be detected, an empty string is returned.
+//
+// Provide at least 12 bytes of input. With less input, its format might not
+// be detected. You may also provide more input to increase detection accuracy.
+//
+// Note that JPEG and PNG images cannot be decoded by libheif even though the
+// formats are detected by this function.
+LIBHEIF_API
+const char* heif_get_file_mime_type(const uint8_t* data, int len);
+
+
+// ========================= file type check ======================
+
+typedef enum heif_filetype_result
+{
+  heif_filetype_no,
+  heif_filetype_yes_supported,   // it is heif and can be read by libheif
+  heif_filetype_yes_unsupported, // it is heif, but cannot be read by libheif
+  heif_filetype_maybe // not sure whether it is an heif, try detection with more input data
+} heif_filetype_result;
+
+// input data should be at least 12 bytes
+LIBHEIF_API
+enum heif_filetype_result heif_check_filetype(const uint8_t* data, int len);
+
+/**
+ * Check the filetype box content for a supported file type.
+ *
+ * <p>The data is assumed to start from the start of the `ftyp` box.
+ *
+ * <p>This function checks the compatible brands.
+ *
+ * @returns heif_error_ok if a supported brand is found, or other error if not.
+ */
+LIBHEIF_API
+heif_error heif_has_compatible_filetype(const uint8_t* data, int len);
+
+LIBHEIF_API
+int heif_check_jpeg_filetype(const uint8_t* data, int len);
+
+
+// ===================== DEPRECATED =====================
+
+// DEPRECATED, use heif_brand2 and the heif_brand2_* constants instead
+typedef enum heif_brand
+{
+  heif_unknown_brand,
+  heif_heic, // HEIF image with h265
+  heif_heix, // 10bit images, or anything that uses h265 with range extension
+  heif_hevc, heif_hevx, // brands for image sequences
+  heif_heim, // multiview
+  heif_heis, // scalable
+  heif_hevm, // multiview sequence
+  heif_hevs, // scalable sequence
+  heif_mif1, // image, any coding algorithm
+  heif_msf1, // sequence, any coding algorithm
+  heif_avif, // HEIF image with AV1
+  heif_avis,
+  heif_vvic, // VVC image
+  heif_vvis, // VVC sequence
+  heif_evbi, // EVC image
+  heif_evbs, // EVC sequence
+  heif_j2ki, // JPEG2000 image
+  heif_j2is, // JPEG2000 image sequence
+} heif_brand;
+
+// input data should be at least 12 bytes
+// DEPRECATED, use heif_read_main_brand() instead
+LIBHEIF_API
+enum heif_brand heif_main_brand(const uint8_t* data, int len);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/libheif/api/libheif/heif_color.cc b/libheif/api/libheif/heif_color.cc
new file mode 100644
index 0000000000..2cf7e10175
--- /dev/null
+++ b/libheif/api/libheif/heif_color.cc
@@ -0,0 +1,573 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <libheif/heif_color.h>
+
+#include "common_utils.h"
+#include <cstdint>
+#include "heif.h"
+#include "pixelimage.h"
+#include "api_structs.h"
+#include "error.h"
+#include <set>
+#include <limits>
+
+#include <algorithm>
+#include <iostream>
+#include <fstream>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+#include <cstring>
+#include <array>
+
+
+void heif_color_conversion_options_set_defaults(heif_color_conversion_options* options)
+{
+  options->version = 1;
+#if HAVE_LIBSHARPYUV
+  options->preferred_chroma_downsampling_algorithm = heif_chroma_downsampling_sharp_yuv;
+#else
+  options->preferred_chroma_downsampling_algorithm = heif_chroma_downsampling_average;
+#endif
+
+  options->preferred_chroma_upsampling_algorithm = heif_chroma_upsampling_bilinear;
+  options->only_use_preferred_chroma_algorithm = true;
+}
+
+
+static void fill_default_color_conversion_options_ext(heif_color_conversion_options_ext& options)
+{
+  options.version = 1;
+  options.alpha_composition_mode = heif_alpha_composition_mode_none;
+  options.background_red = options.background_green = options.background_blue = 0xFFFF;
+  options.secondary_background_red = options.secondary_background_green = options.secondary_background_blue = 0xCCCC;
+  options.checkerboard_square_size = 16;
+}
+
+
+heif_color_conversion_options_ext* heif_color_conversion_options_ext_alloc()
+{
+  auto options = new heif_color_conversion_options_ext;
+
+  fill_default_color_conversion_options_ext(*options);
+
+  return options;
+}
+
+
+void heif_color_conversion_options_ext_copy(heif_color_conversion_options_ext* dst,
+                                            const heif_color_conversion_options_ext* src)
+{
+  if (src == nullptr) {
+    return;
+  }
+
+  int min_version = std::min(dst->version, src->version);
+
+  switch (min_version) {
+    case 1:
+      dst->alpha_composition_mode = src->alpha_composition_mode;
+      dst->background_red = src->background_red;
+      dst->background_green = src->background_green;
+      dst->background_blue = src->background_blue;
+      dst->secondary_background_red = src->secondary_background_red;
+      dst->secondary_background_green = src->secondary_background_green;
+      dst->secondary_background_blue = src->secondary_background_blue;
+      dst->checkerboard_square_size = src->checkerboard_square_size;
+  }
+}
+
+
+void heif_color_conversion_options_ext_free(heif_color_conversion_options_ext* options)
+{
+  delete options;
+}
+
+
+heif_color_profile_type heif_image_handle_get_color_profile_type(const heif_image_handle* handle)
+{
+  auto profile_icc = handle->image->get_color_profile_icc();
+  if (profile_icc) {
+    return (heif_color_profile_type) profile_icc->get_type();
+  }
+
+  if (handle->image->has_nclx_color_profile()) {
+    return heif_color_profile_type_nclx;
+  }
+
+  return heif_color_profile_type_not_present;
+}
+
+
+size_t heif_image_handle_get_raw_color_profile_size(const heif_image_handle* handle)
+{
+  auto profile_icc = handle->image->get_color_profile_icc();
+  if (profile_icc) {
+    return profile_icc->get_data().size();
+  }
+  else {
+    return 0;
+  }
+}
+
+
+heif_error heif_image_handle_get_raw_color_profile(const heif_image_handle* handle,
+                                                   void* out_data)
+{
+  if (out_data == nullptr) {
+    return heif_error_null_pointer_argument;
+  }
+
+  auto raw_profile = handle->image->get_color_profile_icc();
+  if (raw_profile) {
+    memcpy(out_data,
+           raw_profile->get_data().data(),
+           raw_profile->get_data().size());
+  }
+  else {
+    Error err(heif_error_Color_profile_does_not_exist,
+              heif_suberror_Unspecified);
+    return err.error_struct(handle->image.get());
+  }
+
+  return Error::Ok.error_struct(handle->image.get());
+}
+
+
+static const std::set<std::underlying_type<heif_color_primaries>::type> known_color_primaries{
+  heif_color_primaries_ITU_R_BT_709_5,
+  heif_color_primaries_unspecified,
+  heif_color_primaries_ITU_R_BT_470_6_System_M,
+  heif_color_primaries_ITU_R_BT_470_6_System_B_G,
+  heif_color_primaries_ITU_R_BT_601_6,
+  heif_color_primaries_SMPTE_240M,
+  heif_color_primaries_generic_film,
+  heif_color_primaries_ITU_R_BT_2020_2_and_2100_0,
+  heif_color_primaries_SMPTE_ST_428_1,
+  heif_color_primaries_SMPTE_RP_431_2,
+  heif_color_primaries_SMPTE_EG_432_1,
+  heif_color_primaries_EBU_Tech_3213_E,
+};
+
+
+heif_error heif_nclx_color_profile_set_color_primaries(heif_color_profile_nclx* nclx, uint16_t cp)
+{
+  if (static_cast<std::underlying_type<heif_color_primaries>::type>(cp) > std::numeric_limits<std::underlying_type<heif_color_primaries>::type>::max()) {
+    return Error(heif_error_Invalid_input, heif_suberror_Unknown_NCLX_color_primaries).error_struct(nullptr);
+  }
+
+  auto n = static_cast<std::underlying_type<heif_color_primaries>::type>(cp);
+  if (known_color_primaries.find(n) != known_color_primaries.end()) {
+    nclx->color_primaries = static_cast<heif_color_primaries>(n);
+  }
+  else {
+    nclx->color_primaries = heif_color_primaries_unspecified;
+    return Error(heif_error_Invalid_input, heif_suberror_Unknown_NCLX_color_primaries).error_struct(nullptr);
+  }
+
+  return Error::Ok.error_struct(nullptr);
+}
+
+
+static const std::set<std::underlying_type<heif_transfer_characteristics>::type> known_transfer_characteristics{
+  heif_transfer_characteristic_ITU_R_BT_709_5,
+  heif_transfer_characteristic_unspecified,
+  heif_transfer_characteristic_ITU_R_BT_470_6_System_M,
+  heif_transfer_characteristic_ITU_R_BT_470_6_System_B_G,
+  heif_transfer_characteristic_ITU_R_BT_601_6,
+  heif_transfer_characteristic_SMPTE_240M,
+  heif_transfer_characteristic_linear,
+  heif_transfer_characteristic_logarithmic_100,
+  heif_transfer_characteristic_logarithmic_100_sqrt10,
+  heif_transfer_characteristic_IEC_61966_2_4,
+  heif_transfer_characteristic_ITU_R_BT_1361,
+  heif_transfer_characteristic_IEC_61966_2_1,
+  heif_transfer_characteristic_ITU_R_BT_2020_2_10bit,
+  heif_transfer_characteristic_ITU_R_BT_2020_2_12bit,
+  heif_transfer_characteristic_ITU_R_BT_2100_0_PQ,
+  heif_transfer_characteristic_SMPTE_ST_428_1,
+  heif_transfer_characteristic_ITU_R_BT_2100_0_HLG
+};
+
+
+heif_error heif_nclx_color_profile_set_transfer_characteristics(heif_color_profile_nclx* nclx, uint16_t tc)
+{
+  if (static_cast<std::underlying_type<heif_color_primaries>::type>(tc) > std::numeric_limits<std::underlying_type<heif_transfer_characteristics>::type>::max()) {
+    return Error(heif_error_Invalid_input, heif_suberror_Unknown_NCLX_transfer_characteristics).error_struct(nullptr);
+  }
+
+  auto n = static_cast<std::underlying_type<heif_transfer_characteristics>::type>(tc);
+  if (known_transfer_characteristics.find(n) != known_transfer_characteristics.end()) {
+    nclx->transfer_characteristics = static_cast<heif_transfer_characteristics>(n);
+  }
+  else {
+    nclx->transfer_characteristics = heif_transfer_characteristic_unspecified;
+    return Error(heif_error_Invalid_input, heif_suberror_Unknown_NCLX_transfer_characteristics).error_struct(nullptr);
+  }
+
+  return Error::Ok.error_struct(nullptr);
+}
+
+
+static const std::set<std::underlying_type<heif_matrix_coefficients>::type> known_matrix_coefficients{
+  heif_matrix_coefficients_RGB_GBR,
+  heif_matrix_coefficients_ITU_R_BT_709_5,
+  heif_matrix_coefficients_unspecified,
+  heif_matrix_coefficients_US_FCC_T47,
+  heif_matrix_coefficients_ITU_R_BT_470_6_System_B_G,
+  heif_matrix_coefficients_ITU_R_BT_601_6,
+  heif_matrix_coefficients_SMPTE_240M,
+  heif_matrix_coefficients_YCgCo,
+  heif_matrix_coefficients_ITU_R_BT_2020_2_non_constant_luminance,
+  heif_matrix_coefficients_ITU_R_BT_2020_2_constant_luminance,
+  heif_matrix_coefficients_SMPTE_ST_2085,
+  heif_matrix_coefficients_chromaticity_derived_non_constant_luminance,
+  heif_matrix_coefficients_chromaticity_derived_constant_luminance,
+  heif_matrix_coefficients_ICtCp
+};
+
+
+heif_error heif_nclx_color_profile_set_matrix_coefficients(heif_color_profile_nclx* nclx, uint16_t mc)
+{
+  if (static_cast<std::underlying_type<heif_color_primaries>::type>(mc) > std::numeric_limits<std::underlying_type<heif_matrix_coefficients>::type>::max()) {
+    return Error(heif_error_Invalid_input, heif_suberror_Unknown_NCLX_matrix_coefficients).error_struct(nullptr);
+  }
+
+  auto n = static_cast<std::underlying_type<heif_matrix_coefficients>::type>(mc);
+  if (known_matrix_coefficients.find(n) != known_matrix_coefficients.end()) {
+    nclx->matrix_coefficients = static_cast<heif_matrix_coefficients>(n);;
+  }
+  else {
+    nclx->matrix_coefficients = heif_matrix_coefficients_unspecified;
+    return Error(heif_error_Invalid_input, heif_suberror_Unknown_NCLX_matrix_coefficients).error_struct(nullptr);
+  }
+
+  return Error::Ok.error_struct(nullptr);
+}
+
+
+heif_error heif_image_handle_get_nclx_color_profile(const heif_image_handle* handle,
+                                                    heif_color_profile_nclx** out_data)
+{
+  if (!out_data) {
+    return heif_error_null_pointer_argument;
+  }
+
+  if (!handle->image->has_nclx_color_profile()) {
+    Error err(heif_error_Color_profile_does_not_exist,
+              heif_suberror_Unspecified);
+    return err.error_struct(handle->image.get());
+  }
+
+  auto nclx_profile = handle->image->get_color_profile_nclx();
+  Error err = nclx_profile.get_nclx_color_profile(out_data);
+
+  return err.error_struct(handle->image.get());
+}
+
+
+heif_color_profile_nclx* heif_nclx_color_profile_alloc()
+{
+  auto profile = new heif_color_profile_nclx;
+
+  if (profile) {
+    profile->version = 1;
+
+    // sRGB defaults
+    profile->color_primaries = heif_color_primaries_ITU_R_BT_709_5; // 1
+    profile->transfer_characteristics = heif_transfer_characteristic_IEC_61966_2_1; // 13
+    profile->matrix_coefficients = heif_matrix_coefficients_ITU_R_BT_601_6; // 6
+    profile->full_range_flag = true;
+  }
+
+  return profile;
+}
+
+
+void heif_nclx_color_profile_free(heif_color_profile_nclx* nclx_profile)
+{
+  delete nclx_profile;
+}
+
+
+heif_color_profile_type heif_image_get_color_profile_type(const heif_image* image)
+{
+  std::shared_ptr<const color_profile> profile;
+
+  profile = image->image->get_color_profile_icc();
+  if (profile) {
+    return (heif_color_profile_type) profile->get_type();
+  }
+
+  if (image->image->has_nclx_color_profile()) {
+    return heif_color_profile_type_nclx;
+  }
+
+  return heif_color_profile_type_not_present;
+}
+
+
+size_t heif_image_get_raw_color_profile_size(const heif_image* image)
+{
+  auto raw_profile = image->image->get_color_profile_icc();
+  if (raw_profile) {
+    return raw_profile->get_data().size();
+  }
+  else {
+    return 0;
+  }
+}
+
+
+heif_error heif_image_get_raw_color_profile(const heif_image* image,
+                                            void* out_data)
+{
+  if (out_data == nullptr) {
+    return heif_error_null_pointer_argument;
+  }
+
+  auto raw_profile = image->image->get_color_profile_icc();
+  if (raw_profile) {
+    memcpy(out_data,
+           raw_profile->get_data().data(),
+           raw_profile->get_data().size());
+  }
+  else {
+    Error err(heif_error_Color_profile_does_not_exist,
+              heif_suberror_Unspecified);
+    return err.error_struct(image->image.get());
+  }
+
+  return Error::Ok.error_struct(image->image.get());
+}
+
+
+heif_error heif_image_get_nclx_color_profile(const heif_image* image,
+                                             heif_color_profile_nclx** out_data)
+{
+  if (!out_data) {
+    return heif_error_null_pointer_argument;
+  }
+
+  if (!image->image->has_nclx_color_profile()) {
+    Error err(heif_error_Color_profile_does_not_exist,
+              heif_suberror_Unspecified);
+    return err.error_struct(image->image.get());
+  }
+
+  auto nclx_profile = image->image->get_color_profile_nclx();
+  Error err = nclx_profile.get_nclx_color_profile(out_data);
+
+  return err.error_struct(image->image.get());
+}
+
+
+heif_error heif_image_set_raw_color_profile(heif_image* image,
+                                            const char* color_profile_type_fourcc,
+                                            const void* profile_data,
+                                            const size_t profile_size)
+{
+  if (strlen(color_profile_type_fourcc) != 4) {
+    heif_error err = {
+      heif_error_Usage_error,
+      heif_suberror_Unspecified,
+      "Invalid color_profile_type (must be 4 characters)"
+    };
+    return err;
+  }
+
+  uint32_t color_profile_type = fourcc(color_profile_type_fourcc);
+
+  std::vector<uint8_t> data;
+  data.insert(data.end(),
+              (const uint8_t*) profile_data,
+              (const uint8_t*) profile_data + profile_size);
+
+  auto color_profile = std::make_shared<color_profile_raw>(color_profile_type, data);
+
+  image->image->set_color_profile_icc(color_profile);
+
+  return heif_error_success;
+}
+
+
+heif_error heif_image_set_nclx_color_profile(heif_image* image,
+                                             const heif_color_profile_nclx* color_profile)
+{
+  nclx_profile nclx;
+  nclx.set_colour_primaries(color_profile->color_primaries);
+  nclx.set_transfer_characteristics(color_profile->transfer_characteristics);
+  nclx.set_matrix_coefficients(color_profile->matrix_coefficients);
+  nclx.set_full_range_flag(color_profile->full_range_flag);
+
+  image->image->set_color_profile_nclx(nclx);
+
+  return heif_error_success;
+}
+
+
+// --- content light level ---
+
+int heif_image_has_content_light_level(const heif_image* image)
+{
+  return image->image->has_clli();
+}
+
+
+void heif_image_get_content_light_level(const heif_image* image, heif_content_light_level* out)
+{
+  if (out) {
+    *out = image->image->get_clli();
+  }
+}
+
+
+int heif_image_handle_get_content_light_level(const heif_image_handle* handle, heif_content_light_level* out)
+{
+  auto clli = handle->image->get_property<Box_clli>();
+  if (out && clli) {
+    *out = clli->clli;
+  }
+
+  return clli ? 1 : 0;
+}
+
+
+void heif_image_set_content_light_level(const heif_image* image, const heif_content_light_level* in)
+{
+  if (in == nullptr) {
+    return;
+  }
+
+  image->image->set_clli(*in);
+}
+
+
+void heif_image_handle_set_content_light_level(const heif_image_handle* handle, const heif_content_light_level* in)
+{
+  if (in == nullptr) {
+    return;
+  }
+
+  handle->image->set_clli(*in);
+}
+
+
+// --- mastering display colour volume ---
+
+
+int heif_image_has_mastering_display_colour_volume(const heif_image* image)
+{
+  return image->image->has_mdcv();
+}
+
+
+void heif_image_get_mastering_display_colour_volume(const heif_image* image, heif_mastering_display_colour_volume* out)
+{
+  *out = image->image->get_mdcv();
+}
+
+
+int heif_image_handle_get_mastering_display_colour_volume(const heif_image_handle* handle, heif_mastering_display_colour_volume* out)
+{
+  auto mdcv = handle->image->get_property<Box_mdcv>();
+  if (out && mdcv) {
+    *out = mdcv->mdcv;
+  }
+
+  return mdcv ? 1 : 0;
+}
+
+
+void heif_image_set_mastering_display_colour_volume(const heif_image* image, const heif_mastering_display_colour_volume* in)
+{
+  if (in == nullptr) {
+    return;
+  }
+
+  image->image->set_mdcv(*in);
+}
+
+
+void heif_image_handle_set_mastering_display_colour_volume(const heif_image_handle* handle, const heif_mastering_display_colour_volume* in)
+{
+  if (in == nullptr) {
+    return;
+  }
+
+  handle->image->set_mdcv(*in);
+}
+
+
+float mdcv_coord_decode_x(uint16_t coord)
+{
+  // check for unspecified value
+  if (coord < 5 || coord > 37000) {
+    return 0.0f;
+  }
+
+  return (float) (coord * 0.00002);
+}
+
+
+float mdcv_coord_decode_y(uint16_t coord)
+{
+  // check for unspecified value
+  if (coord < 5 || coord > 42000) {
+    return 0.0f;
+  }
+
+  return (float) (coord * 0.00002);
+}
+
+
+heif_error heif_mastering_display_colour_volume_decode(const heif_mastering_display_colour_volume* in,
+                                                       heif_decoded_mastering_display_colour_volume* out)
+{
+  if (in == nullptr || out == nullptr) {
+    return heif_error_null_pointer_argument;
+  }
+
+  for (int c = 0; c < 3; c++) {
+    out->display_primaries_x[c] = mdcv_coord_decode_x(in->display_primaries_x[c]);
+    out->display_primaries_y[c] = mdcv_coord_decode_y(in->display_primaries_y[c]);
+  }
+
+  out->white_point_x = mdcv_coord_decode_x(in->white_point_x);
+  out->white_point_y = mdcv_coord_decode_y(in->white_point_y);
+
+  if (in->max_display_mastering_luminance < 50000 || in->max_display_mastering_luminance > 100000000) {
+    out->max_display_mastering_luminance = 0;
+  }
+  else {
+    out->max_display_mastering_luminance = in->max_display_mastering_luminance * 0.0001;
+  }
+
+  if (in->min_display_mastering_luminance < 1 || in->min_display_mastering_luminance > 50000) {
+    out->min_display_mastering_luminance = 0;
+  }
+  else {
+    out->min_display_mastering_luminance = in->min_display_mastering_luminance * 0.0001;
+  }
+
+  return heif_error_success;
+}
diff --git a/libheif/api/libheif/heif_color.h b/libheif/api/libheif/heif_color.h
new file mode 100644
index 0000000000..c9dcfc8da9
--- /dev/null
+++ b/libheif/api/libheif/heif_color.h
@@ -0,0 +1,363 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017-2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_HEIF_COLOR_H
+#define LIBHEIF_HEIF_COLOR_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <libheif/heif_library.h>
+
+// forward declaration from other header files
+typedef struct heif_image heif_image;
+
+
+typedef enum heif_chroma_downsampling_algorithm
+{
+  heif_chroma_downsampling_nearest_neighbor = 1,
+  heif_chroma_downsampling_average = 2,
+
+  // Combine with 'heif_chroma_upsampling_bilinear' for best quality.
+  // Makes edges look sharper when using YUV 420 with bilinear chroma upsampling.
+  heif_chroma_downsampling_sharp_yuv = 3
+} heif_chroma_downsampling_algorithm;
+
+typedef enum heif_chroma_upsampling_algorithm
+{
+  heif_chroma_upsampling_nearest_neighbor = 1,
+  heif_chroma_upsampling_bilinear = 2
+} heif_chroma_upsampling_algorithm;
+
+
+typedef struct heif_color_conversion_options
+{
+  // 'version' must be 1.
+  uint8_t version;
+
+  // --- version 1 options
+
+  enum heif_chroma_downsampling_algorithm preferred_chroma_downsampling_algorithm;
+  enum heif_chroma_upsampling_algorithm preferred_chroma_upsampling_algorithm;
+
+  // When set to 'false' libheif may also use a different algorithm if the preferred one is not available
+  // or using a different algorithm is computationally less complex. Note that currently (v1.17.0) this
+  // means that for RGB input it will usually choose nearest-neighbor sampling because this is computationally
+  // the simplest.
+  // Set this field to 'true' if you want to make sure that the specified algorithm is used even
+  // at the cost of slightly higher computation times.
+  uint8_t only_use_preferred_chroma_algorithm;
+
+  // --- Note that we cannot extend this struct because it is embedded in
+  //     other structs (heif_decoding_options and heif_encoding_options).
+} heif_color_conversion_options;
+
+
+typedef enum heif_alpha_composition_mode
+{
+  heif_alpha_composition_mode_none,
+  heif_alpha_composition_mode_solid_color,
+  heif_alpha_composition_mode_checkerboard,
+} heif_alpha_composition_mode;
+
+
+typedef struct heif_color_conversion_options_ext
+{
+  uint8_t version;
+
+  // --- version 1 options
+
+  enum heif_alpha_composition_mode alpha_composition_mode;
+
+  // color values should be specified in the range [0, 65535]
+  uint16_t background_red, background_green, background_blue;
+  uint16_t secondary_background_red, secondary_background_green, secondary_background_blue;
+  uint16_t checkerboard_square_size;
+} heif_color_conversion_options_ext;
+
+
+// Assumes that it is a version=1 struct.
+LIBHEIF_API
+void heif_color_conversion_options_set_defaults(heif_color_conversion_options*);
+
+LIBHEIF_API
+heif_color_conversion_options_ext* heif_color_conversion_options_ext_alloc(void);
+
+LIBHEIF_API
+void heif_color_conversion_options_ext_copy(heif_color_conversion_options_ext* dst,
+                                            const heif_color_conversion_options_ext* src);
+
+LIBHEIF_API
+void heif_color_conversion_options_ext_free(heif_color_conversion_options_ext*);
+
+
+// ------------------------- color profiles -------------------------
+
+typedef enum heif_color_profile_type
+{
+  heif_color_profile_type_not_present = 0,
+  heif_color_profile_type_nclx = heif_fourcc('n', 'c', 'l', 'x'),
+  heif_color_profile_type_rICC = heif_fourcc('r', 'I', 'C', 'C'),
+  heif_color_profile_type_prof = heif_fourcc('p', 'r', 'o', 'f')
+} heif_color_profile_type;
+
+
+// Returns 'heif_color_profile_type_not_present' if there is no color profile.
+// If there is an ICC profile and an NCLX profile, the ICC profile is returned.
+// TODO: we need a new API for this function as images can contain both NCLX and ICC at the same time.
+//       However, you can still use heif_image_handle_get_raw_color_profile() and
+//       heif_image_handle_get_nclx_color_profile() to access both profiles.
+LIBHEIF_API
+enum heif_color_profile_type heif_image_handle_get_color_profile_type(const heif_image_handle* handle);
+
+LIBHEIF_API
+size_t heif_image_handle_get_raw_color_profile_size(const heif_image_handle* handle);
+
+// Returns 'heif_error_Color_profile_does_not_exist' when there is no ICC profile.
+LIBHEIF_API
+struct heif_error heif_image_handle_get_raw_color_profile(const heif_image_handle* handle,
+                                                          void* out_data);
+
+
+typedef enum heif_color_primaries
+{
+  heif_color_primaries_ITU_R_BT_709_5 = 1, // g=0.3;0.6, b=0.15;0.06, r=0.64;0.33, w=0.3127,0.3290
+  heif_color_primaries_unspecified = 2,
+  heif_color_primaries_ITU_R_BT_470_6_System_M = 4,
+  heif_color_primaries_ITU_R_BT_470_6_System_B_G = 5,
+  heif_color_primaries_ITU_R_BT_601_6 = 6,
+  heif_color_primaries_SMPTE_240M = 7,
+  heif_color_primaries_generic_film = 8,
+  heif_color_primaries_ITU_R_BT_2020_2_and_2100_0 = 9,
+  heif_color_primaries_SMPTE_ST_428_1 = 10,
+  heif_color_primaries_SMPTE_RP_431_2 = 11,
+  heif_color_primaries_SMPTE_EG_432_1 = 12,
+  heif_color_primaries_EBU_Tech_3213_E = 22
+} heif_color_primaries;
+
+typedef enum heif_transfer_characteristics
+{
+  heif_transfer_characteristic_ITU_R_BT_709_5 = 1,
+  heif_transfer_characteristic_unspecified = 2,
+  heif_transfer_characteristic_ITU_R_BT_470_6_System_M = 4,
+  heif_transfer_characteristic_ITU_R_BT_470_6_System_B_G = 5,
+  heif_transfer_characteristic_ITU_R_BT_601_6 = 6,
+  heif_transfer_characteristic_SMPTE_240M = 7,
+  heif_transfer_characteristic_linear = 8,
+  heif_transfer_characteristic_logarithmic_100 = 9,
+  heif_transfer_characteristic_logarithmic_100_sqrt10 = 10,
+  heif_transfer_characteristic_IEC_61966_2_4 = 11,
+  heif_transfer_characteristic_ITU_R_BT_1361 = 12,
+  heif_transfer_characteristic_IEC_61966_2_1 = 13,
+  heif_transfer_characteristic_ITU_R_BT_2020_2_10bit = 14,
+  heif_transfer_characteristic_ITU_R_BT_2020_2_12bit = 15,
+  heif_transfer_characteristic_ITU_R_BT_2100_0_PQ = 16,
+  heif_transfer_characteristic_SMPTE_ST_428_1 = 17,
+  heif_transfer_characteristic_ITU_R_BT_2100_0_HLG = 18
+} heif_transfer_characteristics;
+
+typedef enum heif_matrix_coefficients
+{
+  heif_matrix_coefficients_RGB_GBR = 0,
+  heif_matrix_coefficients_ITU_R_BT_709_5 = 1,  // TODO: or 709-6 according to h.273
+  heif_matrix_coefficients_unspecified = 2,
+  heif_matrix_coefficients_US_FCC_T47 = 4,
+  heif_matrix_coefficients_ITU_R_BT_470_6_System_B_G = 5,
+  heif_matrix_coefficients_ITU_R_BT_601_6 = 6,  // TODO: or 601-7 according to h.273
+  heif_matrix_coefficients_SMPTE_240M = 7,
+  heif_matrix_coefficients_YCgCo = 8,
+  heif_matrix_coefficients_ITU_R_BT_2020_2_non_constant_luminance = 9,
+  heif_matrix_coefficients_ITU_R_BT_2020_2_constant_luminance = 10,
+  heif_matrix_coefficients_SMPTE_ST_2085 = 11,
+  heif_matrix_coefficients_chromaticity_derived_non_constant_luminance = 12,
+  heif_matrix_coefficients_chromaticity_derived_constant_luminance = 13,
+  heif_matrix_coefficients_ICtCp = 14
+} heif_matrix_coefficients;
+
+typedef struct heif_color_profile_nclx
+{
+  // === version 1 fields
+
+  uint8_t version;
+
+  enum heif_color_primaries color_primaries;
+  enum heif_transfer_characteristics transfer_characteristics;
+  enum heif_matrix_coefficients matrix_coefficients;
+  uint8_t full_range_flag;
+
+  // --- decoded values (not used when saving nclx)
+
+  float color_primary_red_x, color_primary_red_y;
+  float color_primary_green_x, color_primary_green_y;
+  float color_primary_blue_x, color_primary_blue_y;
+  float color_primary_white_x, color_primary_white_y;
+} heif_color_profile_nclx;
+
+LIBHEIF_API
+heif_error heif_nclx_color_profile_set_color_primaries(heif_color_profile_nclx* nclx, uint16_t cp);
+
+LIBHEIF_API
+heif_error heif_nclx_color_profile_set_transfer_characteristics(heif_color_profile_nclx* nclx, uint16_t transfer_characteristics);
+
+LIBHEIF_API
+heif_error heif_nclx_color_profile_set_matrix_coefficients(heif_color_profile_nclx* nclx, uint16_t matrix_coefficients);
+
+// Returns 'heif_error_Color_profile_does_not_exist' when there is no NCLX profile.
+// TODO: This function does currently not return an NCLX profile if it is stored in the image bitstream.
+//       Only NCLX profiles stored as colr boxes are returned. This may change in the future.
+LIBHEIF_API
+heif_error heif_image_handle_get_nclx_color_profile(const heif_image_handle* handle,
+                                                    heif_color_profile_nclx** out_data);
+
+// Returned color profile has 'version' field set to the maximum allowed.
+// Do not fill values for higher versions as these might be outside the allocated structure size.
+// May return NULL.
+LIBHEIF_API
+heif_color_profile_nclx* heif_nclx_color_profile_alloc(void);
+
+LIBHEIF_API
+void heif_nclx_color_profile_free(heif_color_profile_nclx* nclx_profile);
+
+// Note: in early versions of HEIF, there could only be one color profile per image. However, this has been changed.
+// This function will now return ICC if one is present and NCLX only if there is no ICC.
+// You may better avoid this function and simply query for NCLX and ICC directly.
+LIBHEIF_API
+enum heif_color_profile_type heif_image_get_color_profile_type(const heif_image* image);
+
+// Returns the size of the ICC profile if one is assigned to the image. Otherwise, it returns 0.
+LIBHEIF_API
+size_t heif_image_get_raw_color_profile_size(const heif_image* image);
+
+// Returns the ICC profile if one is assigned to the image. Otherwise, it returns an error.
+LIBHEIF_API
+heif_error heif_image_get_raw_color_profile(const heif_image* image,
+                                            void* out_data);
+
+LIBHEIF_API
+heif_error heif_image_get_nclx_color_profile(const heif_image* image,
+                                             heif_color_profile_nclx** out_data);
+
+
+// The color profile is not attached to the image handle because we might need it
+// for color space transform and encoding.
+LIBHEIF_API
+heif_error heif_image_set_raw_color_profile(heif_image* image,
+                                            const char* profile_type_fourcc_string,
+                                            const void* profile_data,
+                                            const size_t profile_size);
+
+LIBHEIF_API
+heif_error heif_image_set_nclx_color_profile(heif_image* image,
+                                             const heif_color_profile_nclx* color_profile);
+
+
+// TODO: this function does not make any sense yet, since we currently cannot modify existing HEIF files.
+//LIBHEIF_API
+//void heif_image_remove_color_profile(struct heif_image* image);
+
+
+// --- content light level ---
+
+// Note: a value of 0 for any of these values indicates that the value is undefined.
+// The unit of these values is Candelas per square meter.
+typedef struct heif_content_light_level
+{
+  uint16_t max_content_light_level;
+  uint16_t max_pic_average_light_level;
+} heif_content_light_level;
+
+LIBHEIF_API
+int heif_image_has_content_light_level(const heif_image*);
+
+LIBHEIF_API
+void heif_image_get_content_light_level(const heif_image*, heif_content_light_level* out);
+
+// Returns whether the image has 'content light level' information. If 0 is returned, the output is not filled.
+LIBHEIF_API
+int heif_image_handle_get_content_light_level(const heif_image_handle*, heif_content_light_level* out);
+
+LIBHEIF_API
+void heif_image_set_content_light_level(const heif_image*, const heif_content_light_level* in);
+
+LIBHEIF_API
+void heif_image_handle_set_content_light_level(const heif_image_handle*, const heif_content_light_level* in);
+
+
+// --- mastering display colour volume ---
+
+// Note: color coordinates are defined according to the CIE 1931 definition of x as specified in ISO 11664-1 (see also ISO 11664-3 and CIE 15).
+typedef struct heif_mastering_display_colour_volume
+{
+  uint16_t display_primaries_x[3];
+  uint16_t display_primaries_y[3];
+  uint16_t white_point_x;
+  uint16_t white_point_y;
+  uint32_t max_display_mastering_luminance;
+  uint32_t min_display_mastering_luminance;
+} heif_mastering_display_colour_volume;
+
+// The units for max_display_mastering_luminance and min_display_mastering_luminance is Candelas per square meter.
+typedef struct heif_decoded_mastering_display_colour_volume
+{
+  float display_primaries_x[3];
+  float display_primaries_y[3];
+  float white_point_x;
+  float white_point_y;
+  double max_display_mastering_luminance;
+  double min_display_mastering_luminance;
+} heif_decoded_mastering_display_colour_volume;
+
+typedef struct heif_ambient_viewing_environment
+{
+  uint32_t ambient_illumination;
+  uint16_t ambient_light_x;
+  uint16_t ambient_light_y;
+} heif_ambient_viewing_environment;
+
+LIBHEIF_API
+int heif_image_has_mastering_display_colour_volume(const heif_image*);
+
+LIBHEIF_API
+void heif_image_get_mastering_display_colour_volume(const heif_image*, heif_mastering_display_colour_volume* out);
+
+// Returns whether the image has 'mastering display colour volume' information. If 0 is returned, the output is not filled.
+LIBHEIF_API
+int heif_image_handle_get_mastering_display_colour_volume(const heif_image_handle*, heif_mastering_display_colour_volume* out);
+
+LIBHEIF_API
+void heif_image_set_mastering_display_colour_volume(const heif_image*, const heif_mastering_display_colour_volume* in);
+
+LIBHEIF_API
+void heif_image_handle_set_mastering_display_colour_volume(const heif_image_handle*, const heif_mastering_display_colour_volume* in);
+
+
+// Converts the internal numeric representation of heif_mastering_display_colour_volume to the
+// normalized values, collected in heif_decoded_mastering_display_colour_volume.
+// Values that are out-of-range are decoded to 0, indicating an undefined value (as specified in ISO/IEC 23008-2).
+LIBHEIF_API
+struct heif_error heif_mastering_display_colour_volume_decode(const heif_mastering_display_colour_volume* in,
+                                                              heif_decoded_mastering_display_colour_volume* out);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/libheif/api/libheif/heif_context.cc b/libheif/api/libheif/heif_context.cc
new file mode 100644
index 0000000000..b45595c21a
--- /dev/null
+++ b/libheif/api/libheif/heif_context.cc
@@ -0,0 +1,293 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017-2025 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "heif_context.h"
+#include "api_structs.h"
+#include "context.h"
+#include "init.h"
+#include "file.h"
+
+#include <fstream>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+#include <algorithm>
+
+#ifdef _WIN32
+// for _write
+#include <io.h>
+#else
+#include <unistd.h>
+#endif
+
+
+heif_context* heif_context_alloc()
+{
+  load_plugins_if_not_initialized_yet();
+
+  heif_context* ctx = new heif_context;
+  ctx->context = std::make_shared<HeifContext>();
+
+  return ctx;
+}
+
+void heif_context_free(heif_context* ctx)
+{
+  delete ctx;
+}
+
+heif_error heif_context_read_from_file(heif_context* ctx, const char* filename,
+                                       const heif_reading_options*)
+{
+  Error err = ctx->context->read_from_file(filename);
+  return err.error_struct(ctx->context.get());
+}
+
+heif_error heif_context_read_from_memory(heif_context* ctx, const void* mem, size_t size,
+                                         const heif_reading_options*)
+{
+  Error err = ctx->context->read_from_memory(mem, size, true);
+  return err.error_struct(ctx->context.get());
+}
+
+heif_error heif_context_read_from_memory_without_copy(heif_context* ctx, const void* mem, size_t size,
+                                                      const heif_reading_options*)
+{
+  Error err = ctx->context->read_from_memory(mem, size, false);
+  return err.error_struct(ctx->context.get());
+}
+
+heif_error heif_context_read_from_reader(heif_context* ctx,
+                                         const heif_reader* reader_func_table,
+                                         void* userdata,
+                                         const heif_reading_options*)
+{
+  auto reader = std::make_shared<StreamReader_CApi>(reader_func_table, userdata);
+
+  Error err = ctx->context->read(reader);
+  return err.error_struct(ctx->context.get());
+}
+
+// TODO: heif_error heif_context_read_from_file_descriptor(heif_context*, int fd);
+
+int heif_context_get_number_of_top_level_images(heif_context* ctx)
+{
+  return (int) ctx->context->get_top_level_images(true).size();
+}
+
+
+int heif_context_is_top_level_image_ID(heif_context* ctx, heif_item_id id)
+{
+  const std::vector<std::shared_ptr<ImageItem> > images = ctx->context->get_top_level_images(true);
+
+  for (const auto& img : images) {
+    if (img->get_id() == id) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+
+int heif_context_get_list_of_top_level_image_IDs(heif_context* ctx,
+                                                 heif_item_id* ID_array,
+                                                 int count)
+{
+  if (ID_array == nullptr || count == 0 || ctx == nullptr) {
+    return 0;
+  }
+
+
+  // fill in ID values into output array
+
+  const std::vector<std::shared_ptr<ImageItem> > imgs = ctx->context->get_top_level_images(true);
+  int n = (int) std::min(count, (int) imgs.size());
+  for (int i = 0; i < n; i++) {
+    ID_array[i] = imgs[i]->get_id();
+  }
+
+  return n;
+}
+
+
+heif_error heif_context_get_primary_image_ID(heif_context* ctx, heif_item_id* id)
+{
+  if (!id) {
+    return Error(heif_error_Usage_error,
+                 heif_suberror_Null_pointer_argument).error_struct(ctx->context.get());
+  }
+
+  std::shared_ptr<ImageItem> primary = ctx->context->get_primary_image(true);
+  if (!primary) {
+    return Error(heif_error_Invalid_input,
+                 heif_suberror_No_or_invalid_primary_item).error_struct(ctx->context.get());
+  }
+
+  *id = primary->get_id();
+
+  return Error::Ok.error_struct(ctx->context.get());
+}
+
+
+heif_error heif_context_get_primary_image_handle(heif_context* ctx, heif_image_handle** img)
+{
+  if (!img) {
+    Error err(heif_error_Usage_error,
+              heif_suberror_Null_pointer_argument);
+    return err.error_struct(ctx->context.get());
+  }
+
+  std::shared_ptr<ImageItem> primary_image = ctx->context->get_primary_image(true);
+
+  // It is a requirement of an HEIF file there is always a primary image.
+  // If there is none, an error is generated when loading the file.
+  if (!primary_image) {
+    Error err(heif_error_Invalid_input,
+              heif_suberror_No_or_invalid_primary_item);
+    return err.error_struct(ctx->context.get());
+  }
+
+  if (auto errImage = std::dynamic_pointer_cast<ImageItem_Error>(primary_image)) {
+    Error error = errImage->get_item_error();
+    return error.error_struct(ctx->context.get());
+  }
+
+  *img = new heif_image_handle();
+  (*img)->image = std::move(primary_image);
+  (*img)->context = ctx->context;
+
+  return Error::Ok.error_struct(ctx->context.get());
+}
+
+
+heif_error heif_context_get_image_handle(heif_context* ctx,
+                                         heif_item_id id,
+                                         heif_image_handle** imgHdl)
+{
+  if (!imgHdl) {
+    return {heif_error_Usage_error, heif_suberror_Null_pointer_argument, ""};
+  }
+
+  auto image = ctx->context->get_image(id, true);
+
+  if (auto errImage = std::dynamic_pointer_cast<ImageItem_Error>(image)) {
+    Error error = errImage->get_item_error();
+    return error.error_struct(ctx->context.get());
+  }
+
+  if (!image) {
+    *imgHdl = nullptr;
+
+    return {heif_error_Usage_error, heif_suberror_Nonexisting_item_referenced, ""};
+  }
+
+  *imgHdl = new heif_image_handle();
+  (*imgHdl)->image = std::move(image);
+  (*imgHdl)->context = ctx->context;
+
+  return heif_error_success;
+}
+
+
+void heif_context_debug_dump_boxes_to_file(heif_context* ctx, int fd)
+{
+  if (!ctx) {
+    return;
+  }
+
+  std::string dump = ctx->context->debug_dump_boxes();
+  // TODO(fancycode): Should we return an error if writing fails?
+#ifdef _WIN32
+  auto written = _write(fd, dump.c_str(), static_cast<unsigned int>(dump.size()));
+#else
+  auto written = write(fd, dump.c_str(), dump.size());
+#endif
+  (void) written;
+}
+
+
+// ====================================================================================================
+//   Write the heif_context to a HEIF file
+
+
+static heif_error heif_file_writer_write(heif_context* ctx,
+                                         const void* data, size_t size, void* userdata)
+{
+  const char* filename = static_cast<const char*>(userdata);
+
+#if defined(__MINGW32__) || defined(__MINGW64__) || defined(_MSC_VER)
+  std::ofstream ostr(HeifFile::convert_utf8_path_to_utf16(filename).c_str(), std::ios_base::binary);
+#else
+  std::ofstream ostr(filename, std::ios_base::binary);
+#endif
+  ostr.write(static_cast<const char*>(data), size);
+  // TODO: handle write errors
+  return Error::Ok.error_struct(ctx->context.get());
+}
+
+
+heif_error heif_context_write_to_file(heif_context* ctx,
+                                      const char* filename)
+{
+  heif_writer writer;
+  writer.writer_api_version = 1;
+  writer.write = heif_file_writer_write;
+  return heif_context_write(ctx, &writer, (void*) filename);
+}
+
+
+heif_error heif_context_write(heif_context* ctx,
+                              heif_writer* writer,
+                              void* userdata)
+{
+  if (!writer) {
+    return Error(heif_error_Usage_error,
+                 heif_suberror_Null_pointer_argument).error_struct(ctx->context.get());
+  }
+
+  if (writer->writer_api_version != 1) {
+    Error err(heif_error_Usage_error, heif_suberror_Unsupported_writer_version);
+    return err.error_struct(ctx->context.get());
+  }
+
+  StreamWriter swriter;
+  Error err = ctx->context->write(swriter);
+  if (err) {
+    return err.error_struct(ctx->context.get());
+  }
+
+  const auto& data = swriter.get_data();
+  heif_error writer_error = writer->write(ctx, data.data(), data.size(), userdata);
+  if (!writer_error.message) {
+    // It is now allowed to return a NULL error message on success. It will be replaced by "Success". An error message is still required when there is an error.
+    if (writer_error.code == heif_error_Ok) {
+      writer_error.message = Error::kSuccess;
+      return writer_error;
+    }
+    else {
+      return heif_error{heif_error_Usage_error, heif_suberror_Null_pointer_argument, "heif_writer callback returned a null error text"};
+    }
+  }
+  else {
+    return writer_error;
+  }
+}
diff --git a/libheif/api/libheif/heif_context.h b/libheif/api/libheif/heif_context.h
new file mode 100644
index 0000000000..c978b35116
--- /dev/null
+++ b/libheif/api/libheif/heif_context.h
@@ -0,0 +1,329 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017-2025 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_HEIF_CONTEXT_H
+#define LIBHEIF_HEIF_CONTEXT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <libheif/heif_library.h>
+#include <libheif/heif_error.h>
+
+
+/**
+ * libheif known compression formats.
+ */
+typedef enum heif_compression_format
+{
+  /**
+   * Unspecified / undefined compression format.
+   *
+   * This is used to mean "no match" or "any decoder" for some parts of the
+   * API. It does not indicate a specific compression format.
+   */
+  heif_compression_undefined = 0,
+  /**
+   * HEVC compression, used for HEIC images.
+   *
+   * This is equivalent to H.265.
+  */
+  heif_compression_HEVC = 1,
+  /**
+   * AVC compression. (Currently unused in libheif.)
+   *
+   * The compression is defined in ISO/IEC 14496-10. This is equivalent to H.264.
+   *
+   * The encapsulation is defined in ISO/IEC 23008-12:2022 Annex E.
+   */
+  heif_compression_AVC = 2,
+  /**
+   * JPEG compression.
+   *
+   * The compression format is defined in ISO/IEC 10918-1. The encapsulation
+   * of JPEG is specified in ISO/IEC 23008-12:2022 Annex H.
+  */
+  heif_compression_JPEG = 3,
+  /**
+   * AV1 compression, used for AVIF images.
+   *
+   * The compression format is provided at https://aomediacodec.github.io/av1-spec/
+   *
+   * The encapsulation is defined in https://aomediacodec.github.io/av1-avif/
+   */
+  heif_compression_AV1 = 4,
+  /**
+   * VVC compression.
+   *
+   * The compression format is defined in ISO/IEC 23090-3. This is equivalent to H.266.
+   *
+   * The encapsulation is defined in ISO/IEC 23008-12:2022 Annex L.
+   */
+  heif_compression_VVC = 5,
+  /**
+   * EVC compression. (Currently unused in libheif.)
+   *
+   * The compression format is defined in ISO/IEC 23094-1.
+   *
+   * The encapsulation is defined in ISO/IEC 23008-12:2022 Annex M.
+   */
+  heif_compression_EVC = 6,
+  /**
+   * JPEG 2000 compression.
+   *
+   * The encapsulation of JPEG 2000 is specified in ISO/IEC 15444-16:2021.
+   * The core encoding is defined in ISO/IEC 15444-1, or ITU-T T.800.
+  */
+  heif_compression_JPEG2000 = 7,
+  /**
+   * Uncompressed encoding.
+   *
+   * This is defined in ISO/IEC 23001-17:2024.
+  */
+  heif_compression_uncompressed = 8,
+  /**
+   * Mask image encoding.
+   *
+   * See ISO/IEC 23008-12:2022 Section 6.10.2
+   */
+  heif_compression_mask = 9,
+  /**
+   * High Throughput JPEG 2000 (HT-J2K) compression.
+   *
+   * The encapsulation of HT-J2K is specified in ISO/IEC 15444-16:2021.
+   * The core encoding is defined in ISO/IEC 15444-15, or ITU-T T.814.
+  */
+  heif_compression_HTJ2K = 10
+} heif_compression_format;
+
+
+// ========================= heif_context =========================
+// A heif_context represents a HEIF file that has been read.
+// In the future, you will also be able to add pictures to a heif_context
+// and write it into a file again.
+
+
+// Allocate a new context for reading HEIF files.
+// Has to be freed again with heif_context_free().
+LIBHEIF_API
+heif_context* heif_context_alloc(void);
+
+// Free a previously allocated HEIF context. You should not free a context twice.
+LIBHEIF_API
+void heif_context_free(heif_context*);
+
+
+typedef struct heif_reading_options heif_reading_options;
+
+typedef enum heif_reader_grow_status
+{
+  heif_reader_grow_status_size_reached,    // requested size has been reached, we can read until this point
+  heif_reader_grow_status_timeout,         // size has not been reached yet, but it may still grow further (deprecated)
+  heif_reader_grow_status_size_beyond_eof, // size has not been reached and never will. The file has grown to its full size
+  heif_reader_grow_status_error            // an error has occurred
+} heif_reader_grow_status;
+
+
+typedef struct heif_reader_range_request_result
+{
+  enum heif_reader_grow_status status; // should not return 'heif_reader_grow_status_timeout'
+
+  // Indicates up to what position the file has been read.
+  // If we cannot read the whole file range (status == 'heif_reader_grow_status_size_beyond_eof'), this is the actual end position.
+  // On the other hand, it may be that the reader was reading more data than requested. In that case, it should indicate the full size here
+  // and libheif may decide to make use of the additional data (e.g. for filling 'tili' offset tables).
+  uint64_t range_end;
+
+  // for status == 'heif_reader_grow_status_error'
+  int reader_error_code;        // a reader specific error code
+  const char* reader_error_msg; // libheif will call heif_reader.release_error_msg on this if it is not NULL
+} heif_reader_range_request_result;
+
+
+typedef struct heif_reader
+{
+  // API version supported by this reader
+  int reader_api_version;
+
+  // --- version 1 functions ---
+  int64_t (* get_position)(void* userdata);
+
+  // The functions read(), and seek() return 0 on success.
+  // Generally, libheif will make sure that we do not read past the file size.
+  int (* read)(void* data,
+               size_t size,
+               void* userdata);
+
+  int (* seek)(int64_t position,
+               void* userdata);
+
+  // When calling this function, libheif wants to make sure that it can read the file
+  // up to 'target_size'. This is useful when the file is currently downloaded and may
+  // grow with time. You may, for example, extract the image sizes even before the actual
+  // compressed image data has been completely downloaded.
+  //
+  // Even if your input files will not grow, you will have to implement at least
+  // detection whether the target_size is above the (fixed) file length
+  // (in this case, return 'size_beyond_eof').
+  enum heif_reader_grow_status (* wait_for_file_size)(int64_t target_size, void* userdata);
+
+  // --- version 2 functions ---
+
+  // These two functions are for applications that want to stream HEIF files on demand.
+  // For example, a large HEIF file that is served over HTTPS and we only want to download
+  // it partially to decode individual tiles.
+  // If you do not have this use case, you do not have to implement these functions and
+  // you can set them to NULL. For simple linear loading, you may use the 'wait_for_file_size'
+  // function above instead.
+
+  // If this function is defined, libheif will often request a file range before accessing it.
+  // The purpose of this function is that libheif will usually read very small chunks of data with the
+  // read() callback above. However, it is inefficient to request such a small chunk of data over a network
+  // and the network delay will significantly increase the decoding time.
+  // Thus, libheif will call request_range() with a larger block of data that should be preloaded and the
+  // subsequent read() calls will work within the requested ranges.
+  //
+  // Note: `end_pos` is one byte after the last position to be read.
+  // You should return
+  // - 'heif_reader_grow_status_size_reached' if the requested range is available, or
+  // - 'heif_reader_grow_status_size_beyond_eof' if the requested range exceeds the file size
+  //   (the valid part of the range has been read).
+  heif_reader_range_request_result (* request_range)(uint64_t start_pos, uint64_t end_pos, void* userdata);
+
+  // libheif might issue hints when it assumes that a file range might be needed in the future.
+  // This may happen, for example, when your are doing selective tile accesses and libheif proposes
+  // to preload offset pointer tables.
+  // Another difference to request_file_range() is that this call should be non-blocking.
+  // If you preload any data, do this in a background thread.
+  void (* preload_range_hint)(uint64_t start_pos, uint64_t end_pos, void* userdata);
+
+  // If libheif does not need access to a file range anymore, it may call this function to
+  // give a hint to the reader that it may release the range from a cache.
+  // If you do not maintain a file cache that wants to reduce its size dynamically, you do not
+  // need to implement this function.
+  void (* release_file_range)(uint64_t start_pos, uint64_t end_pos, void* userdata);
+
+  // Release an error message that was returned by heif_reader in an earlier call.
+  // If this function is NULL, the error message string will not be released.
+  // This is a viable option if you are only returning static strings.
+  void (* release_error_msg)(const char* msg);
+} heif_reader;
+
+
+// Read a HEIF file from a named disk file.
+// The heif_reading_options should currently be set to NULL.
+LIBHEIF_API
+heif_error heif_context_read_from_file(heif_context*, const char* filename,
+                                       const heif_reading_options*);
+
+// Read a HEIF file stored completely in memory.
+// The heif_reading_options should currently be set to NULL.
+// DEPRECATED: use heif_context_read_from_memory_without_copy() instead.
+LIBHEIF_API
+heif_error heif_context_read_from_memory(heif_context*,
+                                         const void* mem, size_t size,
+                                         const heif_reading_options*);
+
+// Same as heif_context_read_from_memory() except that the provided memory is not copied.
+// That means, you will have to keep the memory area alive as long as you use the heif_context.
+LIBHEIF_API
+heif_error heif_context_read_from_memory_without_copy(heif_context*,
+                                                      const void* mem, size_t size,
+                                                      const heif_reading_options*);
+
+LIBHEIF_API
+heif_error heif_context_read_from_reader(heif_context*,
+                                         const heif_reader* reader,
+                                         void* userdata,
+                                         const heif_reading_options*);
+
+// Number of top-level images in the HEIF file. This does not include the thumbnails or the
+// tile images that are composed to an image grid. You can get access to the thumbnails via
+// the main image handle.
+LIBHEIF_API
+int heif_context_get_number_of_top_level_images(heif_context* ctx);
+
+LIBHEIF_API
+int heif_context_is_top_level_image_ID(heif_context* ctx, heif_item_id id);
+
+// Fills in image IDs into the user-supplied int-array 'ID_array', preallocated with 'count' entries.
+// Function returns the total number of IDs filled into the array.
+LIBHEIF_API
+int heif_context_get_list_of_top_level_image_IDs(heif_context* ctx,
+                                                 heif_item_id* ID_array,
+                                                 int count);
+
+LIBHEIF_API
+heif_error heif_context_get_primary_image_ID(heif_context* ctx, heif_item_id* id);
+
+// Get a handle to the primary image of the HEIF file.
+// This is the image that should be displayed primarily when there are several images in the file.
+LIBHEIF_API
+heif_error heif_context_get_primary_image_handle(heif_context* ctx,
+                                                 heif_image_handle**);
+
+// Get the image handle for a known image ID.
+LIBHEIF_API
+heif_error heif_context_get_image_handle(heif_context* ctx,
+                                         heif_item_id id,
+                                         heif_image_handle**);
+
+// Print information about the boxes of a HEIF file to file descriptor.
+// This is for debugging and informational purposes only. You should not rely on
+// the output having a specific format. At best, you should not use this at all.
+LIBHEIF_API
+void heif_context_debug_dump_boxes_to_file(heif_context* ctx, int fd);
+
+// ====================================================================================================
+//   Write the heif_context to a HEIF file
+
+LIBHEIF_API
+heif_error heif_context_write_to_file(heif_context*,
+                                      const char* filename);
+
+typedef struct heif_writer
+{
+  // API version supported by this writer
+  int writer_api_version;
+
+  // --- version 1 functions ---
+
+  // On success, the returned heif_error may have a NULL message. It will automatically be replaced with a "Success" string.
+  heif_error (* write)(heif_context* ctx, // TODO: why do we need this parameter?
+                       const void* data,
+                       size_t size,
+                       void* userdata);
+} heif_writer;
+
+
+LIBHEIF_API
+heif_error heif_context_write(heif_context*,
+                              heif_writer* writer,
+                              void* userdata);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/libheif/heif_cxx.h b/libheif/api/libheif/heif_cxx.h
similarity index 86%
rename from libheif/heif_cxx.h
rename to libheif/api/libheif/heif_cxx.h
index 69c30a61f0..bdc2266616 100644
--- a/libheif/heif_cxx.h
+++ b/libheif/api/libheif/heif_cxx.h
@@ -1,21 +1,27 @@
 /*
  * C++ interface to libheif
- * Copyright (c) 2018 struktur AG, Dirk Farin <farin@struktur.de>
  *
- * This file is part of libheif.
+ * MIT License
  *
- * libheif is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as
- * published by the Free Software Foundation, either version 3 of
- * the License, or (at your option) any later version.
+ * Copyright (c) 2018 Dirk Farin <dirk.farin@gmail.com>
  *
- * libheif is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
  */
 
 #ifndef LIBHEIF_HEIF_CXX_H
@@ -24,6 +30,7 @@
 #include <memory>
 #include <string>
 #include <vector>
+#include <cassert>
 
 extern "C" {
 #include <libheif/heif.h>
@@ -44,6 +51,8 @@ namespace heif {
 
     Error(const heif_error& err)
     {
+      assert(err.message);
+
       m_code = err.code;
       m_subcode = err.subcode;
       m_message = err.message;
@@ -56,7 +65,7 @@ namespace heif {
       m_message = msg;
     }
 
-    std::string get_message() const
+    const std::string& get_message() const
     { return m_message; }
 
     heif_error_code get_code() const
@@ -96,7 +105,7 @@ namespace heif {
     };
 
     // throws Error
-    void read_from_file(std::string filename, const ReadingOptions& opts = ReadingOptions());
+    void read_from_file(const std::string& filename, const ReadingOptions& opts = ReadingOptions());
 
     // DEPRECATED. Use read_from_memory_without_copy() instead.
     // throws Error
@@ -108,8 +117,7 @@ namespace heif {
     class Reader
     {
     public:
-      virtual ~Reader()
-      {}
+      virtual ~Reader() = default;
 
       virtual int64_t get_position() const = 0;
 
@@ -173,8 +181,7 @@ namespace heif {
     class Writer
     {
     public:
-      virtual ~Writer()
-      {}
+      virtual ~Writer() = default;
 
       virtual heif_error write(const void* data, size_t size) = 0;
     };
@@ -183,7 +190,7 @@ namespace heif {
     void write(Writer&);
 
     // throws Error
-    void write_to_file(std::string filename) const;
+    void write_to_file(const std::string& filename) const;
 
   private:
     std::shared_ptr<heif_context> m_context;
@@ -200,8 +207,7 @@ namespace heif {
   class ImageHandle
   {
   public:
-    ImageHandle()
-    {}
+    ImageHandle() = default;
 
     ImageHandle(heif_image_handle* handle);
 
@@ -277,7 +283,7 @@ namespace heif {
   public:
     ColorProfile_nclx();
 
-    ~ColorProfile_nclx();
+    ~ColorProfile_nclx() = default;
 
     heif_color_primaries get_color_primaries() const;
 
@@ -287,6 +293,9 @@ namespace heif {
 
     bool is_full_range() const;
 
+    void set_color_primaries(heif_color_primaries cp);
+
+    // DEPRECATED: typo in function name. Use set_color_primaries() instead.
     void set_color_primaties(heif_color_primaries cp);
 
     void set_transfer_characteristics(heif_transfer_characteristics tc);
@@ -296,10 +305,9 @@ namespace heif {
     void set_full_range_flag(bool is_full_range);
 
   private:
-    ColorProfile_nclx(heif_color_profile_nclx* nclx)
-    { mProfile = nclx; }
+    ColorProfile_nclx(heif_color_profile_nclx* nclx);
 
-    heif_color_profile_nclx* mProfile;
+    std::shared_ptr<heif_color_profile_nclx> mProfile;
 
     friend class Image;
   };
@@ -308,8 +316,7 @@ namespace heif {
   class Image
   {
   public:
-    Image()
-    {}
+    Image() = default;
 
     Image(heif_image* image);
 
@@ -337,10 +344,16 @@ namespace heif {
 
     bool has_channel(enum heif_channel channel) const noexcept;
 
+    // DEPRECATED
     const uint8_t* get_plane(enum heif_channel channel, int* out_stride) const noexcept;
 
+    // DEPRECATED
     uint8_t* get_plane(enum heif_channel channel, int* out_stride) noexcept;
 
+    const uint8_t* get_plane2(enum heif_channel channel, size_t* out_stride) const noexcept;
+
+    uint8_t* get_plane2(enum heif_channel channel, size_t* out_stride) noexcept;
+
     // throws Error
     void set_nclx_color_profile(const ColorProfile_nclx&);
 
@@ -387,14 +400,19 @@ namespace heif {
 
     enum heif_compression_format get_compression_format() const noexcept;
 
+    // DEPRECATED: typo in function name
     bool supportes_lossy_compression() const noexcept;
 
+    // DEPRECATED: typo in function name
     bool supportes_lossless_compression() const noexcept;
 
 
     // throws Error
     Encoder get_encoder() const;
 
+    bool supports_lossy_compression() const noexcept;
+
+    bool supports_lossless_compression() const noexcept;
 
   private:
     EncoderDescriptor(const struct heif_encoder_descriptor* descr) : m_descriptor(descr)
@@ -445,21 +463,21 @@ namespace heif {
 
     std::vector<EncoderParameter> list_parameters() const noexcept;
 
-    void set_integer_parameter(std::string parameter_name, int value);
+    void set_integer_parameter(const std::string& parameter_name, int value);
 
-    int get_integer_parameter(std::string parameter_name) const;
+    int get_integer_parameter(const std::string& parameter_name) const;
 
-    void set_boolean_parameter(std::string parameter_name, bool value);
+    void set_boolean_parameter(const std::string& parameter_name, bool value);
 
-    bool get_boolean_parameter(std::string parameter_name) const;
+    bool get_boolean_parameter(const std::string& parameter_name) const;
 
-    void set_string_parameter(std::string parameter_name, std::string value);
+    void set_string_parameter(const std::string& parameter_name, const std::string& value);
 
-    std::string get_string_parameter(std::string parameter_name) const;
+    std::string get_string_parameter(const std::string& parameter_name) const;
 
-    void set_parameter(std::string parameter_name, std::string parameter_value);
+    void set_parameter(const std::string& parameter_name, const std::string& parameter_value);
 
-    std::string get_parameter(std::string parameter_name) const;
+    std::string get_parameter(const std::string& parameter_name) const;
 
   private:
     Encoder(struct heif_encoder*) noexcept;
@@ -483,7 +501,7 @@ namespace heif {
                                               [](heif_context* c) { heif_context_free(c); });
   }
 
-  inline void Context::read_from_file(std::string filename, const ReadingOptions& /*opts*/)
+  inline void Context::read_from_file(const std::string& filename, const ReadingOptions& /*opts*/)
   {
     Error err = Error(heif_context_read_from_file(m_context.get(), filename.c_str(), NULL));
     if (err) {
@@ -539,7 +557,11 @@ namespace heif {
           heif_reader_trampoline_get_position,
           heif_reader_trampoline_read,
           heif_reader_trampoline_seek,
-          heif_reader_trampoline_wait_for_file_size
+          heif_reader_trampoline_wait_for_file_size,
+          NULL,
+          NULL,
+          NULL,
+          NULL,
       };
 
   inline void Context::read_from_reader(Reader& reader, const ReadingOptions& /*opts*/)
@@ -638,7 +660,7 @@ namespace heif {
     }
   }
 
-  inline void Context::write_to_file(std::string filename) const
+  inline void Context::write_to_file(const std::string& filename) const
   {
     Error err = Error(heif_context_write_to_file(m_context.get(), filename.c_str()));
     if (err) {
@@ -790,12 +812,15 @@ namespace heif {
 
   inline ColorProfile_nclx::ColorProfile_nclx()
   {
-    mProfile = heif_nclx_color_profile_alloc();
+    auto profile = heif_nclx_color_profile_alloc();
+    mProfile = std::shared_ptr<heif_color_profile_nclx>(profile,
+                                                        [](heif_color_profile_nclx* p) { heif_nclx_color_profile_free(p); });
   }
 
-  inline ColorProfile_nclx::~ColorProfile_nclx()
+  inline ColorProfile_nclx::ColorProfile_nclx(heif_color_profile_nclx* nclx)
   {
-    delete mProfile;
+    mProfile = std::shared_ptr<heif_color_profile_nclx>(nclx,
+                                                        [](heif_color_profile_nclx* p) { heif_nclx_color_profile_free(p); });
   }
 
   inline heif_color_primaries ColorProfile_nclx::get_color_primaries() const
@@ -810,9 +835,12 @@ namespace heif {
   inline bool ColorProfile_nclx::is_full_range() const
   { return mProfile->full_range_flag; }
 
-  inline void ColorProfile_nclx::set_color_primaties(heif_color_primaries cp)
+  inline void ColorProfile_nclx::set_color_primaries(heif_color_primaries cp)
   { mProfile->color_primaries = cp; }
 
+  inline void ColorProfile_nclx::set_color_primaties(heif_color_primaries cp)
+  { set_color_primaries(cp); }
+
   inline void ColorProfile_nclx::set_transfer_characteristics(heif_transfer_characteristics tc)
   { mProfile->transfer_characteristics = tc; }
 
@@ -900,9 +928,19 @@ namespace heif {
     return heif_image_get_plane(m_image.get(), channel, out_stride);
   }
 
+  inline const uint8_t* Image::get_plane2(enum heif_channel channel, size_t* out_stride) const noexcept
+  {
+    return heif_image_get_plane_readonly2(m_image.get(), channel, out_stride);
+  }
+
+  inline uint8_t* Image::get_plane2(enum heif_channel channel, size_t* out_stride) noexcept
+  {
+    return heif_image_get_plane2(m_image.get(), channel, out_stride);
+  }
+
   inline void Image::set_nclx_color_profile(const ColorProfile_nclx& nclx)
   {
-    Error err = Error(heif_image_set_nclx_color_profile(m_image.get(), nclx.mProfile));
+    Error err = Error(heif_image_set_nclx_color_profile(m_image.get(), nclx.mProfile.get()));
     if (err) {
       throw err;
     }
@@ -1001,6 +1039,7 @@ namespace heif {
                                                           maxDescriptors);
       if (nDescriptors < maxDescriptors) {
         std::vector<EncoderDescriptor> outDescriptors;
+        outDescriptors.reserve(nDescriptors);
         for (int i = 0; i < nDescriptors; i++) {
           outDescriptors.push_back(EncoderDescriptor(descriptors[i]));
         }
@@ -1034,12 +1073,22 @@ namespace heif {
 
   inline bool EncoderDescriptor::supportes_lossy_compression() const noexcept
   {
-    return heif_encoder_descriptor_supportes_lossy_compression(m_descriptor);
+    return heif_encoder_descriptor_supports_lossy_compression(m_descriptor);
+  }
+
+  inline bool EncoderDescriptor::supports_lossy_compression() const noexcept
+  {
+    return heif_encoder_descriptor_supports_lossy_compression(m_descriptor);
   }
 
   inline bool EncoderDescriptor::supportes_lossless_compression() const noexcept
   {
-    return heif_encoder_descriptor_supportes_lossless_compression(m_descriptor);
+    return heif_encoder_descriptor_supports_lossless_compression(m_descriptor);
+  }
+
+  inline bool EncoderDescriptor::supports_lossless_compression() const noexcept
+  {
+    return heif_encoder_descriptor_supports_lossless_compression(m_descriptor);
   }
 
   inline Encoder EncoderDescriptor::get_encoder() const
@@ -1163,7 +1212,7 @@ namespace heif {
     }
   }
 
-  inline void Encoder::set_integer_parameter(std::string parameter_name, int value)
+  inline void Encoder::set_integer_parameter(const std::string& parameter_name, int value)
   {
     Error err = Error(heif_encoder_set_parameter_integer(m_encoder.get(), parameter_name.c_str(), value));
     if (err) {
@@ -1171,7 +1220,7 @@ namespace heif {
     }
   }
 
-  inline int Encoder::get_integer_parameter(std::string parameter_name) const
+  inline int Encoder::get_integer_parameter(const std::string& parameter_name) const
   {
     int value;
     Error err = Error(heif_encoder_get_parameter_integer(m_encoder.get(), parameter_name.c_str(), &value));
@@ -1181,7 +1230,7 @@ namespace heif {
     return value;
   }
 
-  inline void Encoder::set_boolean_parameter(std::string parameter_name, bool value)
+  inline void Encoder::set_boolean_parameter(const std::string& parameter_name, bool value)
   {
     Error err = Error(heif_encoder_set_parameter_boolean(m_encoder.get(), parameter_name.c_str(), value));
     if (err) {
@@ -1189,7 +1238,7 @@ namespace heif {
     }
   }
 
-  inline bool Encoder::get_boolean_parameter(std::string parameter_name) const
+  inline bool Encoder::get_boolean_parameter(const std::string& parameter_name) const
   {
     int value;
     Error err = Error(heif_encoder_get_parameter_boolean(m_encoder.get(), parameter_name.c_str(), &value));
@@ -1199,7 +1248,7 @@ namespace heif {
     return value;
   }
 
-  inline void Encoder::set_string_parameter(std::string parameter_name, std::string value)
+  inline void Encoder::set_string_parameter(const std::string& parameter_name, const std::string& value)
   {
     Error err = Error(heif_encoder_set_parameter_string(m_encoder.get(), parameter_name.c_str(), value.c_str()));
     if (err) {
@@ -1207,7 +1256,7 @@ namespace heif {
     }
   }
 
-  inline std::string Encoder::get_string_parameter(std::string parameter_name) const
+  inline std::string Encoder::get_string_parameter(const std::string& parameter_name) const
   {
     const int max_size = 250;
     char value[max_size];
@@ -1219,7 +1268,7 @@ namespace heif {
     return value;
   }
 
-  inline void Encoder::set_parameter(std::string parameter_name, std::string parameter_value)
+  inline void Encoder::set_parameter(const std::string& parameter_name, const std::string& parameter_value)
   {
     Error err = Error(heif_encoder_set_parameter(m_encoder.get(), parameter_name.c_str(),
                                                  parameter_value.c_str()));
@@ -1228,7 +1277,7 @@ namespace heif {
     }
   }
 
-  inline std::string Encoder::get_parameter(std::string parameter_name) const
+  inline std::string Encoder::get_parameter(const std::string& parameter_name) const
   {
     const int max_size = 250;
     char value[max_size];
diff --git a/libheif/api/libheif/heif_decoding.cc b/libheif/api/libheif/heif_decoding.cc
new file mode 100644
index 0000000000..23ffa9b44e
--- /dev/null
+++ b/libheif/api/libheif/heif_decoding.cc
@@ -0,0 +1,251 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017-2025 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "heif_decoding.h"
+#include "api_structs.h"
+#include "plugin_registry.h"
+
+#include <algorithm>
+#include <memory>
+#include <utility>
+#include <vector>
+
+
+void heif_context_set_max_decoding_threads(heif_context* ctx, int max_threads)
+{
+  ctx->context->set_max_decoding_threads(max_threads);
+}
+
+
+int heif_have_decoder_for_format(heif_compression_format format)
+{
+  auto plugin = get_decoder(format, nullptr);
+  return plugin != nullptr;
+}
+
+
+static void fill_default_decoding_options(heif_decoding_options& options)
+{
+  options.version = 8;
+
+  options.ignore_transformations = false;
+
+  options.start_progress = nullptr;
+  options.on_progress = nullptr;
+  options.end_progress = nullptr;
+  options.progress_user_data = nullptr;
+
+  // version 2
+
+  options.convert_hdr_to_8bit = false;
+
+  // version 3
+
+  options.strict_decoding = false;
+
+  // version 4
+
+  options.decoder_id = nullptr;
+
+  // version 5
+
+  options.color_conversion_options.version = 1;
+  options.color_conversion_options.preferred_chroma_downsampling_algorithm = heif_chroma_downsampling_average;
+  options.color_conversion_options.preferred_chroma_upsampling_algorithm = heif_chroma_upsampling_bilinear;
+  options.color_conversion_options.only_use_preferred_chroma_algorithm = false;
+
+  // version 6
+
+  options.cancel_decoding = nullptr;
+
+  // version 7
+
+  options.color_conversion_options_ext = nullptr;
+
+  // version 8
+
+  options.ignore_sequence_editlist = false;
+  options.output_image_nclx_profile = nullptr;
+  options.num_codec_threads = 0;
+  options.num_library_threads = 0;
+}
+
+
+heif_decoding_options* heif_decoding_options_alloc()
+{
+  auto options = new heif_decoding_options;
+
+  fill_default_decoding_options(*options);
+
+  return options;
+}
+
+
+// overwrite the (possibly lower version) input options over the default options
+void heif_decoding_options_copy(heif_decoding_options* dst,
+                                const heif_decoding_options* src)
+{
+  if (src == nullptr) {
+    return;
+  }
+
+  int min_version = std::min(dst->version, src->version);
+
+  switch (min_version) {
+    case 8:
+      dst->num_library_threads = src->num_library_threads;
+      dst->num_codec_threads = src->num_codec_threads;
+      dst->output_image_nclx_profile = src->output_image_nclx_profile;
+      dst->ignore_sequence_editlist = src->ignore_sequence_editlist;
+      [[fallthrough]];
+    case 7:
+      dst->color_conversion_options_ext = src->color_conversion_options_ext;
+      [[fallthrough]];
+    case 6:
+      dst->cancel_decoding = src->cancel_decoding;
+      [[fallthrough]];
+    case 5:
+      dst->color_conversion_options = src->color_conversion_options;
+      [[fallthrough]];
+    case 4:
+      dst->decoder_id = src->decoder_id;
+      [[fallthrough]];
+    case 3:
+      dst->strict_decoding = src->strict_decoding;
+      [[fallthrough]];
+    case 2:
+      dst->convert_hdr_to_8bit = src->convert_hdr_to_8bit;
+      [[fallthrough]];
+    case 1:
+      dst->ignore_transformations = src->ignore_transformations;
+      dst->start_progress = src->start_progress;
+      dst->on_progress = src->on_progress;
+      dst->end_progress = src->end_progress;
+      dst->progress_user_data = src->progress_user_data;
+  }
+}
+
+
+void heif_decoding_options_free(heif_decoding_options* options)
+{
+  delete options;
+}
+
+
+int heif_get_decoder_descriptors(heif_compression_format format_filter,
+                                 const heif_decoder_descriptor** out_decoders,
+                                 int count)
+{
+  struct decoder_with_priority
+  {
+    const heif_decoder_plugin* plugin;
+    int priority;
+  };
+
+  std::vector<decoder_with_priority> plugins;
+  std::vector<heif_compression_format> formats;
+  if (format_filter == heif_compression_undefined) {
+    formats = {heif_compression_HEVC, heif_compression_AV1, heif_compression_JPEG, heif_compression_JPEG2000, heif_compression_HTJ2K, heif_compression_VVC};
+  }
+  else {
+    formats.emplace_back(format_filter);
+  }
+
+  for (const auto* plugin : get_decoder_plugins()) {
+    for (auto& format : formats) {
+      int priority = plugin->does_support_format(format);
+      if (priority) {
+        plugins.push_back({plugin, priority});
+        break;
+      }
+    }
+  }
+
+  if (out_decoders == nullptr) {
+    return (int) plugins.size();
+  }
+
+  std::sort(plugins.begin(), plugins.end(), [](const decoder_with_priority& a, const decoder_with_priority& b) {
+    return a.priority > b.priority;
+  });
+
+  int nDecodersReturned = std::min(count, (int) plugins.size());
+
+  for (int i = 0; i < nDecodersReturned; i++) {
+    out_decoders[i] = (heif_decoder_descriptor*) (plugins[i].plugin);
+  }
+
+  return nDecodersReturned;
+}
+
+
+const char* heif_decoder_descriptor_get_name(const heif_decoder_descriptor* descriptor)
+{
+  auto decoder = (heif_decoder_plugin*) descriptor;
+  return decoder->get_plugin_name();
+}
+
+
+const char* heif_decoder_descriptor_get_id_name(const heif_decoder_descriptor* descriptor)
+{
+  auto decoder = (heif_decoder_plugin*) descriptor;
+  if (decoder->plugin_api_version < 3) {
+    return nullptr;
+  }
+  else {
+    return decoder->id_name;
+  }
+}
+
+
+heif_error heif_decode_image(const heif_image_handle* in_handle,
+                             heif_image** out_img,
+                             heif_colorspace colorspace,
+                             heif_chroma chroma,
+                             const heif_decoding_options* input_options)
+{
+  if (out_img == nullptr || in_handle == nullptr) {
+    return heif_error_null_pointer_argument;
+  }
+
+  *out_img = nullptr;
+  heif_item_id id = in_handle->image->get_id();
+
+  heif_decoding_options dec_options;
+  fill_default_decoding_options(dec_options);
+  heif_decoding_options_copy(&dec_options, input_options);
+
+  Result<std::shared_ptr<HeifPixelImage> > decodingResult = in_handle->context->decode_image(id,
+                                                                                             colorspace,
+                                                                                             chroma,
+                                                                                             dec_options,
+                                                                                             false, 0, 0, {});
+
+  if (!decodingResult) {
+    return decodingResult.error_struct(in_handle->image.get());
+  }
+
+  std::shared_ptr<HeifPixelImage> img = *decodingResult;
+
+  *out_img = new heif_image();
+  (*out_img)->image = std::move(img);
+
+  return Error::Ok.error_struct(in_handle->image.get());
+}
diff --git a/libheif/api/libheif/heif_decoding.h b/libheif/api/libheif/heif_decoding.h
new file mode 100644
index 0000000000..e580b16279
--- /dev/null
+++ b/libheif/api/libheif/heif_decoding.h
@@ -0,0 +1,172 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017-2025 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_HEIF_DECODING_H
+#define LIBHEIF_HEIF_DECODING_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <libheif/heif_library.h>
+#include <libheif/heif_image.h>
+#include <libheif/heif_context.h>
+#include <libheif/heif_color.h>
+
+
+// If the maximum threads number is set to 0, the image tiles are decoded in the main thread.
+// This is different from setting it to 1, which will generate a single background thread to decode the tiles.
+// Note that this setting only affects libheif itself. The codecs itself may still use multi-threaded decoding.
+// You can use it, for example, in cases where you are decoding several images in parallel anyway you thus want
+// to minimize parallelism in each decoder.
+LIBHEIF_API
+void heif_context_set_max_decoding_threads(heif_context* ctx, int max_threads);
+
+// Quick check whether there is a decoder available for the given format.
+// Note that the decoder still may not be able to decode all variants of that format.
+// You will have to query that further (todo) or just try to decode and check the returned error.
+LIBHEIF_API
+int heif_have_decoder_for_format(enum heif_compression_format format);
+
+
+typedef enum heif_progress_step
+{
+  heif_progress_step_total = 0,
+  heif_progress_step_load_tile = 1
+} heif_progress_step;
+
+
+typedef struct heif_decoding_options
+{
+  uint8_t version;
+
+  // version 1 options
+
+  // Ignore geometric transformations like cropping, rotation, mirroring.
+  // Default: false (do not ignore).
+  uint8_t ignore_transformations;
+
+  // Any of the progress functions may be called from background threads.
+  void (* start_progress)(enum heif_progress_step step, int max_progress, void* progress_user_data);
+
+  void (* on_progress)(enum heif_progress_step step, int progress, void* progress_user_data);
+
+  void (* end_progress)(enum heif_progress_step step, void* progress_user_data);
+
+  void* progress_user_data;
+
+  // version 2 options
+
+  uint8_t convert_hdr_to_8bit;
+
+  // version 3 options
+
+  // When enabled, an error is returned for invalid input. Otherwise, it will try its best and
+  // add decoding warnings to the decoded heif_image. Default is non-strict.
+  uint8_t strict_decoding;
+
+  // version 4 options
+
+  // name_id of the decoder to use for the decoding.
+  // If set to NULL (default), the highest priority decoder is chosen.
+  // The priority is defined in the plugin.
+  const char* decoder_id;
+
+  // version 5 options
+
+  heif_color_conversion_options color_conversion_options;
+
+  // version 6 options
+
+  int (* cancel_decoding)(void* progress_user_data);
+
+  // version 7 options
+
+  // When set to NULL, default options will be used
+  heif_color_conversion_options_ext* color_conversion_options_ext;
+
+  // version 8 options (v1.21.0)
+
+  // If enabled, it will decode the media timeline, ignoring the sequence tracks edit-list.
+  int ignore_sequence_editlist; // bool
+
+  heif_color_profile_nclx* output_image_nclx_profile;
+
+  int num_library_threads; // 0 = let libheif decide (TODO, currently ignored)
+  int num_codec_threads; // 0 = use decoder default
+} heif_decoding_options;
+
+
+// Allocate decoding options and fill with default values.
+// Note: you should always get the decoding options through this function since the
+// option structure may grow in size in future versions.
+LIBHEIF_API
+heif_decoding_options* heif_decoding_options_alloc(void);
+
+LIBHEIF_API
+void heif_decoding_options_copy(heif_decoding_options* dst,
+                                const heif_decoding_options* src);
+
+LIBHEIF_API
+void heif_decoding_options_free(heif_decoding_options*);
+
+
+typedef struct heif_decoder_descriptor heif_decoder_descriptor;
+
+// Get a list of available decoders. You can filter the encoders by compression format.
+// Use format_filter==heif_compression_undefined to get all available decoders.
+// The returned list of decoders is sorted by their priority (which is a plugin property).
+// The number of decoders is returned, which are not more than 'count' if (out_decoders != nullptr).
+// By setting out_decoders==nullptr, you can query the number of decoders, 'count' is ignored.
+LIBHEIF_API
+int heif_get_decoder_descriptors(enum heif_compression_format format_filter,
+                                 const heif_decoder_descriptor** out_decoders,
+                                 int count);
+
+// Return a long, descriptive name of the decoder (including version information).
+LIBHEIF_API
+const char* heif_decoder_descriptor_get_name(const heif_decoder_descriptor*);
+
+// Return a short, symbolic name for identifying the decoder.
+// This name should stay constant over different decoder versions.
+// Note: the returned ID may be NULL for old plugins that don't support this yet.
+LIBHEIF_API
+const char* heif_decoder_descriptor_get_id_name(const heif_decoder_descriptor*);
+
+
+// Decode an heif_image_handle into the actual pixel image and also carry out
+// all geometric transformations specified in the HEIF file (rotation, cropping, mirroring).
+//
+// If colorspace or chroma is set to heif_colorspace_undefined or heif_chroma_undefined,
+// respectively, the original colorspace is taken.
+// Decoding options may be NULL. If you want to supply options, always use
+// heif_decoding_options_alloc() to get the structure.
+LIBHEIF_API
+heif_error heif_decode_image(const heif_image_handle* in_handle,
+                             heif_image** out_img,
+                             enum heif_colorspace colorspace,
+                             enum heif_chroma chroma,
+                             const heif_decoding_options* options);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/libheif/api/libheif/heif_emscripten.h b/libheif/api/libheif/heif_emscripten.h
new file mode 100644
index 0000000000..256bab7c7c
--- /dev/null
+++ b/libheif/api/libheif/heif_emscripten.h
@@ -0,0 +1,606 @@
+#ifndef LIBHEIF_BOX_EMSCRIPTEN_H
+#define LIBHEIF_BOX_EMSCRIPTEN_H
+
+#include <emscripten/bind.h>
+#include <emscripten/version.h>
+
+#include <memory>
+#include <string>
+#include <sstream>
+#include <utility>
+#include <vector>
+#include <string.h>
+#include <cassert>
+
+#include "heif.h"
+#include "heif_items.h"
+
+static std::string heif_js_get_version()
+{
+  return heif_get_version();
+}
+
+static struct heif_error heif_js_context_read_from_memory(
+    struct heif_context* context, const std::string& data)
+{
+  return heif_context_read_from_memory(context, data.data(), data.size(), nullptr);
+}
+
+static heif_filetype_result heif_js_check_filetype(const std::string& data) 
+{
+  return heif_check_filetype((const uint8_t*) data.data(), data.size());
+}
+
+static emscripten::val heif_js_context_get_image_handle(
+    struct heif_context* context, heif_item_id id)
+{
+  emscripten::val result = emscripten::val::object();
+  if (!context) {
+    return result;
+  }
+
+  struct heif_image_handle* handle;
+  struct heif_error err = heif_context_get_image_handle(context, id, &handle);
+  if (err.code != heif_error_Ok) {
+    return emscripten::val(err);
+  }
+
+#if __EMSCRIPTEN_major__ > 4 ||   \
+    (__EMSCRIPTEN_major__ == 4 && \
+     (__EMSCRIPTEN_minor__ > 0 || __EMSCRIPTEN_tiny__ >= 9))
+  return emscripten::val(handle, emscripten::allow_raw_pointers());
+#else
+  return emscripten::val(handle);
+#endif
+}
+
+static emscripten::val heif_js_context_get_primary_image_handle(
+    struct heif_context* context)
+{
+  emscripten::val result = emscripten::val::object();
+  if (!context) {
+    return result;
+  }
+  
+  heif_image_handle* handle;
+  struct heif_error err = heif_context_get_primary_image_handle(context, &handle);
+
+  if (err.code != heif_error_Ok) {
+    return emscripten::val(err);
+  }
+
+#if __EMSCRIPTEN_major__ > 4 ||   \
+    (__EMSCRIPTEN_major__ == 4 && \
+     (__EMSCRIPTEN_minor__ > 0 || __EMSCRIPTEN_tiny__ >= 9))
+  return emscripten::val(handle, emscripten::allow_raw_pointers());
+#else
+  return emscripten::val(handle);
+#endif
+}
+
+
+static emscripten::val heif_js_context_get_list_of_top_level_image_IDs(
+    struct heif_context* context)
+{
+  emscripten::val result = emscripten::val::array();
+  if (!context) {
+    return result;
+  }
+
+  int count = heif_context_get_number_of_top_level_images(context);
+  if (count <= 0) {
+    return result;
+  }
+
+  heif_item_id* ids = (heif_item_id*) alloca(count * sizeof(heif_item_id));
+  if (!ids) {
+    struct heif_error err;
+    err.code = heif_error_Memory_allocation_error;
+    err.subcode = heif_suberror_Security_limit_exceeded;
+    return emscripten::val(err);
+  }
+
+  int received = heif_context_get_list_of_top_level_image_IDs(context, ids, count);
+  if (!received) {
+    free(ids);
+    return result;
+  }
+
+  for (int i = 0; i < received; i++) {
+    result.set(i, ids[i]);
+  }
+  return result;
+}
+
+
+static emscripten::val heif_js_context_get_list_of_item_IDs(
+    struct heif_context* context)
+{
+  emscripten::val result = emscripten::val::array();
+  if (!context) {
+    return result;
+  }
+
+  int count = heif_context_get_number_of_items(context);
+  if (count <= 0) {
+    return result;
+  }
+
+  heif_item_id* ids = (heif_item_id*) alloca(count * sizeof(heif_item_id));
+  if (!ids) {
+    struct heif_error err;
+    err.code = heif_error_Memory_allocation_error;
+    err.subcode = heif_suberror_Security_limit_exceeded;
+    return emscripten::val(err);
+  }
+
+  int num_ids_received = heif_context_get_list_of_item_IDs(context, ids, count);
+
+  for (int i = 0; i < num_ids_received; i++) {
+    result.set(i, ids[i]);
+  }
+
+  return result;
+}
+
+
+static emscripten::val heif_js_item_get_item_type(
+  const struct heif_context* ctx, heif_item_id id)
+{
+  uint32_t type = heif_item_get_item_type(ctx, id);
+  std::string type_string = fourcc_to_string(type);
+  return emscripten::val(type_string);
+}
+
+
+static emscripten::val heif_js_item_get_mime_item_content_type(
+  const struct heif_context* ctx, heif_item_id id)
+{
+  std::string content_type = "";
+  const char* cstring = heif_item_get_mime_item_content_type(ctx, id);
+  if (cstring) {
+    content_type = cstring;
+  }
+  return emscripten::val(content_type);
+}
+
+
+static emscripten::val heif_js_item_get_mime_item_content_encoding(
+  const struct heif_context* ctx, heif_item_id id)
+{
+  std::string content_encoding = "";
+  const char* cstring = heif_item_get_mime_item_content_encoding(ctx, id);
+  if (cstring) {
+    content_encoding = cstring;
+  }
+  return emscripten::val(content_encoding);
+}
+
+
+static emscripten::val heif_js_item_get_uri_item_uri_type(
+  const struct heif_context* ctx, heif_item_id id)
+{
+  std::string uri_type = "";
+  const char* cstring = heif_item_get_uri_item_uri_type(ctx, id);
+  if (cstring) {
+    uri_type = cstring;
+  }
+  return emscripten::val(uri_type);
+}
+
+
+static emscripten::val heif_js_item_get_item_name(
+  const struct heif_context* ctx, heif_item_id id)
+{
+  std::string item_name = "";
+  const char* cstring = heif_item_get_item_name(ctx, id);
+  if (cstring) {
+    item_name = cstring;
+  }
+  return emscripten::val(item_name);
+}
+
+
+#if 0
+static void strided_copy(void* dest, const void* src, int width, int height,
+                         int stride)
+{
+  if (width == stride) {
+    memcpy(dest, src, width * height);
+  }
+  else {
+    const uint8_t* _src = static_cast<const uint8_t*>(src);
+    uint8_t* _dest = static_cast<uint8_t*>(dest);
+    for (int y = 0; y < height; y++, _dest += width, _src += stride) {
+      memcpy(_dest, _src, width);
+    }
+  }
+}
+
+static int round_odd(int v) {
+  return (int) ((v / 2.0) + 0.5);
+}
+
+static emscripten::val heif_js_decode_image(struct heif_image_handle* handle,
+                                            enum heif_colorspace colorspace, enum heif_chroma chroma)
+{
+  emscripten::val result = emscripten::val::object();
+  if (!handle) {
+    return result;
+  }
+
+  struct heif_image* image;
+  struct heif_error err = heif_decode_image(handle, &image, colorspace, chroma, nullptr);
+  if (err.code != heif_error_Ok) {
+    return emscripten::val(err);
+  }
+
+  result.set("is_primary", heif_image_handle_is_primary_image(handle));
+  result.set("thumbnails", heif_image_handle_get_number_of_thumbnails(handle));
+  int width = heif_image_handle_get_width(handle);
+  result.set("width", width);
+  int height = heif_image_handle_get_height(handle);
+  result.set("height", height);
+  std::vector<unsigned char> data;
+  result.set("chroma", heif_image_get_chroma_format(image));
+  result.set("colorspace", heif_image_get_colorspace(image));
+  switch (heif_image_get_colorspace(image)) {
+    case heif_colorspace_YCbCr: {
+      size_t stride_y;
+      const uint8_t* plane_y = heif_image_get_plane_readonly2(image,
+                                                              heif_channel_Y, &stride_y);
+      size_t stride_u;
+      const uint8_t* plane_u = heif_image_get_plane_readonly2(image,
+                                                              heif_channel_Cb, &stride_u);
+      size_t stride_v;
+      const uint8_t* plane_v = heif_image_get_plane_readonly2(image,
+                                                              heif_channel_Cr, &stride_v);
+      data.resize((width * height) + (2 * round_odd(width) * round_odd(height)));
+      unsigned char* dest = const_cast<unsigned char*>(data.data());
+      strided_copy(dest, plane_y, width, height, stride_y);
+      strided_copy(dest + (width * height), plane_u,
+                   round_odd(width), round_odd(height), stride_u);
+      strided_copy(dest + (width * height) + (round_odd(width) * round_odd(height)),
+                   plane_v, round_odd(width), round_odd(height), stride_v);
+    }
+      break;
+    case heif_colorspace_RGB: {
+      if(heif_image_get_chroma_format(image) == heif_chroma_interleaved_RGB) {
+        size_t stride_rgb;
+        const uint8_t* plane_rgb = heif_image_get_plane_readonly2(image,
+                                                                  heif_channel_interleaved, &stride_rgb);
+        data.resize(width * height * 3);
+        unsigned char* dest = const_cast<unsigned char*>(data.data());
+        strided_copy(dest, plane_rgb, width * 3, height, stride_rgb);
+      }
+      else if (heif_image_get_chroma_format(image) == heif_chroma_interleaved_RGBA) {
+        size_t stride_rgba;
+        const uint8_t* plane_rgba = heif_image_get_plane_readonly2(image,
+                                                                   heif_channel_interleaved, &stride_rgba);
+        data.resize(width * height * 4);
+        unsigned char* dest = const_cast<unsigned char*>(data.data());
+        strided_copy(dest, plane_rgba, width * 4, height, stride_rgba);
+      }
+      else {
+        assert(false);
+      }
+    }
+      break;
+    case heif_colorspace_monochrome: {
+      assert(heif_image_get_chroma_format(image) ==
+             heif_chroma_monochrome);
+      size_t stride_grey;
+      const uint8_t* plane_grey = heif_image_get_plane_readonly2(image,
+                                                                 heif_channel_Y, &stride_grey);
+      data.resize(width * height);
+      unsigned char* dest = const_cast<unsigned char*>(data.data());
+      strided_copy(dest, plane_grey, width, height, stride_grey);
+    }
+      break;
+    default:
+      // Should never reach here.
+      break;
+  }
+  result.set("data", std::move(data));
+
+  if (heif_image_has_channel(image, heif_channel_Alpha)) {
+    std::vector<unsigned char> alpha;
+    size_t stride_alpha;
+    const uint8_t* plane_alpha = heif_image_get_plane_readonly2(image, heif_channel_Alpha, &stride_alpha);
+    alpha.resize(width * height);
+    unsigned char* dest = const_cast<unsigned char*>(alpha.data());
+    strided_copy(dest, plane_alpha, width, height, stride_alpha);
+    result.set("alpha", std::move(alpha));
+  }
+
+  heif_image_release(image);
+  return result;
+}
+#endif
+
+/*
+ * The returned object includes a pointer to an heif_image in the property "image".
+ * This image has to be released after the image data has been read (copied) with heif_image_release().
+ */
+static emscripten::val heif_js_decode_image2(struct heif_image_handle* handle,
+                                             enum heif_colorspace colorspace, enum heif_chroma chroma)
+{
+  emscripten::val result = emscripten::val::object();
+  if (!handle) {
+    return result;
+  }
+
+  struct heif_image* image;
+  struct heif_error err = heif_decode_image(handle, &image, colorspace, chroma, nullptr);
+  if (err.code != heif_error_Ok) {
+    return emscripten::val(err);
+  }
+
+#if __EMSCRIPTEN_major__ > 4 ||   \
+    (__EMSCRIPTEN_major__ == 4 && \
+     (__EMSCRIPTEN_minor__ > 0 || __EMSCRIPTEN_tiny__ >= 9))
+  result.set("image", image, emscripten::allow_raw_pointers());
+#else
+  result.set("image", image);
+#endif
+
+  int width = heif_image_handle_get_width(handle);
+  result.set("width", width);
+
+  int height = heif_image_handle_get_height(handle);
+  result.set("height", height);
+
+  std::vector<unsigned char> data;
+  result.set("chroma", heif_image_get_chroma_format(image));
+  result.set("colorspace", heif_image_get_colorspace(image));
+
+  std::vector<heif_channel> channels {
+    heif_channel_Y,
+    heif_channel_Cb,
+    heif_channel_Cr,
+    heif_channel_R,
+    heif_channel_G,
+    heif_channel_B,
+    heif_channel_Alpha,
+    heif_channel_interleaved
+  };
+
+  emscripten::val val_channels = emscripten::val::array();
+
+  for (auto channel : channels) {
+    if (heif_image_has_channel(image, channel)) {
+      emscripten::val val_channel_info = emscripten::val::object();
+      val_channel_info.set("id", channel);
+
+      size_t stride;
+      const uint8_t* plane = heif_image_get_plane_readonly2(image, channel, &stride);
+
+      val_channel_info.set("stride", stride);
+      val_channel_info.set("data", emscripten::val(emscripten::typed_memory_view(stride * height, plane)));
+
+      val_channel_info.set("width", heif_image_get_width(image, channel));
+      val_channel_info.set("height", heif_image_get_height(image, channel));
+
+      val_channel_info.set("bits_per_pixel", heif_image_get_bits_per_pixel_range(image, channel));
+
+      val_channels.call<void>("push", val_channel_info);
+    }
+  }
+
+  result.set("channels", val_channels);
+
+  return result;
+}
+
+
+#define EXPORT_HEIF_FUNCTION(name) \
+  emscripten::function(#name, &name, emscripten::allow_raw_pointers())
+
+EMSCRIPTEN_BINDINGS(libheif) {
+  
+    // heif.h
+    emscripten::function("heif_get_version", &heif_js_get_version, emscripten::allow_raw_pointers());
+    emscripten::function("heif_context_read_from_memory", &heif_js_context_read_from_memory, emscripten::allow_raw_pointers());
+    emscripten::function("heif_check_filetype", &heif_js_check_filetype, emscripten::allow_raw_pointers());
+    emscripten::function("heif_context_get_list_of_top_level_image_IDs", &heif_js_context_get_list_of_top_level_image_IDs, emscripten::allow_raw_pointers());
+    emscripten::function("heif_context_get_image_handle", &heif_js_context_get_image_handle, emscripten::allow_raw_pointers());
+    emscripten::function("heif_context_get_primary_image_handle", &heif_js_context_get_primary_image_handle, emscripten::allow_raw_pointers());
+    emscripten::function("heif_js_decode_image2", &heif_js_decode_image2, emscripten::allow_raw_pointers());
+    EXPORT_HEIF_FUNCTION(heif_get_version_number);
+    EXPORT_HEIF_FUNCTION(heif_context_alloc);
+    EXPORT_HEIF_FUNCTION(heif_context_free);
+    EXPORT_HEIF_FUNCTION(heif_context_get_number_of_top_level_images);
+    EXPORT_HEIF_FUNCTION(heif_image_handle_release);
+    EXPORT_HEIF_FUNCTION(heif_image_handle_get_width);
+    EXPORT_HEIF_FUNCTION(heif_image_handle_get_height);
+    EXPORT_HEIF_FUNCTION(heif_image_handle_is_primary_image);
+    EXPORT_HEIF_FUNCTION(heif_image_release);
+    EXPORT_HEIF_FUNCTION(heif_image_handle_has_alpha_channel);
+    EXPORT_HEIF_FUNCTION(heif_image_handle_is_premultiplied_alpha);
+
+    // heif_items.h
+    emscripten::function("heif_context_get_list_of_item_IDs", &heif_js_context_get_list_of_item_IDs, emscripten::allow_raw_pointers());
+    emscripten::function("heif_item_get_item_type", heif_js_item_get_item_type, emscripten::allow_raw_pointers());
+    emscripten::function("heif_item_get_mime_item_content_type", heif_js_item_get_mime_item_content_type, emscripten::allow_raw_pointers());
+    emscripten::function("heif_item_get_mime_item_content_encoding", heif_js_item_get_mime_item_content_encoding, emscripten::allow_raw_pointers());
+    emscripten::function("heif_item_get_uri_item_uri_type", heif_js_item_get_uri_item_uri_type, emscripten::allow_raw_pointers());
+    emscripten::function("heif_item_get_item_name", heif_js_item_get_item_name, emscripten::allow_raw_pointers());
+    EXPORT_HEIF_FUNCTION(heif_context_get_number_of_items);
+    EXPORT_HEIF_FUNCTION(heif_item_is_item_hidden);
+
+    // DEPRECATED, use functions without the 'js' prefix.
+    emscripten::function("heif_js_check_filetype", &heif_js_check_filetype, emscripten::allow_raw_pointers());
+    emscripten::function("heif_js_context_get_list_of_top_level_image_IDs", &heif_js_context_get_list_of_top_level_image_IDs, emscripten::allow_raw_pointers());
+    emscripten::function("heif_js_context_get_image_handle", &heif_js_context_get_image_handle, emscripten::allow_raw_pointers());
+    emscripten::function("heif_js_context_get_primary_image_handle", &heif_js_context_get_primary_image_handle, emscripten::allow_raw_pointers());
+
+    emscripten::enum_<heif_error_code>("heif_error_code")
+    .value("heif_error_Ok", heif_error_Ok)
+    .value("heif_error_Input_does_not_exist", heif_error_Input_does_not_exist)
+    .value("heif_error_Invalid_input", heif_error_Invalid_input)
+    .value("heif_error_Plugin_loading_error", heif_error_Plugin_loading_error)
+    .value("heif_error_Unsupported_filetype", heif_error_Unsupported_filetype)
+    .value("heif_error_Unsupported_feature", heif_error_Unsupported_feature)
+    .value("heif_error_Usage_error", heif_error_Usage_error)
+    .value("heif_error_Memory_allocation_error", heif_error_Memory_allocation_error)
+    .value("heif_error_Decoder_plugin_error", heif_error_Decoder_plugin_error)
+    .value("heif_error_Encoder_plugin_error", heif_error_Encoder_plugin_error)
+    .value("heif_error_Encoding_error", heif_error_Encoding_error)
+    .value("heif_error_End_of_sequence", heif_error_End_of_sequence)
+    .value("heif_error_Color_profile_does_not_exist", heif_error_Color_profile_does_not_exist)
+    .value("heif_error_Canceled", heif_error_Canceled);
+    emscripten::enum_<heif_suberror_code>("heif_suberror_code")
+    .value("heif_suberror_Unspecified", heif_suberror_Unspecified)
+    .value("heif_suberror_Cannot_write_output_data", heif_suberror_Cannot_write_output_data)
+    .value("heif_suberror_Compression_initialisation_error", heif_suberror_Compression_initialisation_error)
+    .value("heif_suberror_Decompression_invalid_data", heif_suberror_Decompression_invalid_data)
+    .value("heif_suberror_Encoder_initialization", heif_suberror_Encoder_initialization)
+    .value("heif_suberror_Encoder_encoding", heif_suberror_Encoder_encoding)
+    .value("heif_suberror_Encoder_cleanup", heif_suberror_Encoder_cleanup)
+    .value("heif_suberror_Too_many_regions", heif_suberror_Too_many_regions)
+    .value("heif_suberror_End_of_data", heif_suberror_End_of_data)
+    .value("heif_suberror_Invalid_box_size", heif_suberror_Invalid_box_size)
+    .value("heif_suberror_No_ftyp_box", heif_suberror_No_ftyp_box)
+    .value("heif_suberror_No_idat_box", heif_suberror_No_idat_box)
+    .value("heif_suberror_No_meta_box", heif_suberror_No_meta_box)
+    .value("heif_suberror_No_moov_box", heif_suberror_No_moov_box)
+    .value("heif_suberror_No_hdlr_box", heif_suberror_No_hdlr_box)
+    .value("heif_suberror_No_hvcC_box", heif_suberror_No_hvcC_box)
+    .value("heif_suberror_No_vvcC_box", heif_suberror_No_vvcC_box)
+    .value("heif_suberror_No_pitm_box", heif_suberror_No_pitm_box)
+    .value("heif_suberror_No_ipco_box", heif_suberror_No_ipco_box)
+    .value("heif_suberror_No_ipma_box", heif_suberror_No_ipma_box)
+    .value("heif_suberror_No_iloc_box", heif_suberror_No_iloc_box)
+    .value("heif_suberror_No_iinf_box", heif_suberror_No_iinf_box)
+    .value("heif_suberror_No_iprp_box", heif_suberror_No_iprp_box)
+    .value("heif_suberror_No_iref_box", heif_suberror_No_iref_box)
+    .value("heif_suberror_No_pict_handler", heif_suberror_No_pict_handler)
+    .value("heif_suberror_Ipma_box_references_nonexisting_property", heif_suberror_Ipma_box_references_nonexisting_property)
+    .value("heif_suberror_No_properties_assigned_to_item", heif_suberror_No_properties_assigned_to_item)
+    .value("heif_suberror_No_item_data", heif_suberror_No_item_data)
+    .value("heif_suberror_Invalid_grid_data", heif_suberror_Invalid_grid_data)
+    .value("heif_suberror_Missing_grid_images", heif_suberror_Missing_grid_images)
+    .value("heif_suberror_No_av1C_box", heif_suberror_No_av1C_box)
+    .value("heif_suberror_No_avcC_box", heif_suberror_No_avcC_box)
+    .value("heif_suberror_Invalid_mini_box", heif_suberror_Invalid_mini_box)
+    .value("heif_suberror_Invalid_clean_aperture", heif_suberror_Invalid_clean_aperture)
+    .value("heif_suberror_Invalid_overlay_data", heif_suberror_Invalid_overlay_data)
+    .value("heif_suberror_Overlay_image_outside_of_canvas", heif_suberror_Overlay_image_outside_of_canvas)
+    .value("heif_suberror_Plugin_is_not_loaded", heif_suberror_Plugin_is_not_loaded)
+    .value("heif_suberror_Plugin_loading_error", heif_suberror_Plugin_loading_error)
+    .value("heif_suberror_Auxiliary_image_type_unspecified", heif_suberror_Auxiliary_image_type_unspecified)
+    .value("heif_suberror_Cannot_read_plugin_directory", heif_suberror_Cannot_read_plugin_directory)
+    .value("heif_suberror_No_matching_decoder_installed", heif_suberror_No_matching_decoder_installed)
+    .value("heif_suberror_No_or_invalid_primary_item", heif_suberror_No_or_invalid_primary_item)
+    .value("heif_suberror_No_infe_box", heif_suberror_No_infe_box)
+    .value("heif_suberror_Security_limit_exceeded", heif_suberror_Security_limit_exceeded)
+    .value("heif_suberror_Unknown_color_profile_type", heif_suberror_Unknown_color_profile_type)
+    .value("heif_suberror_Wrong_tile_image_chroma_format", heif_suberror_Wrong_tile_image_chroma_format)
+    .value("heif_suberror_Invalid_fractional_number", heif_suberror_Invalid_fractional_number)
+    .value("heif_suberror_Invalid_image_size", heif_suberror_Invalid_image_size)
+    .value("heif_suberror_Nonexisting_item_referenced", heif_suberror_Nonexisting_item_referenced)
+    .value("heif_suberror_Null_pointer_argument", heif_suberror_Null_pointer_argument)
+    .value("heif_suberror_Nonexisting_image_channel_referenced", heif_suberror_Nonexisting_image_channel_referenced)
+    .value("heif_suberror_Unsupported_plugin_version", heif_suberror_Unsupported_plugin_version)
+    .value("heif_suberror_Unsupported_writer_version", heif_suberror_Unsupported_writer_version)
+    .value("heif_suberror_Unsupported_parameter", heif_suberror_Unsupported_parameter)
+    .value("heif_suberror_Invalid_parameter_value", heif_suberror_Invalid_parameter_value)
+    .value("heif_suberror_Invalid_property", heif_suberror_Invalid_property)
+    .value("heif_suberror_Item_reference_cycle", heif_suberror_Item_reference_cycle)
+    .value("heif_suberror_Invalid_pixi_box", heif_suberror_Invalid_pixi_box)
+    .value("heif_suberror_Invalid_region_data", heif_suberror_Invalid_region_data)
+    .value("heif_suberror_Unsupported_codec", heif_suberror_Unsupported_codec)
+    .value("heif_suberror_Unsupported_image_type", heif_suberror_Unsupported_image_type)
+    .value("heif_suberror_Unsupported_data_version", heif_suberror_Unsupported_data_version)
+    .value("heif_suberror_Unsupported_generic_compression_method", heif_suberror_Unsupported_generic_compression_method)
+    .value("heif_suberror_Unsupported_essential_property", heif_suberror_Unsupported_essential_property)
+    .value("heif_suberror_Unsupported_color_conversion", heif_suberror_Unsupported_color_conversion)
+    .value("heif_suberror_Unsupported_item_construction_method", heif_suberror_Unsupported_item_construction_method)
+    .value("heif_suberror_Unsupported_header_compression_method", heif_suberror_Unsupported_header_compression_method)
+    .value("heif_suberror_Unsupported_bit_depth", heif_suberror_Unsupported_bit_depth)
+    .value("heif_suberror_Unsupported_track_type", heif_suberror_Unsupported_track_type)
+    .value("heif_suberror_Wrong_tile_image_pixel_depth", heif_suberror_Wrong_tile_image_pixel_depth)
+    .value("heif_suberror_Unknown_NCLX_color_primaries", heif_suberror_Unknown_NCLX_color_primaries)
+    .value("heif_suberror_Unknown_NCLX_transfer_characteristics", heif_suberror_Unknown_NCLX_transfer_characteristics)
+    .value("heif_suberror_Unknown_NCLX_matrix_coefficients", heif_suberror_Unknown_NCLX_matrix_coefficients)
+    .value("heif_suberror_No_ispe_property", heif_suberror_No_ispe_property)
+    .value("heif_suberror_Camera_intrinsic_matrix_undefined", heif_suberror_Camera_intrinsic_matrix_undefined)
+    .value("heif_suberror_Camera_extrinsic_matrix_undefined", heif_suberror_Camera_extrinsic_matrix_undefined)
+    .value("heif_suberror_Invalid_J2K_codestream", heif_suberror_Invalid_J2K_codestream)
+    .value("heif_suberror_No_icbr_box", heif_suberror_No_icbr_box);
+
+    emscripten::enum_<heif_compression_format>("heif_compression_format")
+    .value("heif_compression_undefined", heif_compression_undefined)
+    .value("heif_compression_HEVC", heif_compression_HEVC)
+    .value("heif_compression_AVC", heif_compression_AVC)
+    .value("heif_compression_JPEG", heif_compression_JPEG)
+    .value("heif_compression_AV1", heif_compression_AV1)
+    .value("heif_compression_VVC", heif_compression_VVC)
+    .value("heif_compression_EVC", heif_compression_EVC)
+    .value("heif_compression_JPEG2000", heif_compression_JPEG2000)
+    .value("heif_compression_uncompressed", heif_compression_uncompressed)
+    .value("heif_compression_mask", heif_compression_mask)
+    .value("heif_compression_HTJ2K", heif_compression_HTJ2K);
+    emscripten::enum_<heif_chroma>("heif_chroma")
+    .value("heif_chroma_undefined", heif_chroma_undefined)
+    .value("heif_chroma_monochrome", heif_chroma_monochrome)
+    .value("heif_chroma_420", heif_chroma_420)
+    .value("heif_chroma_422", heif_chroma_422)
+    .value("heif_chroma_444", heif_chroma_444)
+    .value("heif_chroma_interleaved_RGB", heif_chroma_interleaved_RGB)
+    .value("heif_chroma_interleaved_RGBA", heif_chroma_interleaved_RGBA)
+    .value("heif_chroma_interleaved_RRGGBB_BE", heif_chroma_interleaved_RRGGBB_BE)
+    .value("heif_chroma_interleaved_RRGGBBAA_BE", heif_chroma_interleaved_RRGGBBAA_BE)
+    .value("heif_chroma_interleaved_RRGGBB_LE", heif_chroma_interleaved_RRGGBB_LE)
+    .value("heif_chroma_interleaved_RRGGBBAA_LE", heif_chroma_interleaved_RRGGBBAA_LE)
+    // Aliases
+    .value("heif_chroma_interleaved_24bit", heif_chroma_interleaved_24bit)
+    .value("heif_chroma_interleaved_32bit", heif_chroma_interleaved_32bit);
+    emscripten::enum_<heif_chroma_downsampling_algorithm>("heif_chroma_downsampling_algorithm")
+    .value("heif_chroma_downsampling_average", heif_chroma_downsampling_average)
+    .value("heif_chroma_downsampling_nearest_neighbor", heif_chroma_downsampling_nearest_neighbor)
+    .value("heif_chroma_downsampling_sharp_yuv", heif_chroma_downsampling_sharp_yuv);
+    emscripten::enum_<heif_chroma_upsampling_algorithm>("heif_chroma_upsampling_algorithm")
+    .value("heif_chroma_upsampling_bilinear", heif_chroma_upsampling_bilinear)
+    .value("heif_chroma_upsampling_nearest_neighbor", heif_chroma_upsampling_nearest_neighbor);
+    emscripten::enum_<heif_colorspace>("heif_colorspace")
+    .value("heif_colorspace_undefined", heif_colorspace_undefined)
+    .value("heif_colorspace_YCbCr", heif_colorspace_YCbCr)
+    .value("heif_colorspace_RGB", heif_colorspace_RGB)
+    .value("heif_colorspace_monochrome", heif_colorspace_monochrome)
+    .value("heif_colorspace_filter_array", heif_colorspace_filter_array)
+    .value("heif_colorspace_nonvisual", heif_colorspace_nonvisual);
+    emscripten::enum_<heif_channel>("heif_channel")
+    .value("heif_channel_Y", heif_channel_Y)
+    .value("heif_channel_Cr", heif_channel_Cr)
+    .value("heif_channel_Cb", heif_channel_Cb)
+    .value("heif_channel_R", heif_channel_R)
+    .value("heif_channel_G", heif_channel_G)
+    .value("heif_channel_B", heif_channel_B)
+    .value("heif_channel_Alpha", heif_channel_Alpha)
+    .value("heif_channel_interleaved", heif_channel_interleaved)
+    .value("heif_channel_filter_array", heif_channel_filter_array)
+    .value("heif_channel_depth", heif_channel_depth)
+    .value("heif_channel_disparity", heif_channel_disparity)
+    .value("heif_channel_unknown", heif_channel_unknown);
+
+    emscripten::enum_<heif_filetype_result>("heif_filetype_result")
+    .value("heif_filetype_no", heif_filetype_no)
+    .value("heif_filetype_yes_supported", heif_filetype_yes_supported)
+    .value("heif_filetype_yes_unsupported", heif_filetype_yes_unsupported)
+    .value("heif_filetype_maybe", heif_filetype_maybe);
+
+    emscripten::class_<heif_context>("heif_context");
+    emscripten::class_<heif_image_handle>("heif_image_handle");
+    emscripten::class_<heif_image>("heif_image");
+    emscripten::value_object<heif_error>("heif_error")
+    .field("code", &heif_error::code)
+    .field("subcode", &heif_error::subcode)
+    .field("message", emscripten::optional_override([](const struct heif_error& err) {
+        return std::string(err.message);
+    }), emscripten::optional_override([](struct heif_error& err, const std::string& value) {
+        err.message = value.c_str();
+    }));
+}
+
+#endif  // LIBHEIF_BOX_EMSCRIPTEN_H
diff --git a/libheif/api/libheif/heif_encoding.cc b/libheif/api/libheif/heif_encoding.cc
new file mode 100644
index 0000000000..77afd37968
--- /dev/null
+++ b/libheif/api/libheif/heif_encoding.cc
@@ -0,0 +1,845 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017-2025 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "heif_encoding.h"
+#include "api_structs.h"
+#include "context.h"
+#include "init.h"
+#include "plugin_registry.h"
+#include "image-items/overlay.h"
+#include "image-items/tiled.h"
+#include "image-items/grid.h"
+
+#include <cstring>
+
+#include <vector>
+#include <string>
+#include <algorithm>
+#include <memory>
+#include <utility>
+
+
+static heif_error error_unsupported_parameter = {
+  heif_error_Usage_error,
+  heif_suberror_Unsupported_parameter,
+  "Unsupported encoder parameter"
+};
+static heif_error error_invalid_parameter_value = {
+  heif_error_Usage_error,
+  heif_suberror_Invalid_parameter_value,
+  "Invalid parameter value"
+};
+
+
+int heif_have_encoder_for_format(heif_compression_format format)
+{
+  auto plugin = get_encoder(format);
+  return plugin != nullptr;
+}
+
+
+int heif_get_encoder_descriptors(heif_compression_format format,
+                                 const char* name,
+                                 const heif_encoder_descriptor** out_encoder_descriptors,
+                                 int count)
+{
+  if (out_encoder_descriptors != nullptr && count <= 0) {
+    return 0;
+  }
+
+  std::vector<const heif_encoder_descriptor*> descriptors;
+  descriptors = get_filtered_encoder_descriptors(format, name);
+
+  if (out_encoder_descriptors == nullptr) {
+    return static_cast<int>(descriptors.size());
+  }
+
+  int i;
+  for (i = 0; i < count && static_cast<size_t>(i) < descriptors.size(); i++) {
+    out_encoder_descriptors[i] = descriptors[i];
+  }
+
+  return i;
+}
+
+
+const char* heif_encoder_descriptor_get_name(const heif_encoder_descriptor* descriptor)
+{
+  return descriptor->plugin->get_plugin_name();
+}
+
+
+const char* heif_encoder_descriptor_get_id_name(const heif_encoder_descriptor* descriptor)
+{
+  return descriptor->plugin->id_name;
+}
+
+
+heif_compression_format
+heif_encoder_descriptor_get_compression_format(const heif_encoder_descriptor* descriptor)
+{
+  return descriptor->plugin->compression_format;
+}
+
+
+int heif_encoder_descriptor_supports_lossy_compression(const heif_encoder_descriptor* descriptor)
+{
+  return descriptor->plugin->supports_lossy_compression;
+}
+
+
+int heif_encoder_descriptor_supports_lossless_compression(const heif_encoder_descriptor* descriptor)
+{
+  return descriptor->plugin->supports_lossless_compression;
+}
+
+
+heif_error heif_context_get_encoder(heif_context* context,
+                                    const heif_encoder_descriptor* descriptor,
+                                    heif_encoder** encoder)
+{
+  // Note: be aware that context may be NULL as we explicitly allowed that in an earlier documentation.
+
+  if (!descriptor || !encoder) {
+    return heif_error_null_pointer_argument;
+  }
+
+  *encoder = new heif_encoder(descriptor->plugin);
+  return (*encoder)->alloc();
+}
+
+
+heif_error heif_context_get_encoder_for_format(heif_context* context,
+                                               heif_compression_format format,
+                                               heif_encoder** encoder)
+{
+  // Note: be aware that context may be NULL as we explicitly allowed that in an earlier documentation.
+
+  if (!encoder) {
+    return heif_error_null_pointer_argument;
+  }
+
+  std::vector<const heif_encoder_descriptor*> descriptors;
+  descriptors = get_filtered_encoder_descriptors(format, nullptr);
+
+  if (descriptors.size() > 0) {
+    *encoder = new heif_encoder(descriptors[0]->plugin);
+    return (*encoder)->alloc();
+  }
+  else {
+    *encoder = nullptr;
+    Error err(heif_error_Unsupported_filetype, // TODO: is this the right error code?
+              heif_suberror_Unspecified);
+    return err.error_struct(context ? context->context.get() : nullptr);
+  }
+}
+
+
+void heif_encoder_release(heif_encoder* encoder)
+{
+  if (encoder) {
+    delete encoder;
+  }
+}
+
+
+const char* heif_encoder_get_name(const heif_encoder* encoder)
+{
+  return encoder->plugin->get_plugin_name();
+}
+
+
+// Set a 'quality' factor (0-100). How this is mapped to actual encoding parameters is
+// encoder dependent.
+heif_error heif_encoder_set_lossy_quality(heif_encoder* encoder,
+                                          int quality)
+{
+  if (!encoder) {
+    return heif_error_null_pointer_argument;
+  }
+
+  return encoder->plugin->set_parameter_quality(encoder->encoder, quality);
+}
+
+
+heif_error heif_encoder_set_lossless(heif_encoder* encoder, int enable)
+{
+  if (!encoder) {
+    return heif_error_null_pointer_argument;
+  }
+
+  return encoder->plugin->set_parameter_lossless(encoder->encoder, enable);
+}
+
+
+heif_error heif_encoder_set_logging_level(heif_encoder* encoder, int level)
+{
+  if (!encoder) {
+    return heif_error_null_pointer_argument;
+  }
+
+  if (encoder->plugin->set_parameter_logging_level) {
+    return encoder->plugin->set_parameter_logging_level(encoder->encoder, level);
+  }
+
+  return heif_error_success;
+}
+
+
+const heif_encoder_parameter* const* heif_encoder_list_parameters(heif_encoder* encoder)
+{
+  return encoder->plugin->list_parameters(encoder->encoder);
+}
+
+
+const char* heif_encoder_parameter_get_name(const heif_encoder_parameter* param)
+{
+  return param->name;
+}
+
+heif_encoder_parameter_type
+heif_encoder_parameter_get_type(const heif_encoder_parameter* param)
+{
+  return param->type;
+}
+
+
+heif_error
+heif_encoder_parameter_get_valid_integer_range(const heif_encoder_parameter* param,
+                                               int* have_minimum_maximum,
+                                               int* minimum, int* maximum)
+{
+  if (param->type != heif_encoder_parameter_type_integer) {
+    return error_unsupported_parameter; // TODO: correct error ?
+  }
+
+  if (param->integer.have_minimum_maximum) {
+    if (minimum) {
+      *minimum = param->integer.minimum;
+    }
+
+    if (maximum) {
+      *maximum = param->integer.maximum;
+    }
+  }
+
+  if (have_minimum_maximum) {
+    *have_minimum_maximum = param->integer.have_minimum_maximum;
+  }
+
+  return heif_error_success;
+}
+
+
+heif_error heif_encoder_parameter_get_valid_integer_values(const heif_encoder_parameter* param,
+                                                           int* have_minimum, int* have_maximum,
+                                                           int* minimum, int* maximum,
+                                                           int* num_valid_values,
+                                                           const int** out_integer_array)
+{
+  if (param->type != heif_encoder_parameter_type_integer) {
+    return error_unsupported_parameter; // TODO: correct error ?
+  }
+
+
+  // --- range of values
+
+  if (param->integer.have_minimum_maximum) {
+    if (minimum) {
+      *minimum = param->integer.minimum;
+    }
+
+    if (maximum) {
+      *maximum = param->integer.maximum;
+    }
+  }
+
+  if (have_minimum) {
+    *have_minimum = param->integer.have_minimum_maximum;
+  }
+
+  if (have_maximum) {
+    *have_maximum = param->integer.have_minimum_maximum;
+  }
+
+
+  // --- set of valid values
+
+  if (param->integer.num_valid_values > 0) {
+    if (out_integer_array) {
+      *out_integer_array = param->integer.valid_values;
+    }
+  }
+
+  if (num_valid_values) {
+    *num_valid_values = param->integer.num_valid_values;
+  }
+
+  return heif_error_success;
+}
+
+
+heif_error
+heif_encoder_parameter_get_valid_string_values(const heif_encoder_parameter* param,
+                                               const char* const** out_stringarray)
+{
+  if (param->type != heif_encoder_parameter_type_string) {
+    return error_unsupported_parameter; // TODO: correct error ?
+  }
+
+  if (out_stringarray) {
+    *out_stringarray = param->string.valid_values;
+  }
+
+  return heif_error_success;
+}
+
+
+heif_error heif_encoder_set_parameter_integer(heif_encoder* encoder,
+                                              const char* parameter_name,
+                                              int value)
+{
+  // --- check if parameter is valid
+
+  for (const heif_encoder_parameter* const* params = heif_encoder_list_parameters(encoder);
+       *params;
+       params++) {
+    if (strcmp((*params)->name, parameter_name) == 0) {
+      int have_minimum = 0, have_maximum = 0, minimum = 0, maximum = 0, num_valid_values = 0;
+      const int* valid_values = nullptr;
+      heif_error err = heif_encoder_parameter_get_valid_integer_values((*params), &have_minimum, &have_maximum,
+                                                                       &minimum, &maximum,
+                                                                       &num_valid_values,
+                                                                       &valid_values);
+      if (err.code) {
+        return err;
+      }
+
+      if ((have_minimum && value < minimum) ||
+          (have_maximum && value > maximum)) {
+        return error_invalid_parameter_value;
+      }
+
+      if (num_valid_values > 0) {
+        bool found = false;
+        for (int i = 0; i < num_valid_values; i++) {
+          if (valid_values[i] == value) {
+            found = true;
+            break;
+          }
+        }
+
+        if (!found) {
+          return error_invalid_parameter_value;
+        }
+      }
+    }
+  }
+
+
+  // --- parameter is ok, pass it to the encoder plugin
+
+  return encoder->plugin->set_parameter_integer(encoder->encoder, parameter_name, value);
+}
+
+heif_error heif_encoder_get_parameter_integer(heif_encoder* encoder,
+                                              const char* parameter_name,
+                                              int* value_ptr)
+{
+  return encoder->plugin->get_parameter_integer(encoder->encoder, parameter_name, value_ptr);
+}
+
+
+heif_error heif_encoder_parameter_integer_valid_range(heif_encoder* encoder,
+                                                      const char* parameter_name,
+                                                      int* have_minimum_maximum,
+                                                      int* minimum, int* maximum)
+{
+  for (const heif_encoder_parameter* const* params = heif_encoder_list_parameters(encoder);
+       *params;
+       params++) {
+    if (strcmp((*params)->name, parameter_name) == 0) {
+      return heif_encoder_parameter_get_valid_integer_range(*params, have_minimum_maximum,
+                                                            minimum, maximum);
+    }
+  }
+
+  return error_unsupported_parameter;
+}
+
+heif_error heif_encoder_set_parameter_boolean(heif_encoder* encoder,
+                                              const char* parameter_name,
+                                              int value)
+{
+  return encoder->plugin->set_parameter_boolean(encoder->encoder, parameter_name, value);
+}
+
+heif_error heif_encoder_get_parameter_boolean(heif_encoder* encoder,
+                                              const char* parameter_name,
+                                              int* value_ptr)
+{
+  return encoder->plugin->get_parameter_boolean(encoder->encoder, parameter_name, value_ptr);
+}
+
+heif_error heif_encoder_set_parameter_string(heif_encoder* encoder,
+                                             const char* parameter_name,
+                                             const char* value)
+{
+  return encoder->plugin->set_parameter_string(encoder->encoder, parameter_name, value);
+}
+
+heif_error heif_encoder_get_parameter_string(heif_encoder* encoder,
+                                             const char* parameter_name,
+                                             char* value_ptr, int value_size)
+{
+  return encoder->plugin->get_parameter_string(encoder->encoder, parameter_name,
+                                               value_ptr, value_size);
+}
+
+heif_error heif_encoder_parameter_string_valid_values(heif_encoder* encoder,
+                                                      const char* parameter_name,
+                                                      const char* const** out_stringarray)
+{
+  for (const heif_encoder_parameter* const* params = heif_encoder_list_parameters(encoder);
+       *params;
+       params++) {
+    if (strcmp((*params)->name, parameter_name) == 0) {
+      return heif_encoder_parameter_get_valid_string_values(*params, out_stringarray);
+    }
+  }
+
+  return error_unsupported_parameter;
+}
+
+heif_error heif_encoder_parameter_integer_valid_values(heif_encoder* encoder,
+                                                       const char* parameter_name,
+                                                       int* have_minimum, int* have_maximum,
+                                                       int* minimum, int* maximum,
+                                                       int* num_valid_values,
+                                                       const int** out_integer_array)
+{
+  for (const heif_encoder_parameter* const* params = heif_encoder_list_parameters(encoder);
+       *params;
+       params++) {
+    if (strcmp((*params)->name, parameter_name) == 0) {
+      return heif_encoder_parameter_get_valid_integer_values(*params, have_minimum, have_maximum, minimum, maximum,
+                                                             num_valid_values, out_integer_array);
+    }
+  }
+
+  return error_unsupported_parameter;
+}
+
+
+static bool parse_boolean(const char* value)
+{
+  if (strcmp(value, "true") == 0) {
+    return true;
+  }
+  else if (strcmp(value, "false") == 0) {
+    return false;
+  }
+  else if (strcmp(value, "1") == 0) {
+    return true;
+  }
+  else if (strcmp(value, "0") == 0) {
+    return false;
+  }
+
+  return false;
+}
+
+
+heif_error heif_encoder_set_parameter(heif_encoder* encoder,
+                                      const char* parameter_name,
+                                      const char* value)
+{
+  for (const heif_encoder_parameter* const* params = heif_encoder_list_parameters(encoder);
+       *params;
+       params++) {
+    if (strcmp((*params)->name, parameter_name) == 0) {
+      switch ((*params)->type) {
+        case heif_encoder_parameter_type_integer:
+          return heif_encoder_set_parameter_integer(encoder, parameter_name, atoi(value));
+
+        case heif_encoder_parameter_type_boolean:
+          return heif_encoder_set_parameter_boolean(encoder, parameter_name, parse_boolean(value));
+
+        case heif_encoder_parameter_type_string:
+          return heif_encoder_set_parameter_string(encoder, parameter_name, value);
+          break;
+      }
+
+      return heif_error_success;
+    }
+  }
+
+  return heif_encoder_set_parameter_string(encoder, parameter_name, value);
+
+  //return error_unsupported_parameter;
+}
+
+
+heif_error heif_encoder_get_parameter(heif_encoder* encoder,
+                                      const char* parameter_name,
+                                      char* value_ptr, int value_size)
+{
+  for (const heif_encoder_parameter* const* params = heif_encoder_list_parameters(encoder);
+       *params;
+       params++) {
+    if (strcmp((*params)->name, parameter_name) == 0) {
+      switch ((*params)->type) {
+        case heif_encoder_parameter_type_integer: {
+          int value;
+          heif_error error = heif_encoder_get_parameter_integer(encoder, parameter_name, &value);
+          if (error.code) {
+            return error;
+          }
+          else {
+            snprintf(value_ptr, value_size, "%d", value);
+          }
+        }
+        break;
+
+        case heif_encoder_parameter_type_boolean: {
+          int value;
+          heif_error error = heif_encoder_get_parameter_boolean(encoder, parameter_name, &value);
+          if (error.code) {
+            return error;
+          }
+          else {
+            snprintf(value_ptr, value_size, "%d", value);
+          }
+        }
+        break;
+
+        case heif_encoder_parameter_type_string: {
+          heif_error error = heif_encoder_get_parameter_string(encoder, parameter_name,
+                                                               value_ptr, value_size);
+          if (error.code) {
+            return error;
+          }
+        }
+        break;
+      }
+
+      return heif_error_success;
+    }
+  }
+
+  return error_unsupported_parameter;
+}
+
+
+int heif_encoder_has_default(heif_encoder* encoder,
+                             const char* parameter_name)
+{
+  for (const heif_encoder_parameter* const* params = heif_encoder_list_parameters(encoder);
+       *params;
+       params++) {
+    if (strcmp((*params)->name, parameter_name) == 0) {
+      if ((*params)->version >= 2) {
+        return (*params)->has_default;
+      }
+      else {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+
+// 1 = heif_orientation_normal
+// 2 = heif_orientation_flip_horizontally
+// 3 = heif_orientation_rotate_180
+// 4 = heif_orientation_flip_vertically
+// 5 = heif_orientation_rotate_90_cw_then_flip_horizontally
+// 6 = heif_orientation_rotate_90_cw
+// 7 = heif_orientation_rotate_90_cw_then_flip_vertically
+// 8 = heif_orientation_rotate_270_cw
+static int orientation_concat[8][8] {
+  //         second: 1  2  3  4  5  6  7  8
+  /* first=1 */   {1, 2, 3, 4, 5, 6, 7, 8},
+  /* first=2 */   {2, 1, 4, 3, 8, 7, 6, 5},
+  /* first=3 */   {3, 4, 1, 2, 7, 8, 5, 6},
+  /* first=4 */   {4, 3, 2, 1, 6, 5, 8, 7},
+  /* first=5 */   {5, 6, 7, 8, 1, 2, 3, 4},
+  /* first=6 */   {6, 5, 8, 7, 4, 3, 2, 1},
+  /* first=7 */   {7, 8, 5, 6, 3, 4, 1, 2},
+  /* first=8 */   {8, 7, 6, 5, 2, 1, 4, 3}
+};
+
+
+heif_orientation heif_orientation_concat(heif_orientation first, heif_orientation second)
+{
+  // handle invalid input
+  if (first < 1 || first > 8 || second < 1 || second > 8) {
+    return heif_orientation_normal;
+  }
+
+  return static_cast<heif_orientation>(orientation_concat[first - 1][second - 1]);
+}
+
+
+static void set_default_encoding_options(heif_encoding_options& options)
+{
+  options.version = 8;
+
+  options.save_alpha_channel = true;
+  options.macOS_compatibility_workaround = false;
+  options.save_two_colr_boxes_when_ICC_and_nclx_available = false;
+  options.output_nclx_profile = nullptr;
+  options.macOS_compatibility_workaround_no_nclx_profile = false;
+  options.image_orientation = heif_orientation_normal;
+
+  options.color_conversion_options.version = 1;
+  options.color_conversion_options.preferred_chroma_downsampling_algorithm = heif_chroma_downsampling_average;
+  options.color_conversion_options.preferred_chroma_upsampling_algorithm = heif_chroma_upsampling_bilinear;
+  options.color_conversion_options.only_use_preferred_chroma_algorithm = false;
+
+  options.prefer_uncC_short_form = true;
+
+  options.unci_compression = heif_unci_compression_off;
+}
+
+
+heif_encoding_options* heif_encoding_options_alloc()
+{
+  auto options = new heif_encoding_options;
+
+  set_default_encoding_options(*options);
+
+  return options;
+}
+
+
+void heif_encoding_options_copy(heif_encoding_options* dst, const heif_encoding_options* src)
+{
+  if (src == nullptr) {
+    return;
+  }
+
+  int min_version = std::min(dst->version, src->version);
+
+  switch (min_version) {
+    case 8:
+      dst->unci_compression = src->unci_compression;
+      [[fallthrough]];
+    case 7:
+      dst->prefer_uncC_short_form = src->prefer_uncC_short_form;
+      [[fallthrough]];
+    case 6:
+      dst->color_conversion_options = src->color_conversion_options;
+      [[fallthrough]];
+    case 5:
+      dst->image_orientation = src->image_orientation;
+      [[fallthrough]];
+    case 4:
+      dst->output_nclx_profile = src->output_nclx_profile;
+      dst->macOS_compatibility_workaround_no_nclx_profile = src->macOS_compatibility_workaround_no_nclx_profile;
+      [[fallthrough]];
+    case 3:
+      dst->save_two_colr_boxes_when_ICC_and_nclx_available = src->save_two_colr_boxes_when_ICC_and_nclx_available;
+      [[fallthrough]];
+    case 2:
+      dst->macOS_compatibility_workaround = src->macOS_compatibility_workaround;
+      [[fallthrough]];
+    case 1:
+      dst->save_alpha_channel = src->save_alpha_channel;
+  }
+}
+
+
+void heif_encoding_options_free(heif_encoding_options* options)
+{
+  delete options;
+}
+
+heif_error heif_context_encode_image(heif_context* ctx,
+                                     const heif_image* input_image,
+                                     heif_encoder* encoder,
+                                     const heif_encoding_options* input_options,
+                                     heif_image_handle** out_image_handle)
+{
+  if (!encoder) {
+    return heif_error_null_pointer_argument;
+  }
+
+  if (out_image_handle) {
+    *out_image_handle = nullptr;
+  }
+
+  heif_encoding_options options;
+  heif_color_profile_nclx nclx;
+  set_default_encoding_options(options);
+  if (input_options) {
+    heif_encoding_options_copy(&options, input_options);
+
+    if (options.output_nclx_profile == nullptr) {
+      if (input_image->image->has_nclx_color_profile()) {
+        nclx_profile input_nclx = input_image->image->get_color_profile_nclx();
+
+        options.output_nclx_profile = &nclx;
+        nclx.version = 1;
+        nclx.color_primaries = input_nclx.get_colour_primaries();
+        nclx.transfer_characteristics = input_nclx.get_transfer_characteristics();
+        nclx.matrix_coefficients = input_nclx.get_matrix_coefficients();
+        nclx.full_range_flag = input_nclx.get_full_range_flag();
+      }
+    }
+  }
+
+  auto encodingResult = ctx->context->encode_image(input_image->image,
+                                                   encoder,
+                                                   options,
+                                                   heif_image_input_class_normal);
+  if (!encodingResult) {
+    return encodingResult.error_struct(ctx->context.get());
+  }
+
+  std::shared_ptr<ImageItem> image = *encodingResult;
+
+  // mark the new image as primary image
+
+  if (ctx->context->is_primary_image_set() == false) {
+    ctx->context->set_primary_image(image);
+  }
+
+  if (out_image_handle) {
+    *out_image_handle = new heif_image_handle;
+    (*out_image_handle)->image = std::move(image);
+    (*out_image_handle)->context = ctx->context;
+  }
+
+  return heif_error_success;
+}
+
+
+heif_error heif_context_add_overlay_image(heif_context* ctx,
+                                          uint32_t image_width,
+                                          uint32_t image_height,
+                                          uint16_t nImages,
+                                          const heif_item_id* image_ids,
+                                          int32_t* offsets,
+                                          const uint16_t background_rgba[4],
+                                          heif_image_handle** out_iovl_image_handle)
+{
+  if (!image_ids) {
+    return heif_error_null_pointer_argument;
+  }
+  else if (nImages == 0) {
+    return Error(heif_error_Usage_error,
+                 heif_suberror_Invalid_parameter_value).error_struct(ctx->context.get());
+  }
+
+
+  std::vector<heif_item_id> refs;
+  refs.insert(refs.end(), image_ids, image_ids + nImages);
+
+  ImageOverlay overlay;
+  overlay.set_canvas_size(image_width, image_height);
+
+  if (background_rgba) {
+    overlay.set_background_color(background_rgba);
+  }
+
+  for (uint16_t i = 0; i < nImages; i++) {
+    overlay.add_image_on_top(image_ids[i],
+                             offsets ? offsets[2 * i] : 0,
+                             offsets ? offsets[2 * i + 1] : 0);
+  }
+
+  Result<std::shared_ptr<ImageItem_Overlay> > addImageResult = ImageItem_Overlay::add_new_overlay_item(ctx->context.get(), overlay);
+
+  if (!addImageResult) {
+    return addImageResult.error_struct(ctx->context.get());
+  }
+
+  std::shared_ptr<ImageItem> iovlimage = *addImageResult;
+
+
+  if (out_iovl_image_handle) {
+    *out_iovl_image_handle = new heif_image_handle;
+    (*out_iovl_image_handle)->image = std::move(iovlimage);
+    (*out_iovl_image_handle)->context = ctx->context;
+  }
+
+  return heif_error_success;
+}
+
+
+heif_error heif_context_set_primary_image(heif_context* ctx,
+                                          heif_image_handle* image_handle)
+{
+  ctx->context->set_primary_image(image_handle->image);
+
+  return heif_error_success;
+}
+
+
+void heif_context_set_major_brand(heif_context* ctx,
+                                  heif_brand2 major_brand)
+{
+  auto ftyp = ctx->context->get_heif_file()->get_ftyp_box();
+  ftyp->set_major_brand(major_brand);
+  ftyp->add_compatible_brand(major_brand);
+}
+
+
+void heif_context_add_compatible_brand(heif_context* ctx,
+                                       heif_brand2 compatible_brand)
+{
+  ctx->context->get_heif_file()->get_ftyp_box()->add_compatible_brand(compatible_brand);
+}
+
+
+void heif_context_set_unif(heif_context* ctx, int flag)
+{
+  ctx->context->set_unif(flag != 0);
+}
+
+
+// === DEPRECATED ===
+
+// DEPRECATED: typo in function name
+int heif_encoder_descriptor_supportes_lossy_compression(const heif_encoder_descriptor* descriptor)
+{
+  return descriptor->plugin->supports_lossy_compression;
+}
+
+
+// DEPRECATED: typo in function name
+int heif_encoder_descriptor_supportes_lossless_compression(const heif_encoder_descriptor* descriptor)
+{
+  return descriptor->plugin->supports_lossless_compression;
+}
+
+
+// DEPRECATED
+int heif_context_get_encoder_descriptors(heif_context* ctx,
+                                         heif_compression_format format,
+                                         const char* name,
+                                         const heif_encoder_descriptor** out_encoder_descriptors,
+                                         int count)
+{
+  return heif_get_encoder_descriptors(format, name, out_encoder_descriptors, count);
+}
diff --git a/libheif/api/libheif/heif_encoding.h b/libheif/api/libheif/heif_encoding.h
new file mode 100644
index 0000000000..f7f6e37578
--- /dev/null
+++ b/libheif/api/libheif/heif_encoding.h
@@ -0,0 +1,419 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017-2025 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_HEIF_ENCODING_H
+#define LIBHEIF_HEIF_ENCODING_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <libheif/heif_library.h>
+#include <libheif/heif_image.h>
+#include <libheif/heif_context.h>
+#include <libheif/heif_brands.h>
+#include <libheif/heif_color.h>
+#include <libheif/heif_uncompressed_types.h>
+
+
+// ----- encoder -----
+
+/**
+ * Opaque object that represents the encoder used to code the images.
+ */
+typedef struct heif_encoder heif_encoder;
+
+// A description of the encoder's capabilities and name.
+typedef struct heif_encoder_descriptor heif_encoder_descriptor;
+
+// A configuration parameter of the encoder. Each encoder implementation may have a different
+// set of parameters. For the most common settings (e.q. quality), special functions to set
+// the parameters are provided.
+typedef struct heif_encoder_parameter heif_encoder_parameter;
+
+
+// Quick check whether there is an enoder available for the given format.
+// Note that the encoder may be limited to a certain subset of features (e.g. only 8 bit, only lossy).
+// You will have to query the specific capabilities further.
+LIBHEIF_API
+int heif_have_encoder_for_format(enum heif_compression_format format);
+
+// Get a list of available encoders. You can filter the encoders by compression format and name.
+// Use format_filter==heif_compression_undefined and name_filter==NULL as wildcards.
+// The returned list of encoders is sorted by their priority (which is a plugin property).
+// The number of encoders is returned, which are not more than 'count' if (out_encoders != nullptr).
+// By setting out_encoders==nullptr, you can query the number of encoders, 'count' is ignored.
+// Note: to get the actual encoder from the descriptors returned here, use heif_context_get_encoder().
+LIBHEIF_API
+int heif_get_encoder_descriptors(enum heif_compression_format format_filter,
+                                 const char* name_filter,
+                                 const heif_encoder_descriptor** out_encoders,
+                                 int count);
+
+// Return a long, descriptive name of the encoder (including version information).
+LIBHEIF_API
+const char* heif_encoder_descriptor_get_name(const heif_encoder_descriptor*);
+
+// Return a short, symbolic name for identifying the encoder.
+// This name should stay constant over different encoder versions.
+LIBHEIF_API
+const char* heif_encoder_descriptor_get_id_name(const heif_encoder_descriptor*);
+
+LIBHEIF_API
+enum heif_compression_format
+heif_encoder_descriptor_get_compression_format(const heif_encoder_descriptor*);
+
+LIBHEIF_API
+int heif_encoder_descriptor_supports_lossy_compression(const heif_encoder_descriptor*);
+
+LIBHEIF_API
+int heif_encoder_descriptor_supports_lossless_compression(const heif_encoder_descriptor*);
+
+
+// Get an encoder instance that can be used to actually encode images from a descriptor.
+LIBHEIF_API
+heif_error heif_context_get_encoder(heif_context* context,
+                                    const heif_encoder_descriptor*,
+                                    heif_encoder** out_encoder);
+
+// Get an encoder for the given compression format. If there are several encoder plugins
+// for this format, the encoder with the highest plugin priority will be returned.
+LIBHEIF_API
+heif_error heif_context_get_encoder_for_format(heif_context* context,
+                                               enum heif_compression_format format,
+                                               heif_encoder**);
+
+/**
+ * Release the encoder object after use.
+ */
+LIBHEIF_API
+void heif_encoder_release(heif_encoder*);
+
+// Get the encoder name from the encoder itself.
+LIBHEIF_API
+const char* heif_encoder_get_name(const heif_encoder*);
+
+
+// --- Encoder Parameters ---
+
+// Libheif supports settings parameters through specialized functions and through
+// generic functions by parameter name. Sometimes, the same parameter can be set
+// in both ways.
+// We consider it best practice to use the generic parameter functions only in
+// dynamically generated user interfaces, as no guarantees are made that some specific
+// parameter names are supported by all plugins.
+
+
+// Set a 'quality' factor (0-100). How this is mapped to actual encoding parameters is
+// encoder dependent.
+LIBHEIF_API
+heif_error heif_encoder_set_lossy_quality(heif_encoder*, int quality);
+
+LIBHEIF_API
+heif_error heif_encoder_set_lossless(heif_encoder*, int enable);
+
+// level should be between 0 (= none) to 4 (= full)
+LIBHEIF_API
+heif_error heif_encoder_set_logging_level(heif_encoder*, int level);
+
+// Get a generic list of encoder parameters.
+// Each encoder may define its own, additional set of parameters.
+// You do not have to free the returned list.
+LIBHEIF_API
+const heif_encoder_parameter* const* heif_encoder_list_parameters(heif_encoder*);
+
+// Return the parameter name.
+LIBHEIF_API
+const char* heif_encoder_parameter_get_name(const heif_encoder_parameter*);
+
+
+typedef enum heif_encoder_parameter_type
+{
+  heif_encoder_parameter_type_integer = 1,
+  heif_encoder_parameter_type_boolean = 2,
+  heif_encoder_parameter_type_string = 3
+} heif_encoder_parameter_type;
+
+// Return the parameter type.
+LIBHEIF_API
+enum heif_encoder_parameter_type heif_encoder_parameter_get_type(const heif_encoder_parameter*);
+
+// DEPRECATED. Use heif_encoder_parameter_get_valid_integer_values() instead.
+LIBHEIF_API
+heif_error heif_encoder_parameter_get_valid_integer_range(const heif_encoder_parameter*,
+                                                          int* have_minimum_maximum,
+                                                          int* minimum, int* maximum);
+
+// If integer is limited by a range, have_minimum and/or have_maximum will be != 0 and *minimum, *maximum is set.
+// If integer is limited by a fixed set of values, *num_valid_values will be >0 and *out_integer_array is set.
+LIBHEIF_API
+heif_error heif_encoder_parameter_get_valid_integer_values(const heif_encoder_parameter*,
+                                                           int* have_minimum, int* have_maximum,
+                                                           int* minimum, int* maximum,
+                                                           int* num_valid_values,
+                                                           const int** out_integer_array);
+
+LIBHEIF_API
+heif_error heif_encoder_parameter_get_valid_string_values(const heif_encoder_parameter*,
+                                                          const char* const** out_stringarray);
+
+
+LIBHEIF_API
+heif_error heif_encoder_set_parameter_integer(heif_encoder*,
+                                              const char* parameter_name,
+                                              int value);
+
+LIBHEIF_API
+heif_error heif_encoder_get_parameter_integer(heif_encoder*,
+                                              const char* parameter_name,
+                                              int* value);
+
+// TODO: name should be changed to heif_encoder_get_valid_integer_parameter_range
+LIBHEIF_API // DEPRECATED.
+heif_error heif_encoder_parameter_integer_valid_range(heif_encoder*,
+                                                      const char* parameter_name,
+                                                      int* have_minimum_maximum,
+                                                      int* minimum, int* maximum);
+
+LIBHEIF_API
+heif_error heif_encoder_set_parameter_boolean(heif_encoder*,
+                                              const char* parameter_name,
+                                              int value);
+
+LIBHEIF_API
+heif_error heif_encoder_get_parameter_boolean(heif_encoder*,
+                                              const char* parameter_name,
+                                              int* value);
+
+LIBHEIF_API
+heif_error heif_encoder_set_parameter_string(heif_encoder*,
+                                             const char* parameter_name,
+                                             const char* value);
+
+LIBHEIF_API
+heif_error heif_encoder_get_parameter_string(heif_encoder*,
+                                             const char* parameter_name,
+                                             char* value, int value_size);
+
+// returns a NULL-terminated list of valid strings or NULL if all values are allowed
+LIBHEIF_API
+heif_error heif_encoder_parameter_string_valid_values(heif_encoder*,
+                                                      const char* parameter_name,
+                                                      const char* const** out_stringarray);
+
+LIBHEIF_API
+heif_error heif_encoder_parameter_integer_valid_values(heif_encoder*,
+                                                       const char* parameter_name,
+                                                       int* have_minimum, int* have_maximum,
+                                                       int* minimum, int* maximum,
+                                                       int* num_valid_values,
+                                                       const int** out_integer_array);
+
+// Set a parameter of any type to the string value.
+// Integer values are parsed from the string.
+// Boolean values can be "true"/"false"/"1"/"0"
+//
+// x265 encoder specific note:
+// When using the x265 encoder, you may pass any of its parameters by
+// prefixing the parameter name with 'x265:'. Hence, to set the 'ctu' parameter,
+// you will have to set 'x265:ctu' in libheif.
+// Note that there is no checking for valid parameters when using the prefix.
+LIBHEIF_API
+heif_error heif_encoder_set_parameter(heif_encoder*,
+                                      const char* parameter_name,
+                                      const char* value);
+
+// Get the current value of a parameter of any type as a human readable string.
+// The returned string is compatible with heif_encoder_set_parameter().
+LIBHEIF_API
+heif_error heif_encoder_get_parameter(heif_encoder*,
+                                      const char* parameter_name,
+                                      char* value_ptr, int value_size);
+
+// Query whether a specific parameter has a default value.
+LIBHEIF_API
+int heif_encoder_has_default(heif_encoder*,
+                             const char* parameter_name);
+
+
+// The orientation values are defined equal to the EXIF Orientation tag.
+typedef enum heif_orientation
+{
+  heif_orientation_normal = 1,
+  heif_orientation_flip_horizontally = 2,
+  heif_orientation_rotate_180 = 3,
+  heif_orientation_flip_vertically = 4,
+  heif_orientation_rotate_90_cw_then_flip_horizontally = 5,
+  heif_orientation_rotate_90_cw = 6,
+  heif_orientation_rotate_90_cw_then_flip_vertically = 7,
+  heif_orientation_rotate_270_cw = 8
+} heif_orientation;
+
+
+LIBHEIF_API
+heif_orientation heif_orientation_concat(heif_orientation first, heif_orientation second);
+
+
+typedef struct heif_encoding_options
+{
+  uint8_t version;
+
+  // version 1 options
+
+  uint8_t save_alpha_channel; // default: true
+
+  // version 2 options
+
+  // DEPRECATED. This option is not required anymore. Its value will be ignored.
+  uint8_t macOS_compatibility_workaround;
+
+  // version 3 options
+
+  uint8_t save_two_colr_boxes_when_ICC_and_nclx_available; // default: false
+
+  // version 4 options
+
+  // Set this to the NCLX parameters to be used in the output image or set to NULL
+  // when the same parameters as in the input image should be used.
+  heif_color_profile_nclx* output_nclx_profile;
+
+  uint8_t macOS_compatibility_workaround_no_nclx_profile;
+
+  // version 5 options
+
+  // libheif will generate irot/imir boxes to match these orientations
+  heif_orientation image_orientation;
+
+  // version 6 options
+
+  heif_color_conversion_options color_conversion_options;
+
+  // version 7 options
+
+  // Set this to true to use compressed form of uncC where possible.
+  uint8_t prefer_uncC_short_form;
+
+  // version 8 options
+
+  // Set this to enable compression for 'unci' images encoded through heif_context_encode_image().
+  // Default: heif_unci_compression_off
+  heif_unci_compression unci_compression;
+
+  // TODO: we should add a flag to force MIAF compatible outputs. E.g. this will put restrictions on grid tile sizes and
+  //       might add a clap box when the grid output size does not match the color subsampling factors.
+  //       Since some of these constraints have to be known before actually encoding the image, "forcing MIAF compatibility"
+  //       could also be a flag in the heif_context.
+} heif_encoding_options;
+
+LIBHEIF_API
+heif_encoding_options* heif_encoding_options_alloc(void);
+
+LIBHEIF_API
+void heif_encoding_options_copy(heif_encoding_options* dst, const heif_encoding_options* src);
+
+LIBHEIF_API
+void heif_encoding_options_free(heif_encoding_options*);
+
+
+// Compress the input image.
+// Returns a handle to the coded image in 'out_image_handle' unless out_image_handle = NULL.
+// 'options' should be NULL for now.
+// The first image added to the context is also automatically set the primary image, but
+// you can change the primary image later with heif_context_set_primary_image().
+LIBHEIF_API
+heif_error heif_context_encode_image(heif_context*,
+                                     const heif_image* image,
+                                     heif_encoder* encoder,
+                                     const heif_encoding_options* options,
+                                     heif_image_handle** out_image_handle);
+
+// offsets[] should either be NULL (all offsets==0) or an array of size 2*nImages with x;y offset pairs.
+// If background_rgba is NULL, the background is transparent.
+LIBHEIF_API
+heif_error heif_context_add_overlay_image(heif_context* ctx,
+                                          uint32_t image_width,
+                                          uint32_t image_height,
+                                          uint16_t nImages,
+                                          const heif_item_id* image_ids,
+                                          int32_t* offsets,
+                                          const uint16_t background_rgba[4],
+                                          heif_image_handle** out_iovl_image_handle);
+
+LIBHEIF_API
+heif_error heif_context_set_primary_image(heif_context*,
+                                          heif_image_handle* image_handle);
+
+// Set the major brand of the file.
+// If this function is not called, the major brand is determined automatically from
+// the image or sequence content.
+LIBHEIF_API
+void heif_context_set_major_brand(heif_context* ctx,
+                                  heif_brand2 major_brand);
+
+// Add a compatible brand that is now added automatically by libheif when encoding images (e.g. some application brands like 'geo1').
+LIBHEIF_API
+void heif_context_add_compatible_brand(heif_context* ctx,
+                                       heif_brand2 compatible_brand);
+
+/**
+ * Enable the unified ID namespace ('unif' brand).
+ *
+ * When enabled, item IDs, track IDs, and entity group IDs share a single
+ * global counter so no ID value is reused across categories. The 'unif'
+ * compatible brand is automatically added to the output file.
+ *
+ * @param ctx the encoding context
+ * @param flag non-zero to enable, zero to disable
+ */
+LIBHEIF_API
+void heif_context_set_unif(heif_context* ctx, int flag);
+
+// --- deprecated functions ---
+
+// DEPRECATED, typo in function name
+LIBHEIF_API
+int heif_encoder_descriptor_supportes_lossy_compression(const heif_encoder_descriptor*);
+
+// DEPRECATED, typo in function name
+LIBHEIF_API
+int heif_encoder_descriptor_supportes_lossless_compression(const heif_encoder_descriptor*);
+
+// DEPRECATED: use heif_get_encoder_descriptors() instead.
+// Get a list of available encoders. You can filter the encoders by compression format and name.
+// Use format_filter==heif_compression_undefined and name_filter==NULL as wildcards.
+// The returned list of encoders is sorted by their priority (which is a plugin property).
+// The number of encoders is returned, which are not more than 'count' if (out_encoders != nullptr).
+// By setting out_encoders==nullptr, you can query the number of encoders, 'count' is ignored.
+// Note: to get the actual encoder from the descriptors returned here, use heif_context_get_encoder().
+LIBHEIF_API
+int heif_context_get_encoder_descriptors(heif_context*, // TODO: why do we need this parameter?
+                                         enum heif_compression_format format_filter,
+                                         const char* name_filter,
+                                         const heif_encoder_descriptor** out_encoders,
+                                         int count);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/libheif/api/libheif/heif_entity_groups.cc b/libheif/api/libheif/heif_entity_groups.cc
new file mode 100644
index 0000000000..c8dd171bc5
--- /dev/null
+++ b/libheif/api/libheif/heif_entity_groups.cc
@@ -0,0 +1,99 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017-2025 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "heif_entity_groups.h"
+#include "box.h"
+#include "api_structs.h"
+#include "file.h"
+
+#include <memory>
+#include <vector>
+
+
+heif_entity_group* heif_context_get_entity_groups(const heif_context* ctx,
+                                                  uint32_t type_filter,
+                                                  heif_item_id item_filter,
+                                                  int* out_num_groups)
+{
+  std::shared_ptr<Box_grpl> grplBox = ctx->context->get_heif_file()->get_grpl_box();
+  if (!grplBox) {
+    *out_num_groups = 0;
+    return nullptr;
+  }
+
+  std::vector<std::shared_ptr<Box> > all_entity_group_boxes = grplBox->get_all_child_boxes();
+  if (all_entity_group_boxes.empty()) {
+    *out_num_groups = 0;
+    return nullptr;
+  }
+
+  // --- filter groups
+
+  std::vector<std::shared_ptr<Box_EntityToGroup> > entity_group_boxes;
+  for (auto& group : all_entity_group_boxes) {
+    if (type_filter != 0 && group->get_short_type() != type_filter) {
+      continue;
+    }
+
+    auto groupBox = std::dynamic_pointer_cast<Box_EntityToGroup>(group);
+    const std::vector<heif_item_id>& items = groupBox->get_item_ids();
+
+    if (item_filter != 0 && std::all_of(items.begin(), items.end(), [item_filter](heif_item_id item) {
+      return item != item_filter;
+    })) {
+      continue;
+    }
+
+    entity_group_boxes.emplace_back(groupBox);
+  }
+
+  // --- convert to C structs
+
+  auto* groups = new heif_entity_group[entity_group_boxes.size()];
+  for (size_t i = 0; i < entity_group_boxes.size(); i++) {
+    const auto& groupBox = entity_group_boxes[i];
+    const std::vector<heif_item_id>& items = groupBox->get_item_ids();
+
+    groups[i].entity_group_id = groupBox->get_group_id();
+    groups[i].entity_group_type = groupBox->get_short_type();
+    groups[i].entities = (items.empty() ? nullptr : new heif_item_id[items.size()]);
+    groups[i].num_entities = static_cast<uint32_t>(items.size());
+
+    if (groups[i].entities) {
+      // avoid clang static analyzer false positive
+      for (size_t k = 0; k < items.size(); k++) {
+        groups[i].entities[k] = items[k];
+      }
+    }
+  }
+
+  *out_num_groups = static_cast<int>(entity_group_boxes.size());
+  return groups;
+}
+
+
+void heif_entity_groups_release(heif_entity_group* grp, int num_groups)
+{
+  for (int i = 0; i < num_groups; i++) {
+    delete[] grp[i].entities;
+  }
+
+  delete[] grp;
+}
diff --git a/libheif/api/libheif/heif_entity_groups.h b/libheif/api/libheif/heif_entity_groups.h
new file mode 100644
index 0000000000..4c41129f59
--- /dev/null
+++ b/libheif/api/libheif/heif_entity_groups.h
@@ -0,0 +1,60 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017-2025 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_HEIF_ENTITY_GROUPS_H
+#define LIBHEIF_HEIF_ENTITY_GROUPS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "libheif/heif_library.h"
+
+
+// ------------------------- entity groups ------------------------
+
+typedef uint32_t heif_entity_group_id;
+
+typedef struct heif_entity_group
+{
+  heif_entity_group_id entity_group_id;
+  uint32_t entity_group_type;  // this is a FourCC constant
+  heif_item_id* entities;
+  uint32_t num_entities;
+} heif_entity_group;
+
+// Use 0 for `type_filter` or `item_filter` to disable the filter.
+// Returns an array of heif_entity_group structs with *out_num_groups entries.
+LIBHEIF_API
+heif_entity_group* heif_context_get_entity_groups(const heif_context*,
+                                                  uint32_t type_filter,
+                                                  heif_item_id item_filter,
+                                                  int* out_num_groups);
+
+// Release an array of entity groups returned by heif_context_get_entity_groups().
+LIBHEIF_API
+void heif_entity_groups_release(heif_entity_group*, int num_groups);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/libheif/api/libheif/heif_error.h b/libheif/api/libheif/heif_error.h
new file mode 100644
index 0000000000..a5097bcc07
--- /dev/null
+++ b/libheif/api/libheif/heif_error.h
@@ -0,0 +1,304 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017-2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_HEIF_ERROR_H
+#define LIBHEIF_HEIF_ERROR_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stddef.h>
+#include <stdint.h>
+
+
+typedef enum heif_error_code
+{
+  // Everything ok, no error occurred.
+  heif_error_Ok = 0,
+
+  // Input file does not exist.
+  heif_error_Input_does_not_exist = 1,
+
+  // Error in input file. Corrupted or invalid content.
+  heif_error_Invalid_input = 2,
+
+  // Input file type is not supported.
+  heif_error_Unsupported_filetype = 3,
+
+  // Image requires an unsupported decoder feature.
+  heif_error_Unsupported_feature = 4,
+
+  // Library API has been used in an invalid way.
+  heif_error_Usage_error = 5,
+
+  // Could not allocate enough memory.
+  heif_error_Memory_allocation_error = 6,
+
+  // The decoder plugin generated an error
+  heif_error_Decoder_plugin_error = 7,
+
+  // The encoder plugin generated an error
+  heif_error_Encoder_plugin_error = 8,
+
+  // Error during encoding or when writing to the output
+  heif_error_Encoding_error = 9,
+
+  // Application has asked for a color profile type that does not exist
+  heif_error_Color_profile_does_not_exist = 10,
+
+  // Error loading a dynamic plugin
+  heif_error_Plugin_loading_error = 11,
+
+  // Operation has been canceled
+  heif_error_Canceled = 12,
+
+  heif_error_End_of_sequence = 13
+} heif_error_code;
+
+
+typedef enum heif_suberror_code
+{
+  // no further information available
+  heif_suberror_Unspecified = 0,
+
+  // --- Invalid_input ---
+
+  // End of data reached unexpectedly.
+  heif_suberror_End_of_data = 100,
+
+  // Size of box (defined in header) is wrong
+  heif_suberror_Invalid_box_size = 101,
+
+  // Mandatory 'ftyp' box is missing
+  heif_suberror_No_ftyp_box = 102,
+
+  heif_suberror_No_idat_box = 103,
+
+  heif_suberror_No_meta_box = 104,
+
+  heif_suberror_No_hdlr_box = 105,
+
+  heif_suberror_No_hvcC_box = 106,
+
+  heif_suberror_No_pitm_box = 107,
+
+  heif_suberror_No_ipco_box = 108,
+
+  heif_suberror_No_ipma_box = 109,
+
+  heif_suberror_No_iloc_box = 110,
+
+  heif_suberror_No_iinf_box = 111,
+
+  heif_suberror_No_iprp_box = 112,
+
+  heif_suberror_No_iref_box = 113,
+
+  heif_suberror_No_pict_handler = 114,
+
+  // An item property referenced in the 'ipma' box is not existing in the 'ipco' container.
+  heif_suberror_Ipma_box_references_nonexisting_property = 115,
+
+  // No properties have been assigned to an item.
+  heif_suberror_No_properties_assigned_to_item = 116,
+
+  // Image has no (compressed) data
+  heif_suberror_No_item_data = 117,
+
+  // Invalid specification of image grid (tiled image)
+  heif_suberror_Invalid_grid_data = 118,
+
+  // Tile-images in a grid image are missing
+  heif_suberror_Missing_grid_images = 119,
+
+  heif_suberror_Invalid_clean_aperture = 120,
+
+  // Invalid specification of overlay image
+  heif_suberror_Invalid_overlay_data = 121,
+
+  // Overlay image completely outside of visible canvas area
+  heif_suberror_Overlay_image_outside_of_canvas = 122,
+
+  heif_suberror_Auxiliary_image_type_unspecified = 123,
+
+  heif_suberror_No_or_invalid_primary_item = 124,
+
+  heif_suberror_No_infe_box = 125,
+
+  heif_suberror_Unknown_color_profile_type = 126,
+
+  heif_suberror_Wrong_tile_image_chroma_format = 127,
+
+  heif_suberror_Invalid_fractional_number = 128,
+
+  heif_suberror_Invalid_image_size = 129,
+
+  heif_suberror_Invalid_pixi_box = 130,
+
+  heif_suberror_No_av1C_box = 131,
+
+  heif_suberror_Wrong_tile_image_pixel_depth = 132,
+
+  heif_suberror_Unknown_NCLX_color_primaries = 133,
+
+  heif_suberror_Unknown_NCLX_transfer_characteristics = 134,
+
+  heif_suberror_Unknown_NCLX_matrix_coefficients = 135,
+
+  // Invalid specification of region item
+  heif_suberror_Invalid_region_data = 136,
+
+  // Image has no ispe property
+  heif_suberror_No_ispe_property = 137,
+
+  heif_suberror_Camera_intrinsic_matrix_undefined = 138,
+
+  heif_suberror_Camera_extrinsic_matrix_undefined = 139,
+
+  // Invalid JPEG 2000 codestream - usually a missing marker
+  heif_suberror_Invalid_J2K_codestream = 140,
+
+  heif_suberror_No_vvcC_box = 141,
+
+  // icbr is only needed in some situations, this error is for those cases
+  heif_suberror_No_icbr_box = 142,
+
+  heif_suberror_No_avcC_box = 143,
+
+  // we got a mini box, but could not read it properly
+  heif_suberror_Invalid_mini_box = 149,
+
+  // Decompressing generic compression or header compression data failed (e.g. bitstream corruption)
+  heif_suberror_Decompression_invalid_data = 150,
+
+  heif_suberror_No_moov_box = 151,
+
+  // --- Memory_allocation_error ---
+
+  // A security limit preventing unreasonable memory allocations was exceeded by the input file.
+  // Please check whether the file is valid. If it is, contact us so that we could increase the
+  // security limits further.
+  heif_suberror_Security_limit_exceeded = 1000,
+
+  // There was an error from the underlying compression / decompression library.
+  // One possibility is lack of resources (e.g. memory).
+  heif_suberror_Compression_initialisation_error = 1001,
+
+  // --- Usage_error ---
+
+  // An item ID was used that is not present in the file.
+  heif_suberror_Nonexisting_item_referenced = 2000, // also used for Invalid_input
+
+  // An API argument was given a NULL pointer, which is not allowed for that function.
+  heif_suberror_Null_pointer_argument = 2001,
+
+  // Image channel referenced that does not exist in the image
+  heif_suberror_Nonexisting_image_channel_referenced = 2002,
+
+  // The version of the passed plugin is not supported.
+  heif_suberror_Unsupported_plugin_version = 2003,
+
+  // The version of the passed writer is not supported.
+  heif_suberror_Unsupported_writer_version = 2004,
+
+  // The given (encoder) parameter name does not exist.
+  heif_suberror_Unsupported_parameter = 2005,
+
+  // The value for the given parameter is not in the valid range.
+  heif_suberror_Invalid_parameter_value = 2006,
+
+  // Error in property specification
+  heif_suberror_Invalid_property = 2007,
+
+  // Image reference cycle found in iref
+  heif_suberror_Item_reference_cycle = 2008,
+
+
+  // --- Unsupported_feature ---
+
+  // Image was coded with an unsupported compression method.
+  heif_suberror_Unsupported_codec = 3000,
+
+  // Image is specified in an unknown way, e.g. as tiled grid image (which is supported)
+  heif_suberror_Unsupported_image_type = 3001,
+
+  heif_suberror_Unsupported_data_version = 3002,
+
+  // The conversion of the source image to the requested chroma / colorspace is not supported.
+  heif_suberror_Unsupported_color_conversion = 3003,
+
+  heif_suberror_Unsupported_item_construction_method = 3004,
+
+  heif_suberror_Unsupported_header_compression_method = 3005,
+
+  // Generically compressed data used an unsupported compression method
+  heif_suberror_Unsupported_generic_compression_method = 3006,
+
+  heif_suberror_Unsupported_essential_property = 3007,
+
+  heif_suberror_Unsupported_track_type = 3008,
+
+  // --- Encoder_plugin_error ---
+
+  heif_suberror_Unsupported_bit_depth = 4000,
+
+
+  // --- Encoding_error ---
+
+  heif_suberror_Cannot_write_output_data = 5000,
+
+  heif_suberror_Encoder_initialization = 5001,
+  heif_suberror_Encoder_encoding = 5002,
+  heif_suberror_Encoder_cleanup = 5003,
+
+  heif_suberror_Too_many_regions = 5004,
+
+
+  // --- Plugin loading error ---
+
+  heif_suberror_Plugin_loading_error = 6000,         // a specific plugin file cannot be loaded
+  heif_suberror_Plugin_is_not_loaded = 6001,         // trying to remove a plugin that is not loaded
+  heif_suberror_Cannot_read_plugin_directory = 6002, // error while scanning the directory for plugins
+  heif_suberror_No_matching_decoder_installed = 6003 // no decoder found for that compression format
+} heif_suberror_code;
+
+
+typedef struct heif_error
+{
+  // main error category
+  enum heif_error_code code;
+
+  // more detailed error code
+  enum heif_suberror_code subcode;
+
+  // textual error message (is always defined, you do not have to check for NULL)
+  const char* message;
+} heif_error;
+
+// Default success return value. Intended for use in user-supplied callback functions.
+LIBHEIF_API extern const heif_error heif_error_success;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/libheif/api/libheif/heif_experimental.cc b/libheif/api/libheif/heif_experimental.cc
new file mode 100644
index 0000000000..e83a03015a
--- /dev/null
+++ b/libheif/api/libheif/heif_experimental.cc
@@ -0,0 +1,372 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "heif_experimental.h"
+#include "context.h"
+#include "api_structs.h"
+#include "image-items/unc_image.h"
+#include "image-items/tiled.h"
+
+#include <array>
+#include <cstring>
+#include <memory>
+#include <vector>
+#include <limits>
+
+
+struct heif_property_camera_intrinsic_matrix
+{
+  Box_cmin::RelativeIntrinsicMatrix matrix;
+};
+
+heif_error heif_item_get_property_camera_intrinsic_matrix(const heif_context* context,
+                                                          heif_item_id itemId,
+                                                          heif_property_id propertyId,
+                                                          heif_property_camera_intrinsic_matrix** out_matrix)
+{
+  if (!out_matrix || !context) {
+    return heif_error_null_pointer_argument;
+  }
+
+  auto cmin = context->context->find_property<Box_cmin>(itemId, propertyId);
+  if (!cmin) {
+    return cmin.error_struct(context->context.get());
+  }
+
+  *out_matrix = new heif_property_camera_intrinsic_matrix;
+  (*out_matrix)->matrix = (*cmin)->get_intrinsic_matrix();
+
+  return heif_error_success;
+}
+
+
+void heif_property_camera_intrinsic_matrix_release(heif_property_camera_intrinsic_matrix* matrix)
+{
+  delete matrix;
+}
+
+heif_error heif_property_camera_intrinsic_matrix_get_focal_length(const heif_property_camera_intrinsic_matrix* matrix,
+                                                                  int image_width, int image_height,
+                                                                  double* out_focal_length_x,
+                                                                  double* out_focal_length_y)
+{
+  if (!matrix) {
+    return heif_error_null_pointer_argument;
+  }
+
+  double fx, fy;
+  matrix->matrix.compute_focal_length(image_width, image_height, fx, fy);
+
+  if (out_focal_length_x) *out_focal_length_x = fx;
+  if (out_focal_length_y) *out_focal_length_y = fy;
+
+  return heif_error_success;
+}
+
+
+heif_error heif_property_camera_intrinsic_matrix_get_principal_point(const heif_property_camera_intrinsic_matrix* matrix,
+                                                                     int image_width, int image_height,
+                                                                     double* out_principal_point_x,
+                                                                     double* out_principal_point_y)
+{
+  if (!matrix) {
+    return heif_error_null_pointer_argument;
+  }
+
+  double px, py;
+  matrix->matrix.compute_principal_point(image_width, image_height, px, py);
+
+  if (out_principal_point_x) *out_principal_point_x = px;
+  if (out_principal_point_y) *out_principal_point_y = py;
+
+  return heif_error_success;
+}
+
+
+heif_error heif_property_camera_intrinsic_matrix_get_skew(const heif_property_camera_intrinsic_matrix* matrix,
+                                                          double* out_skew)
+{
+  if (!matrix || !out_skew) {
+    return heif_error_null_pointer_argument;
+  }
+
+  *out_skew = matrix->matrix.skew;
+
+  return heif_error_success;
+}
+
+
+heif_property_camera_intrinsic_matrix* heif_property_camera_intrinsic_matrix_alloc()
+{
+  return new heif_property_camera_intrinsic_matrix;
+}
+
+void heif_property_camera_intrinsic_matrix_set_simple(heif_property_camera_intrinsic_matrix* matrix,
+                                                      int image_width, int image_height,
+                                                      double focal_length, double principal_point_x, double principal_point_y)
+{
+  if (!matrix) {
+    return;
+  }
+
+  matrix->matrix.is_anisotropic = false;
+  matrix->matrix.focal_length_x = focal_length / image_width;
+  matrix->matrix.principal_point_x = principal_point_x / image_width;
+  matrix->matrix.principal_point_y = principal_point_y / image_height;
+}
+
+void heif_property_camera_intrinsic_matrix_set_full(heif_property_camera_intrinsic_matrix* matrix,
+                                                    int image_width, int image_height,
+                                                    double focal_length_x,
+                                                    double focal_length_y,
+                                                    double principal_point_x, double principal_point_y,
+                                                    double skew)
+{
+  if (!matrix) {
+    return;
+  }
+
+  if (focal_length_x == focal_length_y && skew == 0) {
+    heif_property_camera_intrinsic_matrix_set_simple(matrix, image_width, image_height, focal_length_x, principal_point_x, principal_point_y);
+    return;
+  }
+
+  matrix->matrix.is_anisotropic = true;
+  matrix->matrix.focal_length_x = focal_length_x / image_width;
+  matrix->matrix.focal_length_y = focal_length_y / image_width;
+  matrix->matrix.principal_point_x = principal_point_x / image_width;
+  matrix->matrix.principal_point_y = principal_point_y / image_height;
+  matrix->matrix.skew = skew;
+}
+
+
+heif_error heif_item_add_property_camera_intrinsic_matrix(const heif_context* context,
+                                                          heif_item_id itemId,
+                                                          const heif_property_camera_intrinsic_matrix* matrix,
+                                                          heif_property_id* out_propertyId)
+{
+  if (!context || !matrix) {
+    return heif_error_null_pointer_argument;
+  }
+
+  auto cmin = std::make_shared<Box_cmin>();
+  cmin->set_intrinsic_matrix(matrix->matrix);
+
+  heif_property_id id = context->context->add_property(itemId, cmin, false);
+
+  if (out_propertyId) {
+    *out_propertyId = id;
+  }
+
+  return heif_error_success;
+}
+
+
+struct heif_property_camera_extrinsic_matrix
+{
+  Box_cmex::ExtrinsicMatrix matrix;
+};
+
+
+heif_error heif_item_get_property_camera_extrinsic_matrix(const heif_context* context,
+                                                          heif_item_id itemId,
+                                                          heif_property_id propertyId,
+                                                          heif_property_camera_extrinsic_matrix** out_matrix)
+{
+  if (!out_matrix || !context) {
+    return heif_error_null_pointer_argument;
+  }
+
+  auto cmex = context->context->find_property<Box_cmex>(itemId, propertyId);
+  if (!cmex) {
+    return cmex.error_struct(context->context.get());
+  }
+
+  *out_matrix = new heif_property_camera_extrinsic_matrix;
+  (*out_matrix)->matrix = (*cmex)->get_extrinsic_matrix();
+
+  return heif_error_success;
+}
+
+
+void heif_property_camera_extrinsic_matrix_release(heif_property_camera_extrinsic_matrix* matrix)
+{
+  delete matrix;
+}
+
+
+heif_error heif_property_camera_extrinsic_matrix_get_rotation_matrix(const heif_property_camera_extrinsic_matrix* matrix,
+                                                                     double* out_matrix)
+{
+  if (!matrix || !out_matrix) {
+    return heif_error_null_pointer_argument;
+  }
+
+  auto rot_matrix = matrix->matrix.calculate_rotation_matrix();
+  for (int i = 0; i < 9; i++) {
+    out_matrix[i] = rot_matrix[i];
+  }
+
+  return heif_error_success;
+}
+
+
+heif_error heif_property_camera_extrinsic_matrix_get_position_vector(const heif_property_camera_extrinsic_matrix* matrix,
+                                                                     int32_t* out_vector)
+{
+  if (!matrix || !out_vector) {
+    return heif_error_null_pointer_argument;
+  }
+
+  out_vector[0] = matrix->matrix.pos_x;
+  out_vector[1] = matrix->matrix.pos_y;
+  out_vector[2] = matrix->matrix.pos_z;
+
+  return heif_error_success;
+}
+
+
+heif_error heif_property_camera_extrinsic_matrix_get_world_coordinate_system_id(const heif_property_camera_extrinsic_matrix* matrix,
+                                                                                uint32_t* out_wcs_id)
+{
+  if (!matrix || !out_wcs_id) {
+    return heif_error_null_pointer_argument;
+  }
+
+  *out_wcs_id = matrix->matrix.world_coordinate_system_id;
+
+  return heif_error_success;
+}
+
+
+#if HEIF_ENABLE_EXPERIMENTAL_FEATURES
+
+heif_error heif_context_add_pyramid_entity_group(struct heif_context* ctx,
+                                                 const heif_item_id* layer_item_ids,
+                                                 size_t num_layers,
+                                                 /*
+                                                 uint16_t tile_width,
+                                                 uint16_t tile_height,
+                                                 uint32_t num_layers,
+                                                 const heif_pyramid_layer_info* in_layers,
+                                                  */
+                                                 heif_item_id* out_group_id)
+{
+  if (!layer_item_ids) {
+    return heif_error_null_pointer_argument;
+  }
+
+  if (num_layers == 0) {
+    return {heif_error_Usage_error, heif_suberror_Invalid_parameter_value, "Number of layers cannot be 0."};
+  }
+
+  std::vector<heif_item_id> layers(num_layers);
+  for (size_t i = 0; i < num_layers; i++) {
+    layers[i] = layer_item_ids[i];
+  }
+
+  Result<heif_item_id> result = ctx->context->add_pyramid_group(layers);
+
+  if (result) {
+    if (out_group_id) {
+      *out_group_id = result;
+    }
+    return heif_error_success;
+  }
+  else {
+    return result.error_struct(ctx->context.get());
+  }
+}
+
+
+heif_pyramid_layer_info* heif_context_get_pyramid_entity_group_info(heif_context* ctx, heif_entity_group_id id, int* out_num_layers)
+{
+  if (!out_num_layers) {
+    return nullptr;
+  }
+
+  std::shared_ptr<Box_EntityToGroup> groupBox = ctx->context->get_heif_file()->get_entity_group(id);
+  if (!groupBox) {
+    return nullptr;
+  }
+
+  const auto pymdBox = std::dynamic_pointer_cast<Box_pymd>(groupBox);
+  if (!pymdBox) {
+    return nullptr;
+  }
+
+  const std::vector<Box_pymd::LayerInfo> pymd_layers = pymdBox->get_layers();
+  if (pymd_layers.empty()) {
+    return nullptr;
+  }
+
+  auto items = pymdBox->get_item_ids();
+  assert(items.size() == pymd_layers.size());
+
+  auto* layerInfo = new heif_pyramid_layer_info[pymd_layers.size()];
+  for (size_t i = 0; i < pymd_layers.size(); i++) {
+    layerInfo[i].layer_image_id = items[i];
+    layerInfo[i].layer_binning = pymd_layers[i].layer_binning;
+    layerInfo[i].tile_rows_in_layer = pymd_layers[i].tiles_in_layer_row_minus1 + 1;
+    layerInfo[i].tile_columns_in_layer = pymd_layers[i].tiles_in_layer_column_minus1 + 1;
+  }
+
+  *out_num_layers = static_cast<int>(pymd_layers.size());
+
+  return layerInfo;
+}
+
+
+void heif_pyramid_layer_info_release(heif_pyramid_layer_info* infos)
+{
+  delete[] infos;
+}
+
+
+#endif
+
+
+#if HEIF_ENABLE_EXPERIMENTAL_FEATURES
+heif_error heif_context_add_tiled_image(heif_context* ctx,
+                                        const heif_tiled_image_parameters* parameters,
+                                        const heif_encoding_options* options,
+                                        const heif_encoder* encoder,
+                                        heif_image_handle** out_grid_image_handle)
+{
+  if (out_grid_image_handle) {
+    *out_grid_image_handle = nullptr;
+  }
+
+  Result<std::shared_ptr<ImageItem_Tiled> > gridImageResult;
+  gridImageResult = ImageItem_Tiled::add_new_tiled_item(ctx->context.get(), parameters, encoder, options);
+
+  if (!gridImageResult) {
+    return gridImageResult.error_struct(ctx->context.get());
+  }
+
+  if (out_grid_image_handle) {
+    *out_grid_image_handle = new heif_image_handle;
+    (*out_grid_image_handle)->image = *gridImageResult;
+    (*out_grid_image_handle)->context = ctx->context;
+  }
+
+  return heif_error_success;
+}
+#endif
diff --git a/libheif/api/libheif/heif_experimental.h b/libheif/api/libheif/heif_experimental.h
new file mode 100644
index 0000000000..e2d35d4cdf
--- /dev/null
+++ b/libheif/api/libheif/heif_experimental.h
@@ -0,0 +1,185 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_HEIF_EXPERIMENTAL_H
+#define LIBHEIF_HEIF_EXPERIMENTAL_H
+
+#include "libheif/heif.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if HEIF_ENABLE_EXPERIMENTAL_FEATURES
+
+/* ===================================================================================
+ *   This file contains candidate APIs that did not make it into the public API yet.
+ * ===================================================================================
+ */
+
+
+/*
+heif_item_property_type_camera_intrinsic_matrix = heif_fourcc('c', 'm', 'i', 'n'),
+heif_item_property_type_camera_extrinsic_matrix = heif_fourcc('c', 'm', 'e', 'x')
+*/
+
+typedef struct heif_property_camera_intrinsic_matrix heif_property_camera_intrinsic_matrix;
+typedef struct heif_property_camera_extrinsic_matrix heif_property_camera_extrinsic_matrix;
+
+//LIBHEIF_API
+heif_error heif_item_get_property_camera_intrinsic_matrix(const heif_context* context,
+                                                          heif_item_id itemId,
+                                                          heif_property_id propertyId,
+                                                          heif_property_camera_intrinsic_matrix** out_matrix);
+
+//LIBHEIF_API
+void heif_property_camera_intrinsic_matrix_release(heif_property_camera_intrinsic_matrix* matrix);
+
+//LIBHEIF_API
+heif_error heif_property_camera_intrinsic_matrix_get_focal_length(const heif_property_camera_intrinsic_matrix* matrix,
+                                                                  int image_width, int image_height,
+                                                                  double* out_focal_length_x,
+                                                                  double* out_focal_length_y);
+
+//LIBHEIF_API
+heif_error heif_property_camera_intrinsic_matrix_get_principal_point(const heif_property_camera_intrinsic_matrix* matrix,
+                                                                     int image_width, int image_height,
+                                                                     double* out_principal_point_x,
+                                                                     double* out_principal_point_y);
+
+//LIBHEIF_API
+heif_error heif_property_camera_intrinsic_matrix_get_skew(const heif_property_camera_intrinsic_matrix* matrix,
+                                                          double* out_skew);
+
+//LIBHEIF_API
+heif_property_camera_intrinsic_matrix* heif_property_camera_intrinsic_matrix_alloc(void);
+
+//LIBHEIF_API
+void heif_property_camera_intrinsic_matrix_set_simple(heif_property_camera_intrinsic_matrix* matrix,
+                                                      int image_width, int image_height,
+                                                      double focal_length, double principal_point_x, double principal_point_y);
+
+//LIBHEIF_API
+void heif_property_camera_intrinsic_matrix_set_full(heif_property_camera_intrinsic_matrix* matrix,
+                                                    int image_width, int image_height,
+                                                    double focal_length_x,
+                                                    double focal_length_y,
+                                                    double principal_point_x, double principal_point_y,
+                                                    double skew);
+
+//LIBHEIF_API
+heif_error heif_item_add_property_camera_intrinsic_matrix(const heif_context* context,
+                                                          heif_item_id itemId,
+                                                          const heif_property_camera_intrinsic_matrix* matrix,
+                                                          heif_property_id* out_propertyId);
+
+
+//LIBHEIF_API
+heif_error heif_item_get_property_camera_extrinsic_matrix(const heif_context* context,
+                                                          heif_item_id itemId,
+                                                          heif_property_id propertyId,
+                                                          heif_property_camera_extrinsic_matrix** out_matrix);
+
+//LIBHEIF_API
+void heif_property_camera_extrinsic_matrix_release(heif_property_camera_extrinsic_matrix* matrix);
+
+// `out_matrix` must point to a 9-element matrix, which will be filled in row-major order.
+//LIBHEIF_API
+heif_error heif_property_camera_extrinsic_matrix_get_rotation_matrix(const heif_property_camera_extrinsic_matrix* matrix,
+                                                                     double* out_matrix);
+
+// `out_vector` must point to a 3-element vector, which will be filled with the (X,Y,Z) coordinates (in micrometers).
+//LIBHEIF_API
+heif_error heif_property_camera_extrinsic_matrix_get_position_vector(const heif_property_camera_extrinsic_matrix* matrix,
+                                                                     int32_t* out_vector);
+
+//LIBHEIF_API
+heif_error heif_property_camera_extrinsic_matrix_get_world_coordinate_system_id(const heif_property_camera_extrinsic_matrix* matrix,
+                                                                                uint32_t* out_wcs_id);
+#endif
+
+// --- Tiled images
+
+typedef struct heif_tiled_image_parameters
+{
+  int version;
+
+  // --- version 1
+
+  uint32_t image_width;
+  uint32_t image_height;
+
+  uint32_t tile_width;
+  uint32_t tile_height;
+
+  uint32_t compression_format_fourcc;  // will be set automatically when calling heif_context_add_tiled_image()
+
+  uint8_t offset_field_length;   // one of: 32, 40, 48, 64
+  uint8_t size_field_length;     // one of:  0, 24, 32, 64
+
+  uint8_t number_of_extra_dimensions;  // 0 for normal images, 1 for volumetric (3D), ...
+  uint32_t extra_dimensions[8];        // size of extra dimensions (first 8 dimensions)
+
+  // boolean flags
+  uint8_t tiles_are_sequential;  // TODO: can we derive this automatically
+} heif_tiled_image_parameters;
+
+#if HEIF_ENABLE_EXPERIMENTAL_FEATURES
+LIBHEIF_API
+heif_error heif_context_add_tiled_image(heif_context* ctx,
+                                        const heif_tiled_image_parameters* parameters,
+                                        const heif_encoding_options* options, // TODO: do we need this?
+                                        const heif_encoder* encoder,
+                                        heif_image_handle** out_tiled_image_handle);
+#endif
+
+// --- 'pymd' entity group (pyramid layers)
+
+typedef struct heif_pyramid_layer_info
+{
+  heif_item_id layer_image_id;
+  uint16_t layer_binning;
+  uint32_t tile_rows_in_layer;
+  uint32_t tile_columns_in_layer;
+} heif_pyramid_layer_info;
+
+#if HEIF_ENABLE_EXPERIMENTAL_FEATURES
+// The input images are automatically sorted according to resolution. You can provide them in any order.
+LIBHEIF_API
+heif_error heif_context_add_pyramid_entity_group(heif_context* ctx,
+                                                 const heif_item_id* layer_item_ids,
+                                                 size_t num_layers,
+                                                 heif_item_id* out_group_id);
+
+LIBHEIF_API
+heif_pyramid_layer_info* heif_context_get_pyramid_entity_group_info(heif_context*,
+                                                                    heif_entity_group_id id,
+                                                                    int* out_num_layers);
+
+LIBHEIF_API
+void heif_pyramid_layer_info_release(heif_pyramid_layer_info*);
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/libheif/api/libheif/heif_image.cc b/libheif/api/libheif/heif_image.cc
new file mode 100644
index 0000000000..013fff39a4
--- /dev/null
+++ b/libheif/api/libheif/heif_image.cc
@@ -0,0 +1,412 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "heif_image.h"
+#include "heif.h"
+#include "pixelimage.h"
+#include "api_structs.h"
+#include "error.h"
+#include <limits>
+
+#include <algorithm>
+#include <memory>
+#include <utility>
+#include <cstring>
+#include <array>
+
+
+heif_colorspace heif_image_get_colorspace(const heif_image* img)
+{
+  return img->image->get_colorspace();
+}
+
+heif_chroma heif_image_get_chroma_format(const heif_image* img)
+{
+  return img->image->get_chroma_format();
+}
+
+
+static int uint32_to_int(uint32_t v)
+{
+  if (v == 0 || v > static_cast<uint64_t>(std::numeric_limits<int>::max())) {
+    return -1;
+  }
+  else {
+    return static_cast<int>(v);
+  }
+}
+
+
+int heif_image_get_width(const heif_image* img, heif_channel channel)
+{
+  return uint32_to_int(img->image->get_width(channel));
+}
+
+
+int heif_image_get_height(const heif_image* img, heif_channel channel)
+{
+  return uint32_to_int(img->image->get_height(channel));
+}
+
+
+int heif_image_get_primary_width(const heif_image* img)
+{
+  uint32_t primary_component = img->image->get_primary_component();
+  return uint32_to_int(img->image->get_width(primary_component));
+}
+
+
+int heif_image_get_primary_height(const heif_image* img)
+{
+  uint32_t primary_component = img->image->get_primary_component();
+  return uint32_to_int(img->image->get_height(primary_component));
+}
+
+
+heif_error heif_image_crop(heif_image* img,
+                           int left, int right, int top, int bottom)
+{
+  uint32_t w = img->image->get_width();
+  uint32_t h = img->image->get_height();
+
+  if (w == 0 || w > 0x7FFFFFFF ||
+      h == 0 || h > 0x7FFFFFFF) {
+    return heif_error{
+      heif_error_Usage_error,
+      heif_suberror_Invalid_image_size,
+      "Image size exceeds maximum supported size"
+    };
+  }
+
+  auto cropResult = img->image->crop(left, static_cast<int>(w) - 1 - right, top, static_cast<int>(h) - 1 - bottom, nullptr);
+  if (!cropResult) {
+    return cropResult.error_struct(img->image.get());
+  }
+
+  img->image = *cropResult;
+
+  return heif_error_success;
+}
+
+
+heif_error heif_image_extract_area(const heif_image* srcimg,
+                                   uint32_t x0, uint32_t y0, uint32_t w, uint32_t h,
+                                   const heif_security_limits* limits,
+                                   heif_image** out_image)
+{
+  auto extractResult = srcimg->image->extract_image_area(x0, y0, w, h, limits);
+  if (!extractResult) {
+    return extractResult.error_struct(srcimg->image.get());
+  }
+
+  heif_image* area = new heif_image;
+  area->image = *extractResult;
+
+  *out_image = area;
+
+  return heif_error_success;
+}
+
+
+int heif_image_get_bits_per_pixel(const heif_image* img, heif_channel channel)
+{
+  return img->image->get_storage_bits_per_pixel(channel);
+}
+
+
+int heif_image_get_bits_per_pixel_range(const heif_image* img, heif_channel channel)
+{
+  return img->image->get_bits_per_pixel(channel);
+}
+
+
+int heif_image_has_channel(const heif_image* img, heif_channel channel)
+{
+  return img->image->has_channel(channel);
+}
+
+
+const uint8_t* heif_image_get_plane_readonly(const heif_image* image,
+                                             heif_channel channel,
+                                             int* out_stride)
+{
+  if (!out_stride) {
+    return nullptr;
+  }
+
+  if (!image || !image->image) {
+    *out_stride = 0;
+    return nullptr;
+  }
+
+  size_t stride;
+  const auto* p = image->image->get_plane(channel, &stride);
+
+  // TODO: use C++20 std::cmp_greater()
+  if (stride > static_cast<uint32_t>(std::numeric_limits<int>::max())) {
+    return nullptr;
+  }
+
+  *out_stride = static_cast<int>(stride);
+  return p;
+}
+
+
+uint8_t* heif_image_get_plane(heif_image* image,
+                              heif_channel channel,
+                              int* out_stride)
+{
+  if (!out_stride) {
+    return nullptr;
+  }
+
+  if (!image || !image->image) {
+    *out_stride = 0;
+    return nullptr;
+  }
+
+  size_t stride;
+  uint8_t* p = image->image->get_plane(channel, &stride);
+
+  // TODO: use C++20 std::cmp_greater()
+  if (stride > static_cast<uint32_t>(std::numeric_limits<int>::max())) {
+    return nullptr;
+  }
+
+  *out_stride = static_cast<int>(stride);
+  return p;
+}
+
+
+const uint8_t* heif_image_get_plane_readonly2(const heif_image* image,
+                                              heif_channel channel,
+                                              size_t* out_stride)
+{
+  if (!out_stride) {
+    return nullptr;
+  }
+
+  if (!image || !image->image) {
+    *out_stride = 0;
+    return nullptr;
+  }
+
+  return image->image->get_plane(channel, out_stride);
+}
+
+
+uint8_t* heif_image_get_plane2(heif_image* image,
+                               heif_channel channel,
+                               size_t* out_stride)
+{
+  if (!out_stride) {
+    return nullptr;
+  }
+
+  if (!image || !image->image) {
+    *out_stride = 0;
+    return nullptr;
+  }
+
+  return image->image->get_plane(channel, out_stride);
+}
+
+
+heif_error heif_image_scale_image(const heif_image* input,
+                                  heif_image** output,
+                                  int width, int height,
+                                  const heif_scaling_options* options)
+{
+  std::shared_ptr<HeifPixelImage> out_img;
+
+  Error err = input->image->scale_nearest_neighbor(out_img, width, height, nullptr);
+  if (err) {
+    return err.error_struct(input->image.get());
+  }
+
+  *output = new heif_image;
+  (*output)->image = std::move(out_img);
+
+  return Error::Ok.error_struct(input->image.get());
+}
+
+
+heif_error heif_image_extend_to_size_fill_with_zero(heif_image* image,
+                                                    uint32_t width, uint32_t height)
+{
+  Error err = image->image->extend_to_size_with_zero(width, height, nullptr);
+  if (err) {
+    return err.error_struct(image->image.get());
+  }
+
+  return heif_error_ok;
+}
+
+
+int heif_image_get_decoding_warnings(heif_image* image,
+                                     int first_warning_idx,
+                                     heif_error* out_warnings,
+                                     int max_output_buffer_entries)
+{
+  if (max_output_buffer_entries == 0) {
+    return (int) image->image->get_warnings().size();
+  }
+  else {
+    const auto& warnings = image->image->get_warnings();
+    int n;
+    for (n = 0; n + first_warning_idx < (int) warnings.size() && n < max_output_buffer_entries; n++) {
+      out_warnings[n] = warnings[n + first_warning_idx].error_struct(image->image.get());
+    }
+    return n;
+  }
+}
+
+void heif_image_add_decoding_warning(heif_image* image,
+                                     heif_error err)
+{
+  image->image->add_warning(Error(err.code, err.subcode));
+}
+
+
+void heif_image_release(const heif_image* img)
+{
+  delete img;
+}
+
+
+void heif_image_get_pixel_aspect_ratio(const heif_image* image, uint32_t* aspect_h, uint32_t* aspect_v)
+{
+  image->image->get_pixel_ratio(aspect_h, aspect_v);
+}
+
+
+void heif_image_set_pixel_aspect_ratio(heif_image* image, uint32_t aspect_h, uint32_t aspect_v)
+{
+  image->image->set_pixel_ratio(aspect_h, aspect_v);
+}
+
+void heif_image_handle_set_pixel_aspect_ratio(heif_image_handle* handle, uint32_t aspect_h, uint32_t aspect_v)
+{
+  handle->image->set_pixel_ratio(aspect_h, aspect_v);
+}
+
+#if HEIF_WITH_OMAF
+heif_omaf_image_projection heif_image_get_omaf_image_projection(const heif_image* image)
+{
+  return image->image->get_omaf_image_projection();
+}
+
+void heif_image_set_omaf_image_projection(const heif_image* image, heif_omaf_image_projection image_projection)
+{
+  return image->image->set_omaf_image_projection(image_projection);
+}
+#endif
+
+heif_error heif_image_create(int width, int height,
+                             heif_colorspace colorspace,
+                             heif_chroma chroma,
+                             heif_image** image)
+{
+  if (image == nullptr) {
+    return heif_error_null_pointer_argument;
+  }
+
+  // auto-correct colorspace_YCbCr + chroma_monochrome to colorspace_monochrome
+  // TODO: this should return an error in a later version (see below)
+  if (chroma == heif_chroma_monochrome && colorspace == heif_colorspace_YCbCr) {
+    colorspace = heif_colorspace_monochrome;
+
+    std::cerr << "libheif warning: heif_image_create() used with an illegal colorspace/chroma combination. This will return an error in a future version.\n";
+  }
+
+  // return error if invalid colorspace + chroma combination is used
+  auto validChroma = get_valid_chroma_values_for_colorspace(colorspace);
+  if (std::find(validChroma.begin(), validChroma.end(), chroma) == validChroma.end()) {
+    *image = nullptr;
+    return {heif_error_Usage_error, heif_suberror_Invalid_parameter_value, "Invalid colorspace/chroma combination."};
+  }
+
+  heif_image* img = new heif_image;
+  img->image = std::make_shared<HeifPixelImage>();
+
+  img->image->create(width, height, colorspace, chroma);
+
+  *image = img;
+
+  return heif_error_success;
+}
+
+heif_error heif_image_add_plane(heif_image* image,
+                                heif_channel channel, int width, int height, int bit_depth)
+{
+  // Note: no security limit, because this is explicitly requested by the user.
+  if (auto err = image->image->add_plane(channel, width, height, bit_depth, nullptr)) {
+    return err.error_struct(image->image.get());
+  }
+  else {
+    return heif_error_success;
+  }
+}
+
+
+heif_error heif_image_add_plane_safe(heif_image* image,
+                                     heif_channel channel, int width, int height, int bit_depth,
+                                     const heif_security_limits* limits)
+{
+  if (auto err = image->image->add_plane(channel, width, height, bit_depth, limits)) {
+    return err.error_struct(image->image.get());
+  }
+  else {
+    return heif_error_success;
+  }
+}
+
+
+void heif_image_set_premultiplied_alpha(heif_image* image,
+                                        int is_premultiplied_alpha)
+{
+  if (image == nullptr) {
+    return;
+  }
+
+  image->image->set_premultiplied_alpha(is_premultiplied_alpha);
+}
+
+
+int heif_image_is_premultiplied_alpha(heif_image* image)
+{
+  if (image == nullptr) {
+    return 0;
+  }
+
+  return image->image->is_premultiplied_alpha();
+}
+
+
+heif_error heif_image_extend_padding_to_size(heif_image* image, int min_physical_width, int min_physical_height)
+{
+  Error err = image->image->extend_padding_to_size(min_physical_width, min_physical_height, false, nullptr);
+  if (err) {
+    return err.error_struct(image->image.get());
+  }
+  else {
+    return heif_error_success;
+  }
+}
diff --git a/libheif/api/libheif/heif_image.h b/libheif/api/libheif/heif_image.h
new file mode 100644
index 0000000000..ae24712ce2
--- /dev/null
+++ b/libheif/api/libheif/heif_image.h
@@ -0,0 +1,399 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017-2025 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_HEIF_IMAGE_H
+#define LIBHEIF_HEIF_IMAGE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <libheif/heif_library.h>
+#include <libheif/heif_error.h>
+#include <stddef.h>
+#include <stdint.h>
+
+
+typedef enum heif_chroma
+{
+  heif_chroma_undefined = 99,
+  heif_chroma_monochrome = 0,
+  heif_chroma_420 = 1,
+  heif_chroma_422 = 2,
+  heif_chroma_444 = 3,
+  heif_chroma_interleaved_RGB = 10,
+  heif_chroma_interleaved_RGBA = 11,
+  heif_chroma_interleaved_RRGGBB_BE = 12,   // HDR, big endian.
+  heif_chroma_interleaved_RRGGBBAA_BE = 13, // HDR, big endian.
+  heif_chroma_interleaved_RRGGBB_LE = 14,   // HDR, little endian.
+  heif_chroma_interleaved_RRGGBBAA_LE = 15  // HDR, little endian.
+} heif_chroma;
+
+// DEPRECATED ENUM NAMES
+#define heif_chroma_interleaved_24bit  heif_chroma_interleaved_RGB
+#define heif_chroma_interleaved_32bit  heif_chroma_interleaved_RGBA
+
+
+typedef enum heif_colorspace
+{
+  heif_colorspace_undefined = 99,
+
+  // heif_colorspace_YCbCr should be used with one of these heif_chroma values:
+  // * heif_chroma_444
+  // * heif_chroma_422
+  // * heif_chroma_420
+  heif_colorspace_YCbCr = 0,
+
+  // heif_colorspace_RGB should be used with one of these heif_chroma values:
+  // * heif_chroma_444 (for planar RGB)
+  // * heif_chroma_interleaved_RGB
+  // * heif_chroma_interleaved_RGBA
+  // * heif_chroma_interleaved_RRGGBB_BE
+  // * heif_chroma_interleaved_RRGGBBAA_BE
+  // * heif_chroma_interleaved_RRGGBB_LE
+  // * heif_chroma_interleaved_RRGGBBAA_LE
+  heif_colorspace_RGB = 1,
+
+  // heif_colorspace_monochrome should only be used with heif_chroma = heif_chroma_monochrome
+  heif_colorspace_monochrome = 2,
+
+  // Indicates that this image has no visual channels.
+  heif_colorspace_nonvisual = 3,
+
+  heif_colorspace_filter_array = 4
+} heif_colorspace;
+
+typedef enum heif_channel
+{
+  heif_channel_Y = 0,
+  heif_channel_Cb = 1,
+  heif_channel_Cr = 2,
+  heif_channel_R = 3,
+  heif_channel_G = 4,
+  heif_channel_B = 5,
+  heif_channel_Alpha = 6,
+  heif_channel_interleaved = 10,
+  heif_channel_filter_array = 11,
+  heif_channel_depth = 12,
+  heif_channel_disparity = 13,
+  heif_channel_unknown = 65535
+} heif_channel;
+
+#if HEIF_WITH_OMAF
+/**
+ * OMAF Image projection.
+ *
+ * The image projection for most images is flat - it is projected as intended to be shown on
+ * a flat screen or print. For immersive or omnidirectional media (e.g. VR headsets, or
+ * equivalent), there are alternatives such as an equirectangular projection or cubemap projection.
+ *
+ * See ISO/IEC 23090-2 "Omnidirectional media format" for more information.
+ */
+typedef enum heif_omaf_image_projection
+{
+  /**
+   * Equirectangular projection.
+   */
+  heif_omaf_image_projection_equirectangular = 0x00,
+
+  /**
+   * Cube map.
+   */
+  heif_omaf_image_projection_cube_map = 0x01,
+
+  /* Values 2 through 31 are reserved in ISO/IEC 23090-2:2023 Table 10. */
+  /**
+   * Projection is specified, but not recognised.
+   */
+  heif_omaf_image_projection_unknown = 0xFE,
+
+  /**
+   * Flat projection, assumed if no projection information provided.
+   */
+  heif_omaf_image_projection_flat = 0xFF,
+} heif_omaf_image_projection;
+#endif
+
+// An heif_image contains a decoded pixel image in various colorspaces, chroma formats,
+// and bit depths.
+
+// Note: when converting images to an interleaved chroma format, the resulting
+// image contains only a single channel of type channel_interleaved with, e.g., 3 bytes per pixel,
+// containing the interleaved R,G,B values.
+
+// Planar RGB images are specified as heif_colorspace_RGB / heif_chroma_444.
+
+typedef struct heif_image heif_image;
+typedef struct heif_image_handle heif_image_handle;
+typedef struct heif_security_limits heif_security_limits;
+
+
+// Get the colorspace format of the image.
+LIBHEIF_API
+enum heif_colorspace heif_image_get_colorspace(const heif_image*);
+
+// Get the chroma format of the image.
+LIBHEIF_API
+enum heif_chroma heif_image_get_chroma_format(const heif_image*);
+
+/**
+ * Get the width of a specified image channel.
+ *
+ * @param img the image to get the width for
+ * @param channel the channel to select
+ * @return the width of the channel in pixels, or -1 the channel does not exist in the image
+ */
+LIBHEIF_API
+int heif_image_get_width(const heif_image* img, enum heif_channel channel);
+
+/**
+ * Get the height of a specified image channel.
+ *
+ * @param img the image to get the height for
+ * @param channel the channel to select
+ * @return the height of the channel in pixels, or -1 the channel does not exist in the image
+ */
+LIBHEIF_API
+int heif_image_get_height(const heif_image* img, enum heif_channel channel);
+
+/**
+ * Get the width of the main channel.
+ *
+ * This is the Y channel in YCbCr or mono, or any in RGB.
+ *
+ * @param img the image to get the primary width for
+ * @return the width in pixels
+ */
+LIBHEIF_API
+int heif_image_get_primary_width(const heif_image* img);
+
+/**
+ * Get the height of the main channel.
+ *
+ * This is the Y channel in YCbCr or mono, or any in RGB.
+ *
+ * @param img the image to get the primary height for
+ * @return the height in pixels
+ */
+LIBHEIF_API
+int heif_image_get_primary_height(const heif_image* img);
+
+LIBHEIF_API
+heif_error heif_image_crop(heif_image* img,
+                           int left, int right, int top, int bottom);
+
+LIBHEIF_API
+heif_error heif_image_extract_area(const heif_image*,
+                                   uint32_t x0, uint32_t y0, uint32_t w, uint32_t h,
+                                   const heif_security_limits* limits,
+                                   heif_image** out_image);
+
+// Get the number of bits per pixel in the given image channel. Returns -1 if
+// a non-existing channel was given.
+// Note that the number of bits per pixel may be different for each color channel.
+// This function returns the number of bits used for storage of each pixel.
+// Especially for HDR images, this is probably not what you want. Have a look at
+// heif_image_get_bits_per_pixel_range() instead.
+LIBHEIF_API
+int heif_image_get_bits_per_pixel(const heif_image*, enum heif_channel channel);
+
+// Get the number of bits per pixel in the given image channel. This function returns
+// the number of bits used for representing the pixel value, which might be smaller
+// than the number of bits used in memory.
+// For example, in 12bit HDR images, this function returns '12', while still 16 bits
+// are reserved for storage. For interleaved RGBA with 12 bit, this function also returns
+// '12', not '48' or '64' (heif_image_get_bits_per_pixel returns 64 in this case).
+LIBHEIF_API
+int heif_image_get_bits_per_pixel_range(const heif_image*, enum heif_channel channel);
+
+LIBHEIF_API
+int heif_image_has_channel(const heif_image*, enum heif_channel channel);
+
+// Get a pointer to the actual pixel data.
+// The 'out_stride' is returned as "bytes per line".
+// When out_stride is NULL, no value will be written.
+// Returns NULL if a non-existing channel was given.
+// Deprecated, use the safer version heif_image_get_plane_readonly2() instead.
+LIBHEIF_API
+const uint8_t* heif_image_get_plane_readonly(const heif_image*,
+                                             enum heif_channel channel,
+                                             int* out_stride);
+
+// Deprecated, use the safer version heif_image_get_plane2() instead.
+LIBHEIF_API
+uint8_t* heif_image_get_plane(heif_image*,
+                              enum heif_channel channel,
+                              int* out_stride);
+
+// These are safer variants of the two functions above.
+// The 'stride' parameter is often multiplied by the image height in the client application.
+// For very large images, this can lead to integer overflows and, consequently, illegal memory accesses.
+// The changed 'stride' parameter type eliminates this common error.
+LIBHEIF_API
+const uint8_t* heif_image_get_plane_readonly2(const heif_image*,
+                                              enum heif_channel channel,
+                                              size_t* out_stride);
+
+LIBHEIF_API
+uint8_t* heif_image_get_plane2(heif_image*,
+                               enum heif_channel channel,
+                               size_t* out_stride);
+
+
+typedef struct heif_scaling_options heif_scaling_options;
+
+// Currently, heif_scaling_options is not defined yet. Pass a NULL pointer.
+LIBHEIF_API
+heif_error heif_image_scale_image(const heif_image* input,
+                                  heif_image** output,
+                                  int width, int height,
+                                  const heif_scaling_options* options);
+
+// Extends the image size to match the given size by extending the right and bottom borders.
+// The border areas are filled with zero.
+LIBHEIF_API
+heif_error heif_image_extend_to_size_fill_with_zero(heif_image* image,
+                                                    uint32_t width, uint32_t height);
+
+// Fills the image decoding warnings into the provided 'out_warnings' array.
+// The size of the array has to be provided in max_output_buffer_entries.
+// If max_output_buffer_entries==0, the number of decoder warnings is returned.
+// The function fills the warnings into the provided buffer, starting with 'first_warning_idx'.
+// It returns the number of warnings filled into the buffer.
+// Note: you can iterate through all warnings by using 'max_output_buffer_entries=1' and iterate 'first_warning_idx'.
+LIBHEIF_API
+int heif_image_get_decoding_warnings(heif_image* image,
+                                     int first_warning_idx,
+                                     heif_error* out_warnings,
+                                     int max_output_buffer_entries);
+
+// This function is only for decoder plugin implementors.
+LIBHEIF_API
+void heif_image_add_decoding_warning(heif_image* image,
+                                     heif_error err);
+
+// Release heif_image.
+LIBHEIF_API
+void heif_image_release(const heif_image*);
+
+LIBHEIF_API
+void heif_image_get_pixel_aspect_ratio(const heif_image*, uint32_t* aspect_h, uint32_t* aspect_v);
+
+LIBHEIF_API
+void heif_image_set_pixel_aspect_ratio(heif_image*, uint32_t aspect_h, uint32_t aspect_v);
+
+LIBHEIF_API
+void heif_image_handle_set_pixel_aspect_ratio(heif_image_handle*, uint32_t aspect_h, uint32_t aspect_v);
+
+#if HEIF_WITH_OMAF
+LIBHEIF_API
+heif_omaf_image_projection heif_image_get_omaf_image_projection(const heif_image*);
+
+LIBHEIF_API
+void heif_image_set_omaf_image_projection(const heif_image*, heif_omaf_image_projection image_projection);
+#endif
+
+// --- heif_image allocation
+
+/**
+ * Create a new image of the specified resolution and colorspace.
+ *
+ * <p>This does not allocate memory for the image data. Use {@link heif_image_add_plane} to
+ * add the corresponding planes to match the specified {@code colorspace} and {@code chroma}.
+ *
+ * @param width the width of the image in pixels
+ * @param height the height of the image in pixels
+ * @param colorspace the colorspace of the image
+ * @param chroma the chroma of the image
+ * @param out_image pointer to pointer of the resulting image
+ * @return whether the creation succeeded or there was an error
+*/
+LIBHEIF_API
+heif_error heif_image_create(int width, int height,
+                             enum heif_colorspace colorspace,
+                             enum heif_chroma chroma,
+                             heif_image** out_image);
+
+/**
+ * Add an image plane to the image.
+ *
+ * <p>The image plane needs to match the colorspace and chroma of the image. Note
+ * that this does not need to be a single "planar" format - interleaved pixel channels
+ * can also be used if the chroma is interleaved.
+ *
+ * <p>The indicated bit_depth corresponds to the bit depth per channel. For example,
+ * with an interleaved format like RRGGBB where each color is represented by 10 bits,
+ * the {@code bit_depth} would be {@code 10} rather than {@code 30}.
+ *
+ * <p>For backward compatibility, one can also specify 24bits for RGB and 32bits for RGBA,
+ * instead of the preferred 8 bits. However, this use is deprecated.
+ *
+ * @param image the parent image to add the channel plane to
+ * @param channel the channel of the plane to add
+ * @param width the width of the plane
+ * @param height the height of the plane
+ * @param bit_depth the bit depth per color channel
+ * @return whether the addition succeeded or there was an error
+ *
+ * @note The width and height are usually the same as the parent image, but can be
+ * less for subsampling.
+ *
+ * @note The specified width can differ from the row stride of the resulting image plane.
+ * Always use the result of {@link heif_image_get_plane} or {@link heif_image_get_plane_readonly}
+ * to determine row stride.
+ */
+LIBHEIF_API
+heif_error heif_image_add_plane(heif_image* image,
+                                enum heif_channel channel,
+                                int width, int height, int bit_depth);
+
+/*
+ * The security limits should preferably be the limits from a heif_context.
+ * The memory allocated will then be registered in the memory budget of that context.
+ */
+LIBHEIF_API
+heif_error heif_image_add_plane_safe(heif_image* image,
+                                     enum heif_channel channel,
+                                     int width, int height, int bit_depth,
+                                     const heif_security_limits* limits);
+
+// Signal that the image is premultiplied by the alpha pixel values.
+LIBHEIF_API
+void heif_image_set_premultiplied_alpha(heif_image* image,
+                                        int is_premultiplied_alpha);
+
+LIBHEIF_API
+int heif_image_is_premultiplied_alpha(heif_image* image);
+
+// This function extends the padding of the image so that it has at least the given physical size.
+// The padding border is filled with the pixels along the right/bottom border.
+// This function may be useful if you want to process the image, but have some external padding requirements.
+// The image size will not be modified if it is already larger/equal than the given physical size.
+// I.e. you cannot assume that after calling this function, the stride will be equal to min_physical_width.
+LIBHEIF_API
+heif_error heif_image_extend_padding_to_size(heif_image* image,
+                                             int min_physical_width, int min_physical_height);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/libheif/api/libheif/heif_image_handle.cc b/libheif/api/libheif/heif_image_handle.cc
new file mode 100644
index 0000000000..20bf94680e
--- /dev/null
+++ b/libheif/api/libheif/heif_image_handle.cc
@@ -0,0 +1,348 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017-2025 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "heif_image_handle.h"
+#include "api_structs.h"
+#include "box.h"
+#if WITH_UNCOMPRESSED_CODEC
+#include "codecs/uncompressed/unc_boxes.h"
+#endif
+#include <climits>
+#include <cstring>
+#include <string>
+#include <memory>
+#include <vector>
+
+
+void heif_image_handle_release(const heif_image_handle* handle)
+{
+  delete handle;
+}
+
+
+int heif_image_handle_is_primary_image(const heif_image_handle* handle)
+{
+  return handle->image->is_primary();
+}
+
+
+heif_item_id heif_image_handle_get_item_id(const heif_image_handle* handle)
+{
+  return handle->image->get_id();
+}
+
+
+int heif_image_handle_get_width(const heif_image_handle* handle)
+{
+  if (handle && handle->image) {
+    uint32_t w = handle->image->get_width();
+    if (w > INT_MAX) {
+      return 0;
+    }
+    else {
+      return static_cast<int>(w);
+    }
+  }
+  else {
+    return 0;
+  }
+}
+
+
+int heif_image_handle_get_height(const heif_image_handle* handle)
+{
+  if (handle && handle->image) {
+    uint32_t h = handle->image->get_height();
+    if (h > INT_MAX) {
+      return 0;
+    }
+    else {
+      return static_cast<int>(h);
+    }
+  }
+  else {
+    return 0;
+  }
+}
+
+
+int heif_image_handle_has_alpha_channel(const heif_image_handle* handle)
+{
+  // TODO: for now, also scan the grid tiles for alpha information (issue #708), but depending about
+  // how the discussion about this structure goes forward, we might remove this again.
+
+  return handle->context->has_alpha(handle->image->get_id()); // handle case in issue #708
+  //return handle->image->get_alpha_channel() != nullptr;       // old alpha check that fails on alpha in grid tiles
+}
+
+
+int heif_image_handle_is_premultiplied_alpha(const heif_image_handle* handle)
+{
+  // TODO: what about images that have the alpha in the grid tiles (issue #708) ?
+  return handle->image->is_premultiplied_alpha();
+}
+
+
+int heif_image_handle_get_luma_bits_per_pixel(const heif_image_handle* handle)
+{
+  return handle->image->get_luma_bits_per_pixel();
+}
+
+
+int heif_image_handle_get_chroma_bits_per_pixel(const heif_image_handle* handle)
+{
+  return handle->image->get_chroma_bits_per_pixel();
+}
+
+
+heif_error heif_image_handle_get_preferred_decoding_colorspace(const heif_image_handle* image_handle,
+                                                               heif_colorspace* out_colorspace,
+                                                               heif_chroma* out_chroma)
+{
+  Error err = image_handle->image->get_coded_image_colorspace(out_colorspace, out_chroma);
+  if (err) {
+    return err.error_struct(image_handle->image.get());
+  }
+
+  return heif_error_success;
+}
+
+
+int heif_image_handle_get_ispe_width(const heif_image_handle* handle)
+{
+  if (handle && handle->image) {
+    return handle->image->get_ispe_width();
+  }
+  else {
+    return 0;
+  }
+}
+
+
+int heif_image_handle_get_ispe_height(const heif_image_handle* handle)
+{
+  if (handle && handle->image) {
+    return handle->image->get_ispe_height();
+  }
+  else {
+    return 0;
+  }
+}
+
+
+int heif_image_handle_get_pixel_aspect_ratio(const heif_image_handle* handle, uint32_t* aspect_h, uint32_t* aspect_v)
+{
+  auto pasp = handle->image->get_property<Box_pasp>();
+  if (pasp) {
+    *aspect_h = pasp->hSpacing;
+    *aspect_v = pasp->vSpacing;
+    return 1;
+  }
+  else {
+    *aspect_h = 1;
+    *aspect_v = 1;
+    return 0;
+  }
+}
+
+
+heif_context* heif_image_handle_get_context(const heif_image_handle* handle)
+{
+  auto ctx = new heif_context();
+  ctx->context = handle->context;
+  return ctx;
+}
+
+
+const char* heif_image_handle_get_gimi_content_id(const heif_image_handle* handle)
+{
+  if (!handle->image->has_gimi_sample_content_id()) {
+    return nullptr;
+  }
+
+  std::string id = handle->image->get_gimi_sample_content_id();
+  char* idstring = new char[id.size() + 1];
+  strcpy(idstring, id.c_str());
+  return idstring;
+}
+
+
+void heif_image_handle_set_gimi_content_id(heif_image_handle* handle, const char* content_id)
+{
+  auto gimi_box = std::make_shared<Box_gimi_content_id>();
+  gimi_box->set_content_id(content_id);
+  handle->context->add_property(handle->image->get_id(), gimi_box, false);
+  handle->image->set_gimi_sample_content_id(content_id);
+}
+
+
+#if WITH_UNCOMPRESSED_CODEC
+static std::shared_ptr<Box_cmpd> get_effective_cmpd(const heif_image_handle* handle)
+{
+  // Try explicit cmpd property first.
+  auto cmpd = handle->image->get_property<Box_cmpd>();
+  if (cmpd) {
+    return cmpd;
+  }
+
+  // For profile-based uncC (version 1), the cmpd is synthesized inside the uncC box.
+  auto uncC = handle->image->get_property<Box_uncC>();
+  if (uncC) {
+    fill_uncC_and_cmpd_from_profile(uncC, cmpd);
+  }
+  return cmpd;
+}
+#endif
+
+
+uint32_t heif_image_handle_get_number_of_cmpd_components(const heif_image_handle* handle)
+{
+#if WITH_UNCOMPRESSED_CODEC
+  if (!handle) {
+    return 0;
+  }
+  auto cmpd = get_effective_cmpd(handle);
+  if (!cmpd) {
+    return 0;
+  }
+  return static_cast<uint32_t>(cmpd->get_components().size());
+#else
+  return 0;
+#endif
+}
+
+
+uint16_t heif_image_handle_get_cmpd_component_type(const heif_image_handle* handle, uint32_t component_idx)
+{
+#if WITH_UNCOMPRESSED_CODEC
+  if (!handle) {
+    return 0;
+  }
+  auto cmpd = get_effective_cmpd(handle);
+  if (!cmpd) {
+    return 0;
+  }
+  const auto& components = cmpd->get_components();
+  if (component_idx >= components.size()) {
+    return 0;
+  }
+  return components[component_idx].component_type;
+#else
+  return 0;
+#endif
+}
+
+
+const char* heif_image_handle_get_cmpd_component_type_uri(const heif_image_handle* handle, uint32_t component_idx)
+{
+#if WITH_UNCOMPRESSED_CODEC
+  if (!handle) {
+    return nullptr;
+  }
+  auto cmpd = get_effective_cmpd(handle);
+  if (!cmpd) {
+    return nullptr;
+  }
+  const auto& components = cmpd->get_components();
+  if (component_idx >= components.size()) {
+    return nullptr;
+  }
+  const auto& uri = components[component_idx].component_type_uri;
+  if (uri.empty()) {
+    return nullptr;
+  }
+  char* uristring = new char[uri.size() + 1];
+  strcpy(uristring, uri.c_str());
+  return uristring;
+#else
+  return nullptr;
+#endif
+}
+
+
+int heif_image_handle_has_gimi_component_content_ids(const heif_image_handle* handle)
+{
+#if WITH_UNCOMPRESSED_CODEC
+  if (!handle) {
+    return 0;
+  }
+  auto box = handle->image->get_property<Box_gimi_component_content_ids>();
+  if (!box) {
+    return 0;
+  }
+  return static_cast<int>(box->get_content_ids().size());
+#else
+  return 0;
+#endif
+}
+
+
+const char* heif_image_handle_get_gimi_component_content_id(const heif_image_handle* handle, uint32_t component_idx)
+{
+#if WITH_UNCOMPRESSED_CODEC
+  if (!handle) {
+    return nullptr;
+  }
+  auto box = handle->image->get_property<Box_gimi_component_content_ids>();
+  if (!box) {
+    return nullptr;
+  }
+  const auto& ids = box->get_content_ids();
+  if (component_idx >= ids.size()) {
+    return nullptr;
+  }
+  char* idstring = new char[ids[component_idx].size() + 1];
+  strcpy(idstring, ids[component_idx].c_str());
+  return idstring;
+#else
+  return nullptr;
+#endif
+}
+
+
+void heif_image_handle_set_gimi_component_content_id(heif_image_handle* handle,
+                                                     uint32_t component_idx,
+                                                     const char* content_id)
+{
+#if WITH_UNCOMPRESSED_CODEC
+  if (!handle || !content_id) {
+    return;
+  }
+
+  auto box = handle->image->get_property<Box_gimi_component_content_ids>();
+  if (!box) {
+    // Create a new box and add it as property.
+    auto new_box = std::make_shared<Box_gimi_component_content_ids>();
+    std::vector<std::string> ids(component_idx + 1);
+    ids[component_idx] = content_id;
+    new_box->set_content_ids(ids);
+    handle->context->add_property(handle->image->get_id(), new_box, false);
+  }
+  else {
+    // Mutate the existing box in-place.
+    auto ids = box->get_content_ids();
+    if (component_idx >= ids.size()) {
+      ids.resize(component_idx + 1);
+    }
+    ids[component_idx] = content_id;
+    box->set_content_ids(ids);
+  }
+#endif
+}
diff --git a/libheif/api/libheif/heif_image_handle.h b/libheif/api/libheif/heif_image_handle.h
new file mode 100644
index 0000000000..5bd3f29a40
--- /dev/null
+++ b/libheif/api/libheif/heif_image_handle.h
@@ -0,0 +1,171 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017-2025 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_HEIF_IMAGE_HANDLE_H
+#define LIBHEIF_HEIF_IMAGE_HANDLE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <libheif/heif_library.h>
+#include <libheif/heif_image.h>
+
+
+// ========================= heif_image_handle =========================
+
+// An heif_image_handle is a handle to a logical image in the HEIF file.
+// To get the actual pixel data, you have to decode the handle to an heif_image.
+// An heif_image_handle also gives you access to the thumbnails and Exif data
+// associated with an image.
+
+// Once you obtained an heif_image_handle, you can already release the heif_context,
+// since it is internally ref-counted.
+
+// Release image handle.
+LIBHEIF_API
+void heif_image_handle_release(const heif_image_handle*);
+
+// Check whether the given image_handle is the primary image of the file.
+LIBHEIF_API
+int heif_image_handle_is_primary_image(const heif_image_handle* handle);
+
+LIBHEIF_API
+heif_item_id heif_image_handle_get_item_id(const heif_image_handle* handle);
+
+/** Get the image width.
+ *
+ * If 'handle' is invalid (NULL) or if the image size exceeds the range of `int`, 0 is returned.
+ */
+LIBHEIF_API
+int heif_image_handle_get_width(const heif_image_handle* handle);
+
+/** Get the image height.
+ *
+ * If 'handle' is invalid (NULL) or if the image size exceeds the range of `int`, 0 is returned.
+ */
+LIBHEIF_API
+int heif_image_handle_get_height(const heif_image_handle* handle);
+
+LIBHEIF_API
+int heif_image_handle_has_alpha_channel(const heif_image_handle*);
+
+LIBHEIF_API
+int heif_image_handle_is_premultiplied_alpha(const heif_image_handle*);
+
+// Returns -1 on error, e.g. if this information is not present in the image.
+// Only defined for images coded in the YCbCr or monochrome colorspace.
+LIBHEIF_API
+int heif_image_handle_get_luma_bits_per_pixel(const heif_image_handle*);
+
+// Returns -1 on error, e.g. if this information is not present in the image.
+// Only defined for images coded in the YCbCr colorspace.
+LIBHEIF_API
+int heif_image_handle_get_chroma_bits_per_pixel(const heif_image_handle*);
+
+// Return the colorspace that libheif proposes to use for decoding.
+// Usually, these will be either YCbCr or Monochrome, but it may also propose RGB for images
+// encoded with matrix_coefficients=0 or for images coded natively in RGB.
+// It may also return *_undefined if the file misses relevant information to determine this without decoding.
+// These are only proposed values that avoid colorspace conversions as much as possible.
+// You can still request the output in your preferred colorspace, but this may involve an internal conversion.
+LIBHEIF_API
+heif_error heif_image_handle_get_preferred_decoding_colorspace(const heif_image_handle* image_handle,
+                                                               enum heif_colorspace* out_colorspace,
+                                                               enum heif_chroma* out_chroma);
+
+// Get the image width from the 'ispe' box. This is the original image size without
+// any transformations applied to it. Do not use this unless you know exactly what
+// you are doing.
+LIBHEIF_API
+int heif_image_handle_get_ispe_width(const heif_image_handle* handle);
+
+LIBHEIF_API
+int heif_image_handle_get_ispe_height(const heif_image_handle* handle);
+
+// Returns whether the image has 'pixel aspect ratio information' information. If 0 is returned, the output is filled with the 1:1 default.
+LIBHEIF_API
+int heif_image_handle_get_pixel_aspect_ratio(const heif_image_handle*, uint32_t* aspect_h, uint32_t* aspect_v);
+
+
+// This gets the context associated with the image handle.
+// Note that you have to release the returned context with heif_context_free() in any case.
+//
+// This means: when you have several image-handles that originate from the same file and you get the
+// context of each of them, the returned pointer may be different even though it refers to the same
+// logical context. You have to call heif_context_free() on all those context pointers.
+// After you freed a context pointer, you can still use the context through a different pointer that you
+// might have acquired from elsewhere.
+LIBHEIF_API
+heif_context* heif_image_handle_get_context(const heif_image_handle* handle);
+
+LIBHEIF_API
+const char* heif_image_handle_get_gimi_content_id(const heif_image_handle* handle);
+
+LIBHEIF_API
+void heif_image_handle_set_gimi_content_id(heif_image_handle* handle, const char* content_id);
+
+
+// --- cmpd component queries
+
+// Returns the number of components in the cmpd box, or 0 if no cmpd property exists.
+LIBHEIF_API
+uint32_t heif_image_handle_get_number_of_cmpd_components(const heif_image_handle*);
+
+// Returns the component_type for the given cmpd component index.
+// Returns 0 if out of range or no cmpd property.
+LIBHEIF_API
+uint16_t heif_image_handle_get_cmpd_component_type(const heif_image_handle*, uint32_t component_idx);
+
+// Returns the component_type_uri for the given cmpd component index (component_type >= 0x8000).
+// Returns NULL if the component does not have a URI.
+// The returned string must be freed with heif_string_release().
+LIBHEIF_API
+const char* heif_image_handle_get_cmpd_component_type_uri(const heif_image_handle*, uint32_t component_idx);
+
+
+// --- GIMI component content IDs (handle-level)
+
+// Returns non-zero (count of content IDs) if an ItemComponentContentIDProperty is set, 0 otherwise.
+LIBHEIF_API
+int heif_image_handle_has_gimi_component_content_ids(const heif_image_handle*);
+
+// Returns the GIMI component content ID for the given component index.
+// Returns NULL if no ItemComponentContentIDProperty is set or index is out of range.
+// The returned string must be freed with heif_string_release().
+LIBHEIF_API
+const char* heif_image_handle_get_gimi_component_content_id(const heif_image_handle*, uint32_t component_idx);
+
+// Set a GIMI component content ID for a single component.
+// If an ItemComponentContentIDProperty does not yet exist, one will be created.
+// The content IDs array is resized as needed (new entries default to empty).
+LIBHEIF_API
+void heif_image_handle_set_gimi_component_content_id(heif_image_handle*,
+                                                     uint32_t component_idx,
+                                                     const char* content_id);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/libheif/api/libheif/heif_items.cc b/libheif/api/libheif/heif_items.cc
new file mode 100644
index 0000000000..f3e0325f55
--- /dev/null
+++ b/libheif/api/libheif/heif_items.cc
@@ -0,0 +1,377 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "heif_items.h"
+#include "context.h"
+#include "api_structs.h"
+#include "file.h"
+
+#include <cstring>
+#include <memory>
+#include <vector>
+#include <string>
+
+
+// ------------------------- reading -------------------------
+
+int heif_context_get_number_of_items(const heif_context* ctx)
+{
+  return (int) ctx->context->get_heif_file()->get_number_of_items();
+}
+
+
+int heif_context_get_list_of_item_IDs(const heif_context* ctx,
+                                      heif_item_id* ID_array,
+                                      int count)
+{
+  if (!ID_array) {
+    return 0;
+  }
+
+  auto ids = ctx->context->get_heif_file()->get_item_IDs();
+  for (int i = 0; i < (int) ids.size(); i++) {
+    if (i == count) {
+      return count;
+    }
+
+    ID_array[i] = ids[i];
+  }
+
+  return (int) ids.size();
+}
+
+
+uint32_t heif_item_get_item_type(const heif_context* ctx, heif_item_id item_id)
+{
+  return ctx->context->get_heif_file()->get_item_type_4cc(item_id);
+}
+
+
+int heif_item_is_item_hidden(const heif_context* ctx, heif_item_id item_id)
+{
+  auto infe = ctx->context->get_heif_file()->get_infe_box(item_id);
+  if (infe == nullptr) {
+    return true;
+  }
+  else {
+    return infe->is_hidden_item();
+  }
+}
+
+
+const char* heif_item_get_mime_item_content_type(const heif_context* ctx, heif_item_id item_id)
+{
+  auto infe = ctx->context->get_heif_file()->get_infe_box(item_id);
+  if (!infe) { return nullptr; }
+
+  if (infe->get_item_type_4cc() != fourcc("mime")) {
+    return nullptr;
+  }
+
+  return infe->get_content_type().c_str();
+}
+
+
+const char* heif_item_get_mime_item_content_encoding(const heif_context* ctx, heif_item_id item_id)
+{
+  auto infe = ctx->context->get_heif_file()->get_infe_box(item_id);
+  if (!infe) { return nullptr; }
+
+  if (infe->get_item_type_4cc() != fourcc("mime")) {
+    return nullptr;
+  }
+
+  return infe->get_content_encoding().c_str();
+}
+
+
+const char* heif_item_get_uri_item_uri_type(const heif_context* ctx, heif_item_id item_id)
+{
+  auto infe = ctx->context->get_heif_file()->get_infe_box(item_id);
+  if (!infe) { return nullptr; }
+
+  if (infe->get_item_type_4cc() != fourcc("uri ")) {
+    return nullptr;
+  }
+
+  return infe->get_item_uri_type().c_str();
+}
+
+
+const char* heif_item_get_item_name(const heif_context* ctx, heif_item_id item_id)
+{
+  auto infe = ctx->context->get_heif_file()->get_infe_box(item_id);
+  if (!infe) { return nullptr; }
+
+  return infe->get_item_name().c_str();
+}
+
+
+heif_error heif_item_set_item_name(heif_context* ctx,
+                                   heif_item_id item,
+                                   const char* item_name)
+{
+  auto infe = ctx->context->get_heif_file()->get_infe_box(item);
+  if (!infe) {
+    return heif_error{heif_error_Input_does_not_exist, heif_suberror_Nonexisting_item_referenced, "Item does not exist"};
+  }
+
+  infe->set_item_name(item_name);
+
+  return heif_error_success;
+}
+
+
+heif_error heif_item_get_item_data(const heif_context* ctx,
+                                   heif_item_id item_id,
+                                   heif_metadata_compression* out_compression_format,
+                                   uint8_t** out_data, size_t* out_data_size)
+{
+  if (out_data && !out_data_size) {
+    return {heif_error_Usage_error, heif_suberror_Null_pointer_argument, "cannot return data with out_data_size==NULL"};
+  }
+
+  auto dataResult = ctx->context->get_heif_file()->get_item_data(item_id, out_compression_format);
+  if (!dataResult) {
+    *out_data_size = 0;
+    if (out_data) {
+      *out_data = 0;
+    }
+
+    return dataResult.error_struct(ctx->context.get());
+  }
+
+  if (out_data_size) {
+    *out_data_size = dataResult->size();
+  }
+
+  if (out_data) {
+    *out_data = new uint8_t[dataResult->size()];
+    memcpy(*out_data, dataResult->data(), dataResult->size());
+  }
+
+  return heif_error_success;
+}
+
+
+void heif_release_item_data(const heif_context* ctx, uint8_t** item_data)
+{
+  (void) ctx;
+
+  if (item_data) {
+    delete[] *item_data;
+    *item_data = nullptr;
+  }
+}
+
+
+heif_error heif_item_get_property_extended_language(const heif_context* context,
+                                                    heif_item_id itemId,
+                                                    char** out_language)
+{
+  if (!out_language || !context) {
+    return {heif_error_Usage_error, heif_suberror_Invalid_parameter_value, "NULL passed"};
+  }
+
+  auto elng = context->context->find_property<Box_elng>(itemId);
+  if (!elng) {
+    return elng.error_struct(context->context.get());
+  }
+
+  std::string lang = (*elng)->get_extended_language();
+  *out_language = new char[lang.length() + 1];
+  strcpy(*out_language, lang.c_str());
+
+  return heif_error_success;
+}
+
+
+heif_error heif_item_set_property_extended_language(heif_context* context,
+                                           heif_item_id item_id,
+                                           const char* language, heif_property_id* out_optional_propertyId)
+{
+  if (!context || !language) {
+    return {heif_error_Usage_error, heif_suberror_Null_pointer_argument, "NULL passed"};
+  }
+
+  Result<heif_property_id> property_id_result = context->context->add_text_property(item_id,
+                                                                                    language);
+
+  if (auto err = property_id_result.error()) {
+    return err.error_struct(context->context.get());
+  }
+
+  if (out_optional_propertyId) {
+    *out_optional_propertyId = *property_id_result;
+  }
+
+  return heif_error_success;
+}
+
+
+size_t heif_context_get_item_references(const heif_context* ctx,
+                                        heif_item_id from_item_id,
+                                        int index,
+                                        uint32_t* out_reference_type_4cc,
+                                        heif_item_id** out_references_to)
+{
+  if (index < 0) {
+    return 0;
+  }
+
+  auto iref = ctx->context->get_heif_file()->get_iref_box();
+  if (!iref) {
+    return 0;
+  }
+
+  auto refs = iref->get_references_from(from_item_id);
+  if (index >= (int) refs.size()) {
+    return 0;
+  }
+
+  const auto& ref = refs[index];
+  if (out_reference_type_4cc) {
+    *out_reference_type_4cc = ref.header.get_short_type();
+  }
+
+  if (out_references_to) {
+    *out_references_to = new heif_item_id[ref.to_item_ID.size()];
+    for (size_t i = 0; i < ref.to_item_ID.size(); i++) {
+      (*out_references_to)[i] = ref.to_item_ID[i];
+    }
+  }
+
+  return ref.to_item_ID.size();
+}
+
+
+void heif_release_item_references(const heif_context* ctx, heif_item_id** references)
+{
+  (void) ctx;
+
+  if (references) {
+    delete[] *references;
+    *references = nullptr;
+  }
+}
+
+
+heif_error heif_context_add_item_reference(heif_context* ctx,
+                                           uint32_t reference_type,
+                                           heif_item_id from_item,
+                                           heif_item_id to_item)
+{
+  ctx->context->get_heif_file()->add_iref_reference(from_item,
+                                                    reference_type, {to_item});
+
+  return heif_error_success;
+}
+
+heif_error heif_context_add_item_references(heif_context* ctx,
+                                            uint32_t reference_type,
+                                            heif_item_id from_item,
+                                            const heif_item_id* to_item,
+                                            int num_to_items)
+{
+  std::vector<heif_item_id> to_refs(to_item, to_item + num_to_items);
+
+  ctx->context->get_heif_file()->add_iref_reference(from_item,
+                                                    reference_type, to_refs);
+
+  return heif_error_success;
+}
+
+
+// ------------------------- writing -------------------------
+
+heif_error heif_context_add_item(heif_context* ctx,
+                                 const char* item_type,
+                                 const void* data, int size,
+                                 heif_item_id* out_item_id)
+{
+  if (item_type == nullptr || strlen(item_type) != 4) {
+    return {
+      heif_error_Usage_error,
+      heif_suberror_Invalid_parameter_value,
+      "called heif_context_add_item() with invalid 'item_type'."
+    };
+  }
+
+  Result<heif_item_id> result = ctx->context->get_heif_file()->add_infe(fourcc(item_type), (const uint8_t*) data, size);
+
+  if (result && out_item_id) {
+    *out_item_id = result;
+    return heif_error_success;
+  }
+  else {
+    return result.error_struct(ctx->context.get());
+  }
+}
+
+heif_error heif_context_add_mime_item(heif_context* ctx,
+                                      const char* content_type,
+                                      heif_metadata_compression content_encoding,
+                                      const void* data, int size,
+                                      heif_item_id* out_item_id)
+{
+  Result<heif_item_id> result = ctx->context->get_heif_file()->add_infe_mime(content_type, content_encoding, (const uint8_t*) data, size);
+
+  if (result && out_item_id) {
+    *out_item_id = *result;
+    return heif_error_success;
+  }
+  else {
+    return result.error_struct(ctx->context.get());
+  }
+}
+
+
+heif_error heif_context_add_precompressed_mime_item(heif_context* ctx,
+                                                    const char* content_type,
+                                                    const char* content_encoding,
+                                                    const void* data, int size,
+                                                    heif_item_id* out_item_id)
+{
+  Result<heif_item_id> result = ctx->context->get_heif_file()->add_precompressed_infe_mime(content_type, content_encoding, (const uint8_t*) data, size);
+
+  if (result && out_item_id) {
+    *out_item_id = result;
+    return heif_error_success;
+  }
+  else {
+    return result.error_struct(ctx->context.get());
+  }
+}
+
+heif_error heif_context_add_uri_item(heif_context* ctx,
+                                     const char* item_uri_type,
+                                     const void* data, int size,
+                                     heif_item_id* out_item_id)
+{
+  Result<heif_item_id> result = ctx->context->get_heif_file()->add_infe_uri(item_uri_type, (const uint8_t*) data, size);
+
+  if (result && out_item_id) {
+    *out_item_id = result;
+    return heif_error_success;
+  }
+  else {
+    return result.error_struct(ctx->context.get());
+  }
+}
diff --git a/libheif/api/libheif/heif_items.h b/libheif/api/libheif/heif_items.h
new file mode 100644
index 0000000000..cb6e4f0ae4
--- /dev/null
+++ b/libheif/api/libheif/heif_items.h
@@ -0,0 +1,260 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_HEIF_ITEMS_H
+#define LIBHEIF_HEIF_ITEMS_H
+
+#include "heif_library.h"
+#include "heif_error.h"
+#include "heif_metadata.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/**
+ * Gets the number of items.
+ *
+ * This is not the same as the number of images, since there can be other types of items,
+ * such as metadata.
+ *
+ * @param ctx the file context
+ * @return the number of items
+ */
+LIBHEIF_API
+int heif_context_get_number_of_items(const heif_context* ctx);
+
+/**
+ * Get the item identifiers.
+ *
+ * Fills in the item IDs into the user-supplied array {@code ID_array}, preallocated with {@code count} entries.
+ *
+ * @param ctx the file context
+ * @param ID_array the output array.
+ * @param count the number of items allocated within {@code ID_array}.
+ * @return the total number of IDs filled into the array, which may be less than {@code count}.
+ */
+LIBHEIF_API
+int heif_context_get_list_of_item_IDs(const heif_context* ctx,
+                                      heif_item_id* ID_array,
+                                      int count);
+
+/**
+ * Gets the item type.
+ *
+ * Usually, this is a four character code (e.g. `mime` or `uri `), but it can theoretically be
+ * any 4-byte number. Thus, the type is returned as an integer. You can use {@link heif_fourcc} to map
+ * between the two representations.
+ *
+ * @param ctx the file context
+ * @param item_id the item identifier for the item
+ * @return the item type
+ */
+LIBHEIF_API
+uint32_t heif_item_get_item_type(const heif_context* ctx, heif_item_id item_id);
+
+#define heif_item_type_mime   heif_fourcc('m','i','m','e')
+#define heif_item_type_uri    heif_fourcc('u','r','i',' ')
+
+LIBHEIF_API
+int heif_item_is_item_hidden(const heif_context* ctx, heif_item_id item_id);
+
+
+/**
+ * Gets the MIME content_type for an item.
+ *
+ * Only valid if the item type is `mime`.
+ * If the item does not exist, or if it is not a `mime` item, NULL is returned.
+ *
+ * @param ctx the file context
+ * @param item_id the item identifier for the item
+ * @return the item content_type
+ */
+LIBHEIF_API
+const char* heif_item_get_mime_item_content_type(const heif_context* ctx, heif_item_id item_id);
+
+/**
+ * Gets the content_encoding for a MIME item.
+ *
+ * Only valid if the item type is `mime`.
+ * If the item does not exist, or if it is not a `mime` item, NULL is returned.
+ *
+ * If the item is not encoded, the returned value will be an empty string (not null).
+ *
+ * @param ctx the file context
+ * @param item_id the item identifier for the item
+ * @return the item content_type
+ */
+LIBHEIF_API
+const char* heif_item_get_mime_item_content_encoding(const heif_context* ctx, heif_item_id item_id);
+
+/**
+ * Gets the item_uri_type for an item.
+ *
+ * Only valid if the item type is `uri `.
+ * If the item does not exist, or if it is not a `uri ` item, NULL is returned.
+ *
+ * @param ctx the file context
+ * @param item_id the item identifier for the item
+ * @return the item item_uri_type
+ */
+LIBHEIF_API
+const char* heif_item_get_uri_item_uri_type(const heif_context* ctx, heif_item_id item_id);
+
+LIBHEIF_API
+const char* heif_item_get_item_name(const heif_context* ctx, heif_item_id item_id);
+
+LIBHEIF_API
+heif_error heif_item_set_item_name(heif_context* ctx,
+                                   heif_item_id item,
+                                   const char* item_name);
+
+
+/**
+ * Gets the raw metadata, as stored in the HEIF file.
+ *
+ * Data in a "mime" item with "content_encoding" can be compressed.
+ * When `out_compression_format` is NULL, the decompressed data will be returned.
+ * Otherwise, the compressed data is returned and `out_compression_format` will be filled with the
+ * compression format.
+ * If the compression method is not supported, an error will be returned.
+ *
+ * It is valid to set `out_data` to NULL. In that case, only the `out_data_size` is filled.
+ * Note that it is inefficient to use `out_data=NULL` just to get the size of compressed data.
+ * In general, this should be avoided.
+ *
+ * If there is no data assigned to the item or there is an error, `out_data_size` is set to zero.
+ *
+ * @param ctx the file context
+ * @param item_id the item identifier for the item
+ * @param out_compression_format how the data is compressed. If the pointer is NULL, the decompressed data will be returned.
+ * @param out_data the corresponding raw metadata
+ * @param out_data_size the size of the metadata in bytes
+ * @return whether the call succeeded, or there was an error
+ */
+LIBHEIF_API
+heif_error heif_item_get_item_data(const heif_context* ctx,
+                                   heif_item_id item_id,
+                                   enum heif_metadata_compression* out_compression_format,
+                                   uint8_t** out_data, size_t* out_data_size);
+
+/**
+ * Free the item data.
+ *
+ * This is used to free memory associated with the data returned by
+ * {@link heif_item_get_item_data} in 'out_data' and set the pointer to NULL.
+ *
+ * @param ctx the file context
+ * @param item_data the data to free
+ */
+LIBHEIF_API
+void heif_release_item_data(const heif_context* ctx, uint8_t** item_data);
+
+
+// ------------------------- item language -------------------------
+
+/**
+ * Get the extended language associated with the item.
+ * The item is usually a text item.
+ *
+ * @param context the heif file context containg the item.
+ * @param itemId the identifier for the item
+ * @param out_language output parameter with the item's language. Free with heif_string_release().
+ * @return heif_error_ok on success, or an error value indicating the problem
+ */
+LIBHEIF_API
+heif_error heif_item_get_property_extended_language(const heif_context* context,
+                                                    heif_item_id itemId,
+                                                    char** out_language);
+
+LIBHEIF_API
+heif_error heif_item_set_property_extended_language(heif_context* context,
+                                                    heif_item_id item_id,
+                                                    const char* language, heif_property_id* out_optional_propertyId);
+
+// ------------------------- item references -------------------------
+
+/**
+ * Get the item ids that reference the given item.
+ *
+ * @param ctx the file context.
+ * @param from_item_id the item identifier for the item.
+ * @param index the index of the reference to get.
+ * @param out_reference_type_4cc The 4cc of the reference. (e.g dimg, thmb, cdsc, or auxl)
+ * @param out_references_to the item references. Use {@link heif_release_item_references} to free the memory.
+ * @return the number of items that reference the given item. Returns 0 if the index exceeds the number of references.
+ */
+LIBHEIF_API
+size_t heif_context_get_item_references(const heif_context* ctx,
+                                        heif_item_id from_item_id,
+                                        int index,
+                                        uint32_t* out_reference_type_4cc,
+                                        heif_item_id** out_references_to);
+
+LIBHEIF_API
+void heif_release_item_references(const heif_context* ctx, heif_item_id** references);
+
+LIBHEIF_API
+heif_error heif_context_add_item_reference(heif_context* ctx,
+                                           uint32_t reference_type,
+                                           heif_item_id from_item,
+                                           heif_item_id to_item);
+
+LIBHEIF_API
+heif_error heif_context_add_item_references(heif_context* ctx,
+                                            uint32_t reference_type,
+                                            heif_item_id from_item,
+                                            const heif_item_id* to_item,
+                                            int num_to_items);
+
+// ------------------------- adding new items -------------------------
+
+LIBHEIF_API
+heif_error heif_context_add_item(heif_context* ctx,
+                                 const char* item_type,
+                                 const void* data, int size,
+                                 heif_item_id* out_item_id);
+
+LIBHEIF_API
+heif_error heif_context_add_mime_item(heif_context* ctx,
+                                      const char* content_type,
+                                      enum heif_metadata_compression content_encoding,
+                                      const void* data, int size,
+                                      heif_item_id* out_item_id);
+
+LIBHEIF_API
+heif_error heif_context_add_precompressed_mime_item(heif_context* ctx,
+                                                    const char* content_type,
+                                                    const char* content_encoding,
+                                                    const void* data, int size,
+                                                    heif_item_id* out_item_id);
+
+LIBHEIF_API
+heif_error heif_context_add_uri_item(heif_context* ctx,
+                                     const char* item_uri_type,
+                                     const void* data, int size,
+                                     heif_item_id* out_item_id);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/libheif/api/libheif/heif_library.cc b/libheif/api/libheif/heif_library.cc
new file mode 100644
index 0000000000..303a755992
--- /dev/null
+++ b/libheif/api/libheif/heif_library.cc
@@ -0,0 +1,107 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "heif_library.h"
+#include "heif_plugin.h"
+#include "api_structs.h"
+#include "plugin_registry.h"
+
+#ifdef _WIN32
+// for _write
+#include <io.h>
+#else
+
+#include <unistd.h>
+
+#endif
+
+#include <cassert>
+
+
+static heif_error error_unsupported_plugin_version = {heif_error_Usage_error,
+                                                             heif_suberror_Unsupported_plugin_version,
+                                                             "Unsupported plugin version"};
+
+
+const char* heif_get_version()
+{
+  return (LIBHEIF_VERSION);
+}
+
+uint32_t heif_get_version_number()
+{
+  return (LIBHEIF_NUMERIC_VERSION);
+}
+
+int heif_get_version_number_major()
+{
+  return ((LIBHEIF_NUMERIC_VERSION) >> 24) & 0xFF;
+}
+
+int heif_get_version_number_minor()
+{
+  return ((LIBHEIF_NUMERIC_VERSION) >> 16) & 0xFF;
+}
+
+int heif_get_version_number_maintenance()
+{
+  return ((LIBHEIF_NUMERIC_VERSION) >> 8) & 0xFF;
+}
+
+
+
+heif_error heif_register_decoder_plugin(const heif_decoder_plugin* decoder_plugin)
+{
+  if (!decoder_plugin) {
+    return heif_error_null_pointer_argument;
+  }
+  else if (decoder_plugin->plugin_api_version > heif_decoder_plugin_latest_version) {
+    return error_unsupported_plugin_version;
+  }
+
+  register_decoder(decoder_plugin);
+  return heif_error_success;
+}
+
+heif_error heif_register_encoder_plugin(const heif_encoder_plugin* encoder_plugin)
+{
+  if (!encoder_plugin) {
+    return heif_error_null_pointer_argument;
+  }
+  else if (encoder_plugin->plugin_api_version > heif_encoder_plugin_latest_version) {
+    return error_unsupported_plugin_version;
+  }
+
+  register_encoder(encoder_plugin);
+  return heif_error_success;
+}
+
+
+void heif_string_release(const char* str)
+{
+  delete[] str;
+}
+
+
+// DEPRECATED
+heif_error heif_register_decoder(heif_context* heif, const heif_decoder_plugin* decoder_plugin)
+{
+  return heif_register_decoder_plugin(decoder_plugin);
+}
diff --git a/libheif/api/libheif/heif_library.h b/libheif/api/libheif/heif_library.h
new file mode 100644
index 0000000000..f6fbcb811e
--- /dev/null
+++ b/libheif/api/libheif/heif_library.h
@@ -0,0 +1,219 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017-2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_HEIF_LIBRARY_H
+#define LIBHEIF_HEIF_LIBRARY_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stddef.h>
+#include <stdint.h>
+
+
+// API versions table
+//
+// release    dec.options   enc.options   heif_reader   heif_writer   depth.rep   col.profile
+// ------------------------------------------------------------------------------------------
+//  1.0            1           N/A           N/A           N/A           1           N/A
+//  1.1            1           N/A           N/A            1            1           N/A
+//  1.3            1            1             1             1            1           N/A
+//  1.4            1            1             1             1            1            1
+//  1.7            2            1             1             1            1            1
+//  1.9.2          2            2             1             1            1            1
+//  1.10           2            3             1             1            1            1
+//  1.11           2            4             1             1            1            1
+//  1.13           3            4             1             1            1            1
+//  1.14           3            5             1             1            1            1
+//  1.15           4            5             1             1            1            1
+//  1.16           5            6             1             1            1            1
+//  1.18           5            7             1             1            1            1
+//  1.19           6            7             2             1            1            1
+//  1.20           7            7             2             1            1            1
+
+#if (defined(_WIN32) || defined __CYGWIN__) && !defined(LIBHEIF_STATIC_BUILD)
+#ifdef LIBHEIF_EXPORTS
+#define LIBHEIF_API __declspec(dllexport)
+#else
+#define LIBHEIF_API __declspec(dllimport)
+#endif
+#elif defined(HAVE_VISIBILITY) && HAVE_VISIBILITY
+#ifdef LIBHEIF_EXPORTS
+#define LIBHEIF_API __attribute__((__visibility__("default")))
+#else
+#define LIBHEIF_API
+#endif
+#else
+#define LIBHEIF_API
+#endif
+
+/**
+ * Build a 32 bit integer from a 4-character code.
+ */
+#define heif_fourcc(a, b, c, d) ((uint32_t)((a<<24) | (b<<16) | (c<<8) | d))
+
+#include <libheif/heif_version.h>
+#include <libheif/heif_error.h>
+
+
+/* === version numbers === */
+
+// Version string of linked libheif library.
+LIBHEIF_API const char* heif_get_version(void);
+
+// Numeric version of linked libheif library, encoded as 0xHHMMLL00 = hh.mm.ll, where hh, mm, ll is the decimal representation of HH, MM, LL.
+// For example: 0x02150300 is version 2.21.3
+LIBHEIF_API uint32_t heif_get_version_number(void);
+
+// Numeric part "HH" from above. Returned as a decimal number.
+LIBHEIF_API int heif_get_version_number_major(void);
+// Numeric part "MM" from above. Returned as a decimal number.
+LIBHEIF_API int heif_get_version_number_minor(void);
+// Numeric part "LL" from above. Returned as a decimal number.
+LIBHEIF_API int heif_get_version_number_maintenance(void);
+
+// Helper macros to check for given versions of libheif at compile time.
+#define LIBHEIF_MAKE_VERSION(h, m, l) ((h) << 24 | (m) << 16 | (l) << 8)
+#define LIBHEIF_HAVE_VERSION(h, m, l) (LIBHEIF_NUMERIC_VERSION >= LIBHEIF_MAKE_VERSION(h, m, l))
+
+typedef struct heif_context heif_context;
+typedef struct heif_image_handle heif_image_handle;
+
+typedef uint32_t heif_item_id;
+typedef uint32_t heif_property_id;
+
+/**
+ * Free a string returned by libheif in various API functions.
+ * You may pass NULL.
+ */
+LIBHEIF_API
+void heif_string_release(const char*);
+
+
+// ========================= library initialization ======================
+
+typedef struct heif_init_params
+{
+  int version;
+
+  // currently no parameters
+} heif_init_params;
+
+
+/**
+ * Initialise library.
+ *
+ * You should call heif_init() when you start using libheif and heif_deinit() when you are finished.
+ * These calls are reference counted. Each call to heif_init() should be matched by one call to heif_deinit().
+ *
+ * For backwards compatibility, it is not really necessary to call heif_init(), but some library memory objects
+ * will never be freed if you do not call heif_init()/heif_deinit().
+ *
+ * heif_init() will load the external modules installed in the default plugin path. Thus, you need it when you
+ * want to load external plugins from the default path.
+ * Codec plugins that are compiled into the library directly (selected by the compile-time parameters of libheif)
+ * will be available even without heif_init().
+ *
+ * Make sure that you do not have one part of your program use heif_init()/heif_deinit() and another part that does
+ * not use it as the latter may try to use an uninitialized library. If in doubt, enclose everything with init/deinit.
+ *
+ * You may pass nullptr to get default parameters. Currently, no parameters are supported.
+ */
+LIBHEIF_API
+heif_error heif_init(heif_init_params*);
+
+/**
+ * Deinitialise and clean up library.
+ *
+ * You should call heif_init() when you start using libheif and heif_deinit() when you are finished.
+ * These calls are reference counted. Each call to heif_init() should be matched by one call to heif_deinit().
+ *
+ * Note: heif_deinit() must not be called after exit(), for example in a global C++ object's destructor.
+ * If you do, global variables in libheif might have already been released when heif_deinit() is running,
+ * leading to a crash.
+ *
+ * \sa heif_init()
+ */
+LIBHEIF_API
+void heif_deinit(void);
+
+
+// --- Codec plugins ---
+
+// --- Plugins are currently only supported on Unix platforms.
+
+typedef enum heif_plugin_type
+{
+  heif_plugin_type_encoder,
+  heif_plugin_type_decoder
+} heif_plugin_type;
+
+typedef struct heif_plugin_info
+{
+  int version; // version of this info struct
+  enum heif_plugin_type type;
+  const void* plugin;
+  void* internal_handle; // for internal use only
+} heif_plugin_info;
+
+LIBHEIF_API
+heif_error heif_load_plugin(const char* filename, heif_plugin_info const** out_plugin);
+
+LIBHEIF_API
+heif_error heif_load_plugins(const char* directory,
+                             const heif_plugin_info** out_plugins,
+                             int* out_nPluginsLoaded,
+                             int output_array_size);
+
+LIBHEIF_API
+heif_error heif_unload_plugin(const heif_plugin_info* plugin);
+
+// Get a NULL terminated array of the plugin directories that are searched by libheif.
+// This includes the paths specified in the environment variable LIBHEIF_PLUGIN_PATHS and the built-in path
+// (if not overridden by the environment variable).
+LIBHEIF_API
+const char* const* heif_get_plugin_directories(void);
+
+LIBHEIF_API
+void heif_free_plugin_directories(const char* const*);
+
+
+// --- register plugins
+
+typedef struct heif_decoder_plugin heif_decoder_plugin;
+typedef struct heif_encoder_plugin heif_encoder_plugin;
+
+LIBHEIF_API
+heif_error heif_register_decoder_plugin(const heif_decoder_plugin*);
+
+LIBHEIF_API
+heif_error heif_register_encoder_plugin(const heif_encoder_plugin*);
+
+
+// DEPRECATED. Use heif_register_decoder_plugin(const struct heif_decoder_plugin*) instead.
+LIBHEIF_API
+heif_error heif_register_decoder(heif_context* heif, const heif_decoder_plugin*);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/libheif/api/libheif/heif_metadata.cc b/libheif/api/libheif/heif_metadata.cc
new file mode 100644
index 0000000000..8760cda4aa
--- /dev/null
+++ b/libheif/api/libheif/heif_metadata.cc
@@ -0,0 +1,252 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017-2025 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "heif_metadata.h"
+#include "libheif/heif.h"
+#include "api_structs.h"
+
+#include "box.h"
+
+#include <cassert>
+#include <cstring>
+#include <memory>
+#include <array>
+
+
+int heif_metadata_compression_method_supported(enum heif_metadata_compression method)
+{
+  switch (method) {
+    case heif_metadata_compression_off:
+    case heif_metadata_compression_auto:
+      return true;
+
+    case heif_metadata_compression_deflate:
+    case heif_metadata_compression_zlib:
+#if HAVE_ZLIB
+      return true;
+#else
+      return false;
+#endif
+
+    case heif_metadata_compression_brotli:
+#if HAVE_BROTLI
+      return true;
+#else
+      return false;
+#endif
+
+    default:
+      return false;
+  }
+}
+
+
+int heif_image_handle_get_number_of_metadata_blocks(const heif_image_handle* handle,
+                                                    const char* type_filter)
+{
+  int cnt = 0;
+  for (const auto& metadata : handle->image->get_metadata()) {
+    if (type_filter == nullptr ||
+        metadata->item_type == type_filter) {
+      cnt++;
+    }
+  }
+
+  return cnt;
+}
+
+
+int heif_image_handle_get_list_of_metadata_block_IDs(const heif_image_handle* handle,
+                                                     const char* type_filter,
+                                                     heif_item_id* ids, int count)
+{
+  int cnt = 0;
+  for (const auto& metadata : handle->image->get_metadata()) {
+    if (type_filter == nullptr ||
+        metadata->item_type == type_filter) {
+      if (cnt < count) {
+        ids[cnt] = metadata->item_id;
+        cnt++;
+      }
+      else {
+        break;
+      }
+    }
+  }
+
+  return cnt;
+}
+
+
+const char* heif_image_handle_get_metadata_type(const heif_image_handle* handle,
+                                                heif_item_id metadata_id)
+{
+  for (auto& metadata : handle->image->get_metadata()) {
+    if (metadata->item_id == metadata_id) {
+      return metadata->item_type.c_str();
+    }
+  }
+
+  return nullptr;
+}
+
+
+const char* heif_image_handle_get_metadata_content_type(const heif_image_handle* handle,
+                                                        heif_item_id metadata_id)
+{
+  for (auto& metadata : handle->image->get_metadata()) {
+    if (metadata->item_id == metadata_id) {
+      return metadata->content_type.c_str();
+    }
+  }
+
+  return nullptr;
+}
+
+
+size_t heif_image_handle_get_metadata_size(const heif_image_handle* handle,
+                                           heif_item_id metadata_id)
+{
+  for (auto& metadata : handle->image->get_metadata()) {
+    if (metadata->item_id == metadata_id) {
+      return metadata->m_data.size();
+    }
+  }
+
+  return 0;
+}
+
+
+heif_error heif_image_handle_get_metadata(const heif_image_handle* handle,
+                                          heif_item_id metadata_id,
+                                          void* out_data)
+{
+  for (auto& metadata : handle->image->get_metadata()) {
+    if (metadata->item_id == metadata_id) {
+      if (!metadata->m_data.empty()) {
+        if (out_data == nullptr) {
+          return heif_error_null_pointer_argument;
+        }
+
+        memcpy(out_data,
+               metadata->m_data.data(),
+               metadata->m_data.size());
+      }
+
+      return Error::Ok.error_struct(handle->image.get());
+    }
+  }
+
+  Error err(heif_error_Usage_error,
+            heif_suberror_Nonexisting_item_referenced);
+  return err.error_struct(handle->image.get());
+}
+
+
+const char* heif_image_handle_get_metadata_item_uri_type(const heif_image_handle* handle,
+                                                         heif_item_id metadata_id)
+{
+  for (auto& metadata : handle->image->get_metadata()) {
+    if (metadata->item_id == metadata_id) {
+      return metadata->item_uri_type.c_str();
+    }
+  }
+
+  return nullptr;
+}
+
+
+heif_error heif_context_add_exif_metadata(heif_context* ctx,
+                                          const heif_image_handle* image_handle,
+                                          const void* data, int size)
+{
+  Error error = ctx->context->add_exif_metadata(image_handle->image, data, size);
+  if (error != Error::Ok) {
+    return error.error_struct(ctx->context.get());
+  }
+  else {
+    return heif_error_success;
+  }
+}
+
+
+heif_error heif_context_add_XMP_metadata(heif_context* ctx,
+                                         const heif_image_handle* image_handle,
+                                         const void* data, int size)
+{
+  return heif_context_add_XMP_metadata2(ctx, image_handle, data, size,
+                                        heif_metadata_compression_off);
+}
+
+
+heif_error heif_context_add_XMP_metadata2(heif_context* ctx,
+                                          const heif_image_handle* image_handle,
+                                          const void* data, int size,
+                                          heif_metadata_compression compression)
+{
+  Error error = ctx->context->add_XMP_metadata(image_handle->image, data, size, compression);
+  if (error != Error::Ok) {
+    return error.error_struct(ctx->context.get());
+  }
+  else {
+    return heif_error_success;
+  }
+}
+
+
+heif_error heif_context_add_generic_metadata(heif_context* ctx,
+                                             const heif_image_handle* image_handle,
+                                             const void* data, int size,
+                                             const char* item_type, const char* content_type)
+{
+  if (item_type == nullptr || strlen(item_type) != 4) {
+    return {
+      heif_error_Usage_error,
+      heif_suberror_Invalid_parameter_value,
+      "called heif_context_add_generic_metadata() with invalid 'item_type'."
+    };
+  }
+
+  Error error = ctx->context->add_generic_metadata(image_handle->image, data, size,
+                                                   fourcc(item_type), content_type, nullptr, heif_metadata_compression_off, nullptr);
+  if (error != Error::Ok) {
+    return error.error_struct(ctx->context.get());
+  }
+  else {
+    return heif_error_success;
+  }
+}
+
+
+heif_error heif_context_add_generic_uri_metadata(heif_context* ctx,
+                                                 const heif_image_handle* image_handle,
+                                                 const void* data, int size,
+                                                 const char* item_uri_type,
+                                                 heif_item_id* out_item_id)
+{
+  Error error = ctx->context->add_generic_metadata(image_handle->image, data, size,
+                                                   fourcc("uri "), nullptr, item_uri_type, heif_metadata_compression_off, out_item_id);
+  if (error != Error::Ok) {
+    return error.error_struct(ctx->context.get());
+  }
+  else {
+    return heif_error_success;
+  }
+}
diff --git a/libheif/api/libheif/heif_metadata.h b/libheif/api/libheif/heif_metadata.h
new file mode 100644
index 0000000000..94ba76cecd
--- /dev/null
+++ b/libheif/api/libheif/heif_metadata.h
@@ -0,0 +1,136 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017-2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_HEIF_METADATA_H
+#define LIBHEIF_HEIF_METADATA_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <libheif/heif_library.h>
+
+
+typedef enum heif_metadata_compression
+{
+  heif_metadata_compression_off = 0,
+  heif_metadata_compression_auto = 1,
+  heif_metadata_compression_unknown = 2, // only used when reading unknown method from input file
+  heif_metadata_compression_deflate = 3,
+  heif_metadata_compression_zlib = 4,    // do not use for header data
+  heif_metadata_compression_brotli = 5
+} heif_metadata_compression;
+
+LIBHEIF_API
+int heif_metadata_compression_method_supported(enum heif_metadata_compression method);
+
+// ------------------------- metadata (Exif / XMP) -------------------------
+
+// How many metadata blocks are attached to an image. If you only want to get EXIF data,
+// set the type_filter to "Exif". Otherwise, set the type_filter to NULL.
+LIBHEIF_API
+int heif_image_handle_get_number_of_metadata_blocks(const heif_image_handle* handle,
+                                                    const char* type_filter);
+
+// 'type_filter' can be used to get only metadata of specific types, like "Exif".
+// If 'type_filter' is NULL, it will return all types of metadata IDs.
+LIBHEIF_API
+int heif_image_handle_get_list_of_metadata_block_IDs(const heif_image_handle* handle,
+                                                     const char* type_filter,
+                                                     heif_item_id* ids, int count);
+
+// Return a string indicating the type of the metadata, as specified in the HEIF file.
+// Exif data will have the type string "Exif".
+// This string will be valid until the next call to a libheif function.
+// You do not have to free this string.
+LIBHEIF_API
+const char* heif_image_handle_get_metadata_type(const heif_image_handle* handle,
+                                                heif_item_id metadata_id);
+
+// For EXIF, the content type is empty.
+// For XMP, the content type is "application/rdf+xml".
+LIBHEIF_API
+const char* heif_image_handle_get_metadata_content_type(const heif_image_handle* handle,
+                                                        heif_item_id metadata_id);
+
+// Get the size of the raw metadata, as stored in the HEIF file.
+LIBHEIF_API
+size_t heif_image_handle_get_metadata_size(const heif_image_handle* handle,
+                                           heif_item_id metadata_id);
+
+// 'out_data' must point to a memory area of the size reported by heif_image_handle_get_metadata_size().
+// The data is returned exactly as stored in the HEIF file.
+// For Exif data, you probably have to skip the first four bytes of the data, since they
+// indicate the offset to the start of the TIFF header of the Exif data.
+LIBHEIF_API
+heif_error heif_image_handle_get_metadata(const heif_image_handle* handle,
+                                          heif_item_id metadata_id,
+                                          void* out_data);
+
+// Only valid for item type == "uri ", an absolute URI
+LIBHEIF_API
+const char* heif_image_handle_get_metadata_item_uri_type(const heif_image_handle* handle,
+                                                         heif_item_id metadata_id);
+
+// --- writing Exif / XMP metadata ---
+
+// Add EXIF metadata to an image.
+LIBHEIF_API
+heif_error heif_context_add_exif_metadata(heif_context*,
+                                          const heif_image_handle* image_handle,
+                                          const void* data, int size);
+
+// Add XMP metadata to an image.
+LIBHEIF_API
+heif_error heif_context_add_XMP_metadata(heif_context*,
+                                         const heif_image_handle* image_handle,
+                                         const void* data, int size);
+
+// New version of heif_context_add_XMP_metadata() with data compression (experimental).
+LIBHEIF_API
+heif_error heif_context_add_XMP_metadata2(heif_context*,
+                                          const heif_image_handle* image_handle,
+                                          const void* data, int size,
+                                          enum heif_metadata_compression compression);
+
+// Add generic, proprietary metadata to an image. You have to specify an 'item_type' that will
+// identify your metadata. 'content_type' can be an additional type, or it can be NULL.
+// For example, this function can be used to add IPTC metadata (IIM stream, not XMP) to an image.
+// Although not standard, we propose to store IPTC data with item type="iptc", content_type=NULL.
+LIBHEIF_API
+heif_error heif_context_add_generic_metadata(heif_context* ctx,
+                                             const heif_image_handle* image_handle,
+                                             const void* data, int size,
+                                             const char* item_type, const char* content_type);
+
+// Add generic metadata with item_type "uri ". Items with this type do not have a content_type, but
+// an item_uri_type and they have no content_encoding (they are always stored uncompressed).
+LIBHEIF_API
+heif_error heif_context_add_generic_uri_metadata(heif_context* ctx,
+                                                 const heif_image_handle* image_handle,
+                                                 const void* data, int size,
+                                                 const char* item_uri_type,
+                                                 heif_item_id* out_item_id);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/libheif/heif_plugin.cc b/libheif/api/libheif/heif_plugin.cc
similarity index 79%
rename from libheif/heif_plugin.cc
rename to libheif/api/libheif/heif_plugin.cc
index 0afbfe7b56..facfcd2d95 100644
--- a/libheif/heif_plugin.cc
+++ b/libheif/api/libheif/heif_plugin.cc
@@ -1,6 +1,6 @@
 /*
  * HEIF codec.
- * Copyright (c) 2017 struktur AG, Dirk Farin <farin@struktur.de>
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
  *
  * This file is part of libheif.
  *
@@ -21,13 +21,13 @@
 #include "heif.h"
 #include "heif_plugin.h"  // needed to avoid 'unresolved symbols' on Visual Studio compiler
 
-struct heif_error heif_error_ok = {heif_error_Ok, heif_suberror_Unspecified, "Success"};
+heif_error heif_error_ok = {heif_error_Ok, heif_suberror_Unspecified, "Success"};
 
-struct heif_error heif_error_unsupported_parameter = {heif_error_Usage_error,
+heif_error heif_error_unsupported_parameter = {heif_error_Usage_error,
                                                       heif_suberror_Unsupported_parameter,
                                                       "Unsupported encoder parameter"};
 
-struct heif_error heif_error_invalid_parameter_value = {heif_error_Usage_error,
+heif_error heif_error_invalid_parameter_value = {heif_error_Usage_error,
                                                         heif_suberror_Invalid_parameter_value,
                                                         "Invalid parameter value"};
 
diff --git a/libheif/heif_plugin.h b/libheif/api/libheif/heif_plugin.h
similarity index 51%
rename from libheif/heif_plugin.h
rename to libheif/api/libheif/heif_plugin.h
index d1960fb12a..ce7a985936 100644
--- a/libheif/heif_plugin.h
+++ b/libheif/api/libheif/heif_plugin.h
@@ -1,6 +1,6 @@
 /*
  * HEIF codec.
- * Copyright (c) 2017 struktur AG, Dirk Farin <farin@struktur.de>
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
  *
  * This file is part of libheif.
  *
@@ -20,12 +20,13 @@
 
 #ifndef LIBHEIF_HEIF_PLUGIN_H
 #define LIBHEIF_HEIF_PLUGIN_H
+#include "heif_sequences.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#include <libheif/heif.h>
+#include <libheif/heif_encoding.h>
 
 
 // ====================================================================================================
@@ -40,7 +41,17 @@ extern "C" {
 //  1.1          1         1          1
 //  1.4          1         1          2
 //  1.8          1         2          2
+//  1.13         2         3          2
+//  1.15         3         3          2
+//  1.20         4         3          2
+//  1.21         5         4          2
 
+#define heif_decoder_plugin_latest_version 5
+#define heif_encoder_plugin_latest_version 4
+
+// The minimum plugin versions that can be used with this libheif version.
+#define heif_decoder_plugin_minimum_version 5
+#define heif_encoder_plugin_minimum_version 4
 
 // ====================================================================================================
 //  Decoder plugin API
@@ -48,45 +59,63 @@ extern "C" {
 //  added as plugins. A plugin has to implement the functions specified in heif_decoder_plugin
 //  and the plugin has to be registered to the libheif library using heif_register_decoder().
 
-struct heif_decoder_plugin
+typedef struct heif_decoder_plugin_compressed_format_description
+{
+  enum heif_compression_format format;
+
+} heif_decoder_plugin_compressed_format_description;
+
+
+typedef struct heif_decoder_plugin_options
 {
-  // API version supported by this plugin
-  int plugin_api_version; // current version: 1
+  enum heif_compression_format format;
+  int strict_decoding; // bool
+  int num_threads; // 0 - undefined, use decoder default
+
+} heif_decoder_plugin_options;
+
+
+typedef struct heif_decoder_plugin
+{
+  // API version supported by this plugin (see table above for supported versions)
+  int plugin_api_version;
 
 
   // --- version 1 functions ---
 
   // Human-readable name of the plugin
-  const char* (* get_plugin_name)();
+  const char* (* get_plugin_name)(void);
 
   // Global plugin initialization (may be NULL)
-  void (* init_plugin)();
+  void (* init_plugin)(void);
 
   // Global plugin deinitialization (may be NULL)
-  void (* deinit_plugin)();
+  void (* deinit_plugin)(void);
 
   // Query whether the plugin supports decoding of the given format
   // Result is a priority value. The plugin with the largest value wins.
-  // Default priority is 100.
+  // Default priority is 100. Returning 0 indicates that the plugin cannot decode this format.
   int (* does_support_format)(enum heif_compression_format format);
 
   // Create a new decoder context for decoding an image
-  struct heif_error (* new_decoder)(void** decoder);
+  heif_error (* new_decoder)(void** decoder);
 
   // Free the decoder context (heif_image can still be used after destruction)
   void (* free_decoder)(void* decoder);
 
   // Push more data into the decoder. This can be called multiple times.
   // This may not be called after any decode_*() function has been called.
-  struct heif_error (* push_data)(void* decoder, const void* data, size_t size);
+  heif_error (* push_data)(void* decoder, const void* data, size_t size);
 
 
   // --- After pushing the data into the decoder, the decode functions may be called only once.
 
-  struct heif_error (* decode_image)(void* decoder, struct heif_image** out_img);
+  heif_error (* decode_image)(void* decoder, heif_image** out_img);
 
 
-  // --- version 2 functions will follow below ... ---
+  // --- version 2 functions ---
+
+  void (* set_strict_decoding)(void* decoder, int flag);
 
   // If not NULL, this can provide a specialized function to convert YCbCr to sRGB, because
   // only the codec itself knows how to interpret the chroma samples and their locations.
@@ -99,33 +128,64 @@ struct heif_decoder_plugin
 
   // Reset decoder, such that we can feed in new data for another image.
   // void (*reset_image)(void* decoder);
-};
 
+  // --- version 3 functions ---
+
+  const char* id_name;
+
+  // --- version 4 functions ---
+
+  heif_error (* decode_next_image)(void* decoder, heif_image** out_img,
+                                   const heif_security_limits* limits);
+
+  // --- version 5 functions will follow below ... ---
+
+  uint32_t minimum_required_libheif_version;
+
+  // Query whether the plugin supports decoding of the given format
+  // Result is a priority value. The plugin with the largest value wins.
+  // Default priority is 100. Returning 0 indicates that the plugin cannot decode this format.
+  int (* does_support_format2)(const heif_decoder_plugin_compressed_format_description* format);
 
-enum heif_encoded_data_type
+  // Create a new decoder context for decoding an image
+  heif_error (* new_decoder2)(void** decoder, const heif_decoder_plugin_options*);
+
+  heif_error (* push_data2)(void* decoder, const void* data, size_t size, uintptr_t user_data);
+
+  heif_error (* flush_data)(void* decoder);
+
+  heif_error (* decode_next_image2)(void* decoder, heif_image** out_img,
+                                    uintptr_t* out_user_data,
+                                    const heif_security_limits* limits);
+
+  // --- Note: when adding new versions, also update `heif_decoder_plugin_latest_version`.
+} heif_decoder_plugin;
+
+
+typedef enum heif_encoded_data_type
 {
   heif_encoded_data_type_HEVC_header = 1,
   heif_encoded_data_type_HEVC_image = 2,
   heif_encoded_data_type_HEVC_depth_SEI = 3
-};
+} heif_encoded_data_type;
 
 
 // Specifies the class of the input image content.
 // The encoder may want to encode different classes with different parameters
 // (e.g. always encode alpha lossless)
-enum heif_image_input_class
+typedef enum heif_image_input_class
 {
   heif_image_input_class_normal = 1,
   heif_image_input_class_alpha = 2,
   heif_image_input_class_depth = 3,
   heif_image_input_class_thumbnail = 4
-};
+} heif_image_input_class;
 
 
-struct heif_encoder_plugin
+typedef struct heif_encoder_plugin
 {
-  // API version supported by this plugin
-  int plugin_api_version; // current version: 2
+  // API version supported by this plugin (see table above for supported versions)
+  int plugin_api_version;
 
 
   // --- version 1 functions ---
@@ -147,46 +207,46 @@ struct heif_encoder_plugin
 
 
   // Human-readable name of the plugin
-  const char* (* get_plugin_name)();
+  const char* (* get_plugin_name)(void);
 
   // Global plugin initialization (may be NULL)
-  void (* init_plugin)();
+  void (* init_plugin)(void);
 
   // Global plugin cleanup (may be NULL).
   // Free data that was allocated in init_plugin()
-  void (* cleanup_plugin)();
+  void (* cleanup_plugin)(void);
 
   // Create a new decoder context for decoding an image
-  struct heif_error (* new_encoder)(void** encoder);
+  heif_error (* new_encoder)(void** encoder);
 
   // Free the decoder context (heif_image can still be used after destruction)
   void (* free_encoder)(void* encoder);
 
-  struct heif_error (* set_parameter_quality)(void* encoder, int quality);
+  heif_error (* set_parameter_quality)(void* encoder, int quality);
 
-  struct heif_error (* get_parameter_quality)(void* encoder, int* quality);
+  heif_error (* get_parameter_quality)(void* encoder, int* quality);
 
-  struct heif_error (* set_parameter_lossless)(void* encoder, int lossless);
+  heif_error (* set_parameter_lossless)(void* encoder, int lossless);
 
-  struct heif_error (* get_parameter_lossless)(void* encoder, int* lossless);
+  heif_error (* get_parameter_lossless)(void* encoder, int* lossless);
 
-  struct heif_error (* set_parameter_logging_level)(void* encoder, int logging);
+  heif_error (* set_parameter_logging_level)(void* encoder, int logging);
 
-  struct heif_error (* get_parameter_logging_level)(void* encoder, int* logging);
+  heif_error (* get_parameter_logging_level)(void* encoder, int* logging);
 
-  const struct heif_encoder_parameter** (* list_parameters)(void* encoder);
+  const heif_encoder_parameter** (* list_parameters)(void* encoder);
 
-  struct heif_error (* set_parameter_integer)(void* encoder, const char* name, int value);
+  heif_error (* set_parameter_integer)(void* encoder, const char* name, int value);
 
-  struct heif_error (* get_parameter_integer)(void* encoder, const char* name, int* value);
+  heif_error (* get_parameter_integer)(void* encoder, const char* name, int* value);
 
-  struct heif_error (* set_parameter_boolean)(void* encoder, const char* name, int value);
+  heif_error (* set_parameter_boolean)(void* encoder, const char* name, int value);
 
-  struct heif_error (* get_parameter_boolean)(void* encoder, const char* name, int* value);
+  heif_error (* get_parameter_boolean)(void* encoder, const char* name, int* value);
 
-  struct heif_error (* set_parameter_string)(void* encoder, const char* name, const char* value);
+  heif_error (* set_parameter_string)(void* encoder, const char* name, const char* value);
 
-  struct heif_error (* get_parameter_string)(void* encoder, const char* name, char* value, int value_size);
+  heif_error (* get_parameter_string)(void* encoder, const char* name, char* value, int value_size);
 
   // Replace the input colorspace/chroma with the one that is supported by the encoder and that
   // comes as close to the input colorspace/chroma as possible.
@@ -196,12 +256,12 @@ struct heif_encoder_plugin
   // Encode an image.
   // After pushing an image into the encoder, you should call get_compressed_data() to
   // get compressed data until it returns a NULL data pointer.
-  struct heif_error (* encode_image)(void* encoder, const struct heif_image* image,
-                                     enum heif_image_input_class image_class);
+  heif_error (* encode_image)(void* encoder, const heif_image* image,
+                              enum heif_image_input_class image_class);
 
   // Get a packet of decoded data. The data format depends on the codec.
   // For HEVC, each packet shall contain exactly one NAL, starting with the NAL header without startcode.
-  struct heif_error (* get_compressed_data)(void* encoder, uint8_t** data, int* size,
+  heif_error (* get_compressed_data)(void* encoder, uint8_t** data, int* size,
                                             enum heif_encoded_data_type* type);
 
 
@@ -216,11 +276,34 @@ struct heif_encoder_plugin
   // The encoded image size may be different from the input frame size, e.g. because
   // of required rounding, or a required minimum size. Use this function to return
   // the encoded size for a given input image size.
+  // You may set this to NULL if no padding is required for any image size.
   void (* query_encoded_size)(void* encoder, uint32_t input_width, uint32_t input_height,
                               uint32_t* encoded_width, uint32_t* encoded_height);
 
-  // --- version 4 functions will follow below ... ---
-};
+  // --- version 4 ---
+
+  uint32_t minimum_required_libheif_version;
+
+  heif_error (* start_sequence_encoding)(void* encoder, const heif_image* image,
+                                         enum heif_image_input_class image_class,
+                                         uint32_t framerate_num, uint32_t framerate_denom,
+                                         const heif_sequence_encoding_options* options);
+  // TODO: is heif_sequence_encoding_options a good choice here?
+
+  heif_error (* encode_sequence_frame)(void* encoder, const heif_image* image, uintptr_t frame_nr);
+
+  heif_error (* end_sequence_encoding)(void* encoder);
+
+  heif_error (* get_compressed_data2)(void* encoder, uint8_t** data, int* size,
+                                      uintptr_t* frame_nr,
+                                      int* is_keyframe, int* more_frame_packets);
+
+  int does_indicate_keyframes;
+
+  // --- version 5 functions will follow below ... ---
+
+  // --- Note: when adding new versions, also update `heif_encoder_plugin_latest_version`.
+} heif_encoder_plugin;
 
 
 // Names for standard parameters. These should only be used by the encoder plugins.
@@ -229,7 +312,8 @@ struct heif_encoder_plugin
 
 // For use only by the encoder plugins.
 // Application programs should use the access functions.
-struct heif_encoder_parameter
+// NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
+typedef struct heif_encoder_parameter
 {
   int version; // current version: 2
 
@@ -268,13 +352,25 @@ struct heif_encoder_parameter
   // --- version 2 fields
 
   int has_default;
-};
-
-
-extern struct heif_error heif_error_ok;
-extern struct heif_error heif_error_unsupported_parameter;
-extern struct heif_error heif_error_invalid_parameter_value;
-
+} heif_encoder_parameter;
+
+
+extern heif_error heif_error_ok;
+extern heif_error heif_error_unsupported_parameter;
+extern heif_error heif_error_invalid_parameter_value;
+
+#define HEIF_WARN_OR_FAIL(strict, image, cmd, cleanupBlock) \
+{ heif_error e = cmd;                         \
+  if (e.code != heif_error_Ok) {              \
+    if (strict) {                             \
+      cleanupBlock                            \
+      return e;                               \
+    }                                         \
+    else {                                    \
+      heif_image_add_decoding_warning(image, e); \
+    }                                         \
+  }                                           \
+}
 #ifdef __cplusplus
 }
 #endif
diff --git a/libheif/api/libheif/heif_properties.cc b/libheif/api/libheif/heif_properties.cc
new file mode 100644
index 0000000000..ad48c2c9e2
--- /dev/null
+++ b/libheif/api/libheif/heif_properties.cc
@@ -0,0 +1,480 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "libheif/heif_properties.h"
+#include "context.h"
+#include "api_structs.h"
+#include "file.h"
+
+#include <array>
+#include <cstring>
+#include <memory>
+#include <vector>
+#include <string>
+#include <algorithm>
+
+int heif_item_get_properties_of_type(const heif_context* context,
+                                     heif_item_id id,
+                                     heif_item_property_type type,
+                                     heif_property_id* out_list,
+                                     int count)
+{
+  auto file = context->context->get_heif_file();
+
+  std::vector<std::shared_ptr<Box>> properties;
+  Error err = file->get_properties(id, properties);
+  if (err) {
+    // We do not pass the error, because a missing ipco should have been detected already when reading the file.
+    return 0;
+  }
+
+  int out_idx = 0;
+  int property_id = 1;
+
+  for (const auto& property : properties) {
+    bool match;
+    if (type == heif_item_property_type_invalid) {
+      match = true;
+    }
+    else {
+      match = (property->get_short_type() == type);
+    }
+
+    if (match) {
+      if (out_list && out_idx < count) {
+        out_list[out_idx] = property_id;
+        out_idx++;
+      }
+      else if (!out_list) {
+        out_idx++;
+      }
+    }
+
+    property_id++;
+  }
+
+  return out_idx;
+}
+
+
+int heif_item_get_transformation_properties(const heif_context* context,
+                                            heif_item_id id,
+                                            heif_property_id* out_list,
+                                            int count)
+{
+  auto file = context->context->get_heif_file();
+
+  std::vector<std::shared_ptr<Box>> properties;
+  Error err = file->get_properties(id, properties);
+  if (err) {
+    // We do not pass the error, because a missing ipco should have been detected already when reading the file.
+    return 0;
+  }
+
+  int out_idx = 0;
+  int property_id = 1;
+
+  for (const auto& property : properties) {
+    bool match = (property->get_short_type() == fourcc("imir") ||
+                  property->get_short_type() == fourcc("irot") ||
+                  property->get_short_type() == fourcc("clap"));
+
+    if (match) {
+      if (out_list && out_idx < count) {
+        out_list[out_idx] = property_id;
+        out_idx++;
+      }
+      else if (!out_list) {
+        out_idx++;
+      }
+    }
+
+    property_id++;
+  }
+
+  return out_idx;
+}
+
+heif_item_property_type heif_item_get_property_type(const heif_context* context,
+                                                    heif_item_id id,
+                                                    heif_property_id propertyId)
+{
+  auto file = context->context->get_heif_file();
+
+  std::vector<std::shared_ptr<Box>> properties;
+  Error err = file->get_properties(id, properties);
+  if (err) {
+    // We do not pass the error, because a missing ipco should have been detected already when reading the file.
+    return heif_item_property_type_invalid;
+  }
+
+  if (propertyId < 1 || propertyId - 1 >= properties.size()) {
+    return heif_item_property_type_invalid;
+  }
+
+  auto property = properties[propertyId - 1];
+  return (heif_item_property_type) property->get_short_type();
+}
+
+
+static char* create_c_string_copy(const std::string s)
+{
+  char* copy = new char[s.length() + 1];
+  strcpy(copy, s.data());
+  return copy;
+}
+
+
+heif_error heif_item_get_property_user_description(const heif_context* context,
+                                                   heif_item_id itemId,
+                                                   heif_property_id propertyId,
+                                                   heif_property_user_description** out)
+{
+  if (!out || !context) {
+    return heif_error_null_pointer_argument;
+  }
+  auto udes = context->context->find_property<Box_udes>(itemId, propertyId);
+  if (!udes) {
+    return udes.error_struct(context->context.get());
+  }
+
+  auto* udes_c = new heif_property_user_description();
+  udes_c->version = 1;
+  udes_c->lang = create_c_string_copy((*udes)->get_lang());
+  udes_c->name = create_c_string_copy((*udes)->get_name());
+  udes_c->description = create_c_string_copy((*udes)->get_description());
+  udes_c->tags = create_c_string_copy((*udes)->get_tags());
+
+  *out = udes_c;
+
+  return heif_error_success;
+}
+
+
+heif_error heif_item_add_property_user_description(const heif_context* context,
+                                                   heif_item_id itemId,
+                                                   const heif_property_user_description* description,
+                                                   heif_property_id* out_propertyId)
+{
+  if (!context || !description) {
+    return heif_error_null_pointer_argument;
+  }
+
+  auto udes = std::make_shared<Box_udes>();
+  udes->set_lang(description->lang ? description->lang : "");
+  udes->set_name(description->name ? description->name : "");
+  udes->set_description(description->description ? description->description : "");
+  udes->set_tags(description->tags ? description->tags : "");
+
+  heif_property_id id = context->context->add_property(itemId, udes, false);
+
+  if (out_propertyId) {
+    *out_propertyId = id;
+  }
+
+  return heif_error_success;
+}
+
+
+void heif_property_user_description_release(heif_property_user_description* udes)
+{
+  if (udes == nullptr) {
+    return;
+  }
+
+  delete[] udes->lang;
+  delete[] udes->name;
+  delete[] udes->description;
+  delete[] udes->tags;
+
+  delete udes;
+}
+
+
+heif_transform_mirror_direction heif_item_get_property_transform_mirror(const heif_context* context,
+                                                                        heif_item_id itemId,
+                                                                        heif_property_id propertyId)
+{
+  auto imir = context->context->find_property<Box_imir>(itemId, propertyId);
+  if (!imir) {
+    return heif_transform_mirror_direction_invalid;
+  }
+
+  return (*imir)->get_mirror_direction();
+}
+
+
+int heif_item_get_property_transform_rotation_ccw(const heif_context* context,
+                                                  heif_item_id itemId,
+                                                  heif_property_id propertyId)
+{
+  auto irot = context->context->find_property<Box_irot>(itemId, propertyId);
+  if (!irot) {
+    return -1;
+  }
+
+  return (*irot)->get_rotation_ccw();
+}
+
+void heif_item_get_property_transform_crop_borders(const heif_context* context,
+                                                   heif_item_id itemId,
+                                                   heif_property_id propertyId,
+                                                   int image_width, int image_height,
+                                                   int* left, int* top, int* right, int* bottom)
+{
+  auto clap = context->context->find_property<Box_clap>(itemId, propertyId);
+  if (!clap) {
+    return;
+  }
+
+  if (left) *left = (*clap)->left_rounded(image_width);
+  if (right) *right = image_width - 1 - (*clap)->right_rounded(image_width);
+  if (top) *top = (*clap)->top_rounded(image_height);
+  if (bottom) *bottom = image_height - 1 - (*clap)->bottom_rounded(image_height);
+}
+
+
+heif_error heif_item_add_raw_property(const heif_context* context,
+                                      heif_item_id itemId,
+                                      uint32_t short_type,
+                                      const uint8_t* uuid_type,
+                                      const uint8_t* data, size_t size,
+                                      int is_essential,
+                                      heif_property_id* out_propertyId)
+{
+  if (!context || !data || (short_type == fourcc("uuid") && uuid_type==nullptr)) {
+    return heif_error_null_pointer_argument;
+  }
+
+  auto raw_box = std::make_shared<Box_other>(short_type);
+
+  if (short_type == fourcc("uuid")) {
+    std::vector<uint8_t> uuid_type_vector(uuid_type, uuid_type + 16);
+    raw_box->set_uuid_type(uuid_type_vector);
+  }
+
+  std::vector<uint8_t> data_vector(data, data + size);
+  raw_box->set_raw_data(data_vector);
+
+  heif_property_id id = context->context->add_property(itemId, raw_box, is_essential != 0);
+
+  if (out_propertyId) {
+    *out_propertyId = id;
+  }
+
+  return heif_error_success;
+}
+
+
+heif_error heif_item_get_property_raw_size(const heif_context* context,
+                                           heif_item_id itemId,
+                                           heif_property_id propertyId,
+                                           size_t* size_out)
+{
+  if (!context || !size_out) {
+    return heif_error_null_pointer_argument;
+  }
+  auto box_other = context->context->find_property<Box_other>(itemId, propertyId);
+  if (!box_other) {
+    return box_other.error_struct(context->context.get());
+  }
+
+  // TODO: every Box (not just Box_other) should have a get_raw_data() method.
+  if (*box_other == nullptr) {
+    return {heif_error_Usage_error, heif_suberror_Invalid_property, "this property is not read as a raw box"};
+  }
+
+  const auto& data = (*box_other)->get_raw_data();
+
+  *size_out = data.size();
+
+  return heif_error_success;
+}
+
+
+heif_error heif_item_get_property_raw_data(const heif_context* context,
+                                           heif_item_id itemId,
+                                           heif_property_id propertyId,
+                                           uint8_t* data_out)
+{
+  if (!context || !data_out) {
+    return heif_error_null_pointer_argument;
+  }
+
+  auto box_other = context->context->find_property<Box_other>(itemId, propertyId);
+  if (!box_other) {
+    return box_other.error_struct(context->context.get());
+  }
+
+  // TODO: every Box (not just Box_other) should have a get_raw_data() method.
+  if (*box_other == nullptr) {
+    return {heif_error_Usage_error, heif_suberror_Invalid_property, "this property is not read as a raw box"};
+  }
+
+  auto data = (*box_other)->get_raw_data();
+
+  std::copy(data.begin(), data.end(), data_out);
+
+  return heif_error_success;
+}
+
+
+heif_error heif_item_get_property_uuid_type(const heif_context* context,
+                                            heif_item_id itemId,
+                                            heif_property_id propertyId,
+                                            uint8_t extended_type[16])
+{
+  if (!context || !extended_type) {
+    return heif_error_null_pointer_argument;
+  }
+
+  auto box_other = context->context->find_property<Box_other>(itemId, propertyId);
+  if (!box_other) {
+    return box_other.error_struct(context->context.get());
+  }
+
+  if (*box_other == nullptr) {
+    return {heif_error_Usage_error, heif_suberror_Invalid_property, "this property is not read as a raw box"};
+  }
+
+  auto uuid = (*box_other)->get_uuid_type();
+
+  std::copy(uuid.begin(), uuid.end(), extended_type);
+
+  return heif_error_success;
+}
+
+
+
+// ------------------------- intrinsic and extrinsic matrices -------------------------
+
+
+int heif_image_handle_has_camera_intrinsic_matrix(const heif_image_handle* handle)
+{
+  if (!handle) {
+    return false;
+  }
+
+  return handle->image->has_intrinsic_matrix();
+}
+
+
+heif_error heif_image_handle_get_camera_intrinsic_matrix(const heif_image_handle* handle,
+                                                         heif_camera_intrinsic_matrix* out_matrix)
+{
+  if (handle == nullptr || out_matrix == nullptr) {
+    return heif_error_null_pointer_argument;
+  }
+
+  if (!handle->image->has_intrinsic_matrix()) {
+    Error err(heif_error_Usage_error,
+              heif_suberror_Camera_intrinsic_matrix_undefined);
+    return err.error_struct(handle->image.get());
+  }
+
+  const auto& m = handle->image->get_intrinsic_matrix();
+  out_matrix->focal_length_x = m.focal_length_x;
+  out_matrix->focal_length_y = m.focal_length_y;
+  out_matrix->principal_point_x = m.principal_point_x;
+  out_matrix->principal_point_y = m.principal_point_y;
+  out_matrix->skew = m.skew;
+
+  return heif_error_success;
+}
+
+
+int heif_image_handle_has_camera_extrinsic_matrix(const heif_image_handle* handle)
+{
+  if (!handle) {
+    return false;
+  }
+
+  return handle->image->has_extrinsic_matrix();
+}
+
+
+struct heif_camera_extrinsic_matrix
+{
+  Box_cmex::ExtrinsicMatrix matrix;
+};
+
+
+heif_error heif_image_handle_get_camera_extrinsic_matrix(const heif_image_handle* handle,
+                                                         heif_camera_extrinsic_matrix** out_matrix)
+{
+  if (handle == nullptr || out_matrix == nullptr) {
+    return heif_error_null_pointer_argument;
+  }
+
+  if (!handle->image->has_extrinsic_matrix()) {
+    Error err(heif_error_Usage_error,
+              heif_suberror_Camera_extrinsic_matrix_undefined);
+    return err.error_struct(handle->image.get());
+  }
+
+  *out_matrix = new heif_camera_extrinsic_matrix;
+  (*out_matrix)->matrix = handle->image->get_extrinsic_matrix();
+
+  return heif_error_success;
+}
+
+
+void heif_camera_extrinsic_matrix_release(heif_camera_extrinsic_matrix* matrix)
+{
+  delete matrix;
+}
+
+
+heif_error heif_camera_extrinsic_matrix_get_rotation_matrix(const heif_camera_extrinsic_matrix* matrix,
+                                                            double* out_matrix_row_major)
+{
+  if (matrix == nullptr || out_matrix_row_major == nullptr) {
+    return heif_error_null_pointer_argument;
+  }
+
+  auto m3x3 = matrix->matrix.calculate_rotation_matrix();
+
+  for (int i=0;i<9;i++) {
+    out_matrix_row_major[i] = m3x3[i];
+  }
+
+  return heif_error_success;
+}
+
+#if HEIF_WITH_OMAF
+int heif_image_handle_has_omaf_image_projection(const heif_image_handle* handle)
+{
+  if (!handle) {
+    return false;
+  }
+
+  return handle->image->has_omaf_image_projection();
+}
+
+heif_omaf_image_projection heif_image_handle_get_omaf_image_projection(const heif_image_handle* handle)
+{
+  return handle->image->get_omaf_image_projection();
+}
+
+void heif_image_handle_set_omaf_image_projection(const heif_image_handle* handle, heif_omaf_image_projection image_projection)
+{
+  return handle->image->set_omaf_image_projection(image_projection);
+}
+#endif
diff --git a/libheif/api/libheif/heif_properties.h b/libheif/api/libheif/heif_properties.h
new file mode 100644
index 0000000000..8f7278569d
--- /dev/null
+++ b/libheif/api/libheif/heif_properties.h
@@ -0,0 +1,247 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017-2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_HEIF_PROPERTIES_H
+#define LIBHEIF_HEIF_PROPERTIES_H
+
+#include "heif.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// ------------------------- item properties -------------------------
+
+typedef enum heif_item_property_type
+{
+//  heif_item_property_unknown = -1,
+  heif_item_property_type_invalid = 0,
+  heif_item_property_type_user_description = heif_fourcc('u', 'd', 'e', 's'),
+  heif_item_property_type_transform_mirror = heif_fourcc('i', 'm', 'i', 'r'),
+  heif_item_property_type_transform_rotation = heif_fourcc('i', 'r', 'o', 't'),
+  heif_item_property_type_transform_crop = heif_fourcc('c', 'l', 'a', 'p'),
+  heif_item_property_type_image_size = heif_fourcc('i', 's', 'p', 'e'),
+  heif_item_property_type_uuid = heif_fourcc('u', 'u', 'i', 'd'),
+  heif_item_property_type_tai_clock_info = heif_fourcc('t', 'a', 'i', 'c'),
+  heif_item_property_type_tai_timestamp = heif_fourcc('i', 't', 'a', 'i'),
+  heif_item_property_type_extended_language = heif_fourcc('e', 'l', 'n', 'g')
+} heif_item_property_type;
+
+// Get the heif_property_id for a heif_item_id.
+// You may specify which property 'type' you want to receive.
+// If you specify 'heif_item_property_type_invalid', all properties associated to that item are returned.
+// The number of properties is returned, which are not more than 'count' if (out_list != nullptr).
+// By setting out_list==nullptr, you can query the number of properties, 'count' is ignored.
+LIBHEIF_API
+int heif_item_get_properties_of_type(const heif_context* context,
+                                     heif_item_id id,
+                                     enum heif_item_property_type type,
+                                     heif_property_id* out_list,
+                                     int count);
+
+// Returns all transformative properties in the correct order.
+// This includes "irot", "imir", "clap".
+// The number of properties is returned, which are not more than 'count' if (out_list != nullptr).
+// By setting out_list==nullptr, you can query the number of properties, 'count' is ignored.
+LIBHEIF_API
+int heif_item_get_transformation_properties(const heif_context* context,
+                                            heif_item_id id,
+                                            heif_property_id* out_list,
+                                            int count);
+
+LIBHEIF_API
+enum heif_item_property_type heif_item_get_property_type(const heif_context* context,
+                                                         heif_item_id id,
+                                                         heif_property_id property_id);
+
+// The strings are managed by libheif. They will be deleted in heif_property_user_description_release().
+typedef struct heif_property_user_description
+{
+  int version;
+
+  // version 1
+
+  const char* lang;
+  const char* name;
+  const char* description;
+  const char* tags;
+} heif_property_user_description;
+
+// Get the "udes" user description property content.
+// Undefined strings are returned as empty strings.
+LIBHEIF_API
+heif_error heif_item_get_property_user_description(const heif_context* context,
+                                                   heif_item_id itemId,
+                                                   heif_property_id propertyId,
+                                                   heif_property_user_description** out);
+
+// Add a "udes" user description property to the item.
+// If any string pointers are NULL, an empty string will be used instead.
+LIBHEIF_API
+heif_error heif_item_add_property_user_description(const heif_context* context,
+                                                   heif_item_id itemId,
+                                                   const heif_property_user_description* description,
+                                                   heif_property_id* out_propertyId);
+
+// Release all strings and the object itself.
+// Only call for objects that you received from heif_item_get_property_user_description().
+LIBHEIF_API
+void heif_property_user_description_release(heif_property_user_description*);
+
+typedef enum heif_transform_mirror_direction
+{
+  heif_transform_mirror_direction_invalid = -1,
+  heif_transform_mirror_direction_vertical = 0,    // flip image vertically
+  heif_transform_mirror_direction_horizontal = 1   // flip image horizontally
+} heif_transform_mirror_direction;
+
+// Will return 'heif_transform_mirror_direction_invalid' in case of error.
+// If 'propertyId==0', it returns the first imir property found.
+LIBHEIF_API
+enum heif_transform_mirror_direction heif_item_get_property_transform_mirror(const heif_context* context,
+                                                                             heif_item_id itemId,
+                                                                             heif_property_id propertyId);
+
+// Returns only 0, 90, 180, or 270 angle values.
+// Returns -1 in case of error (but it will only return an error in case of wrong usage).
+// If 'propertyId==0', it returns the first irot property found.
+LIBHEIF_API
+int heif_item_get_property_transform_rotation_ccw(const heif_context* context,
+                                                  heif_item_id itemId,
+                                                  heif_property_id propertyId);
+
+// Returns the number of pixels that should be removed from the four edges.
+// Because of the way this data is stored, you have to pass the image size at the moment of the crop operation
+// to compute the cropped border sizes.
+// If 'propertyId==0', it returns the first clap property found.
+LIBHEIF_API
+void heif_item_get_property_transform_crop_borders(const heif_context* context,
+                                                   heif_item_id itemId,
+                                                   heif_property_id propertyId,
+                                                   int image_width, int image_height,
+                                                   int* left, int* top, int* right, int* bottom);
+
+/**
+ * @param context     The heif_context for the file
+ * @param itemId      The image item id to which this property belongs.
+ * @param fourcc_type The short four-cc type of the property to add.
+ * @param uuid_type   If fourcc_type=='uuid', this should point to a 16-byte UUID type. It is ignored otherwise and can be NULL.
+ * @param data        Data to insert for this property (including a full-box header, if required for this box).
+ * @param size        Length of data in bytes.
+ * @param is_essential   Whether this property is essential (boolean).
+ * @param out_propertyId Outputs the id of the inserted property. Can be NULL.
+*/
+LIBHEIF_API
+heif_error heif_item_add_raw_property(const heif_context* context,
+                                      heif_item_id itemId,
+                                      uint32_t fourcc_type,
+                                      const uint8_t* uuid_type,
+                                      const uint8_t* data, size_t size,
+                                      int is_essential,
+                                      heif_property_id* out_propertyId);
+
+LIBHEIF_API
+heif_error heif_item_get_property_raw_size(const heif_context* context,
+                                           heif_item_id itemId,
+                                           heif_property_id propertyId,
+                                           size_t* out_size);
+
+/**
+ * @param out_data User-supplied array to write the property data to. The required size of the output array is given by heif_item_get_property_raw_size().
+*/
+LIBHEIF_API
+heif_error heif_item_get_property_raw_data(const heif_context* context,
+                                           heif_item_id itemId,
+                                           heif_property_id propertyId,
+                                           uint8_t* out_data);
+
+/**
+ * Get the extended type for an extended "uuid" box.
+ *
+ * This provides the UUID for the extended box.
+ *
+ * This method should only be called on properties of type `heif_item_property_type_uuid`.
+ *
+ * @param context the heif_context containing the HEIF file
+ * @param itemId the image item id to which this property belongs.
+ * @param propertyId the property index (1-based) to get the extended type for
+ * @param out_extended_type output of the call, must be a pointer to at least 16-bytes.
+ * @return heif_error_success or an error indicating the failure
+ */
+LIBHEIF_API
+heif_error heif_item_get_property_uuid_type(const heif_context* context,
+                                            heif_item_id itemId,
+                                            heif_property_id propertyId,
+                                            uint8_t out_extended_type[16]);
+
+
+// ------------------------- intrinsic and extrinsic matrices -------------------------
+
+typedef struct heif_camera_intrinsic_matrix
+{
+  double focal_length_x;
+  double focal_length_y;
+  double principal_point_x;
+  double principal_point_y;
+  double skew;
+} heif_camera_intrinsic_matrix;
+
+
+LIBHEIF_API
+int heif_image_handle_has_camera_intrinsic_matrix(const heif_image_handle* handle);
+
+LIBHEIF_API
+heif_error heif_image_handle_get_camera_intrinsic_matrix(const heif_image_handle* handle,
+                                                         heif_camera_intrinsic_matrix* out_matrix);
+
+
+typedef struct heif_camera_extrinsic_matrix heif_camera_extrinsic_matrix;
+
+LIBHEIF_API
+int heif_image_handle_has_camera_extrinsic_matrix(const heif_image_handle* handle);
+
+LIBHEIF_API
+heif_error heif_image_handle_get_camera_extrinsic_matrix(const heif_image_handle* handle,
+                                                         heif_camera_extrinsic_matrix** out_matrix);
+
+LIBHEIF_API
+void heif_camera_extrinsic_matrix_release(heif_camera_extrinsic_matrix*);
+
+LIBHEIF_API
+heif_error heif_camera_extrinsic_matrix_get_rotation_matrix(const heif_camera_extrinsic_matrix*,
+                                                            double* out_matrix_row_major);
+
+#if HEIF_WITH_OMAF
+// ------------------------- OMAF projection information -------------------------
+LIBHEIF_API
+int heif_image_handle_has_omaf_image_projection(const heif_image_handle* handle);
+
+LIBHEIF_API
+heif_omaf_image_projection heif_image_handle_get_omaf_image_projection(const heif_image_handle* handle);
+
+LIBHEIF_API
+void heif_image_handle_set_omaf_image_projection(const heif_image_handle* handle, heif_omaf_image_projection image_projection);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/libheif/api/libheif/heif_regions.cc b/libheif/api/libheif/heif_regions.cc
new file mode 100644
index 0000000000..b54b695200
--- /dev/null
+++ b/libheif/api/libheif/heif_regions.cc
@@ -0,0 +1,733 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ * Copyright (c) 2023 Brad Hards <bradh@frogmouth.net>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "heif_plugin.h"
+#include "region.h"
+#include "heif_regions.h"
+#include "file.h"
+#include "api_structs.h"
+#include "context.h"
+#include <cstring>
+#include <memory>
+#include <vector>
+#include <utility>
+#include <algorithm>
+
+
+int heif_image_handle_get_number_of_region_items(const heif_image_handle* handle)
+{
+  return (int) handle->image->get_region_item_ids().size();
+}
+
+int heif_image_handle_get_list_of_region_item_ids(const heif_image_handle* handle,
+                                                  heif_item_id* item_ids,
+                                                  int max_count)
+{
+  auto region_item_ids = handle->image->get_region_item_ids();
+  int num = std::min((int) region_item_ids.size(), max_count);
+
+  memcpy(item_ids, region_item_ids.data(), num * sizeof(heif_item_id));
+
+  return num;
+}
+
+
+heif_error heif_context_get_region_item(const heif_context* context,
+                                        heif_item_id region_item_id,
+                                        heif_region_item** out)
+{
+  if (out == nullptr) {
+    return heif_error_null_pointer_argument;
+  }
+
+  auto r = context->context->get_region_item(region_item_id);
+
+  if (r == nullptr) {
+    return {heif_error_Usage_error, heif_suberror_Nonexisting_item_referenced, "Region item does not exist"};
+  }
+
+  heif_region_item* item = new heif_region_item();
+  item->context = context->context;
+  item->region_item = std::move(r);
+  *out = item;
+
+  return heif_error_success;
+}
+
+
+heif_item_id heif_region_item_get_id(heif_region_item* region_item)
+{
+  if (region_item == nullptr) {
+    return 0;
+  }
+
+  return region_item->region_item->item_id;
+}
+
+
+void heif_region_item_release(heif_region_item* region_item)
+{
+  delete region_item;
+}
+
+
+void heif_region_item_get_reference_size(heif_region_item* region_item, uint32_t* width, uint32_t* height)
+{
+  auto r = region_item->context->get_region_item(region_item->region_item->item_id);
+
+  if (width) *width = r->reference_width;
+  if (height) *height = r->reference_height;
+}
+
+
+int heif_region_item_get_number_of_regions(const heif_region_item* region_item)
+{
+  return region_item->region_item->get_number_of_regions();
+}
+
+int heif_region_item_get_list_of_regions(const heif_region_item* region_item,
+                                         heif_region** out_regions,
+                                         int max_count)
+{
+  auto regions = region_item->region_item->get_regions();
+  int num = std::min(max_count, (int) regions.size());
+
+  for (int i = 0; i < num; i++) {
+    auto region = new heif_region();
+    region->context = region_item->context;
+    //region->parent_region_item_id = region_item->region_item->item_id;
+    region->region_item = region_item->region_item;
+    region->region = regions[i];
+
+    out_regions[i] = region;
+  }
+
+  return num;
+}
+
+
+void heif_region_release(const heif_region* region)
+{
+  delete region;
+}
+
+
+void heif_region_release_many(const heif_region* const* regions, int num)
+{
+  for (int i = 0; i < num; i++) {
+    delete regions[i];
+  }
+}
+
+
+heif_region_type heif_region_get_type(const heif_region* region)
+{
+  return region->region->getRegionType();
+}
+
+
+heif_error heif_region_get_point(const heif_region* region, int32_t* x, int32_t* y)
+{
+  if (!x || !y) {
+    return heif_error_null_pointer_argument;
+  }
+
+  const std::shared_ptr<RegionGeometry_Point> point = std::dynamic_pointer_cast<RegionGeometry_Point>(region->region);
+  if (point) {
+    *x = point->x;
+    *y = point->y;
+    return heif_error_success;
+  }
+
+  return heif_error_invalid_parameter_value;
+}
+
+
+heif_error heif_region_get_point_transformed(const struct heif_region* region, heif_item_id image_id, double* x, double* y)
+{
+  if (!x || !y) {
+    return heif_error_null_pointer_argument;
+  }
+
+  const std::shared_ptr<RegionGeometry_Point> point = std::dynamic_pointer_cast<RegionGeometry_Point>(region->region);
+  if (point) {
+    auto t = RegionCoordinateTransform::create(region->context->get_heif_file(), image_id,
+                                               region->region_item->reference_width,
+                                               region->region_item->reference_height);
+    RegionCoordinateTransform::Point p = t.transform_point({(double) point->x, (double) point->y});
+    *x = p.x;
+    *y = p.y;
+
+    return heif_error_success;
+  }
+
+  return heif_error_invalid_parameter_value;
+}
+
+
+heif_error heif_region_get_rectangle(const heif_region* region,
+                                     int32_t* x, int32_t* y,
+                                     uint32_t* width, uint32_t* height)
+{
+  const std::shared_ptr<RegionGeometry_Rectangle> rect = std::dynamic_pointer_cast<RegionGeometry_Rectangle>(region->region);
+  if (rect) {
+    *x = rect->x;
+    *y = rect->y;
+    *width = rect->width;
+    *height = rect->height;
+    return heif_error_success;
+  }
+
+  return heif_error_invalid_parameter_value;
+}
+
+
+heif_error heif_region_get_rectangle_transformed(const heif_region* region,
+                                                 heif_item_id image_id,
+                                                 double* x, double* y,
+                                                 double* width, double* height)
+{
+  const std::shared_ptr<RegionGeometry_Rectangle> rect = std::dynamic_pointer_cast<RegionGeometry_Rectangle>(region->region);
+  if (rect) {
+    auto t = RegionCoordinateTransform::create(region->context->get_heif_file(), image_id,
+                                               region->region_item->reference_width,
+                                               region->region_item->reference_height);
+
+    RegionCoordinateTransform::Point p = t.transform_point({(double) rect->x, (double) rect->y});
+    RegionCoordinateTransform::Extent e = t.transform_extent({(double) rect->width, (double) rect->height});
+
+    *x = p.x;
+    *y = p.y;
+    *width = e.x;
+    *height = e.y;
+    return heif_error_success;
+  }
+
+  return heif_error_invalid_parameter_value;
+}
+
+
+heif_error heif_region_get_ellipse(const heif_region* region,
+                                   int32_t* x, int32_t* y,
+                                   uint32_t* radius_x, uint32_t* radius_y)
+{
+  const std::shared_ptr<RegionGeometry_Ellipse> ellipse = std::dynamic_pointer_cast<RegionGeometry_Ellipse>(region->region);
+  if (ellipse) {
+    *x = ellipse->x;
+    *y = ellipse->y;
+    *radius_x = ellipse->radius_x;
+    *radius_y = ellipse->radius_y;
+    return heif_error_success;
+  }
+
+  return heif_error_invalid_parameter_value;
+}
+
+
+heif_error heif_region_get_ellipse_transformed(const heif_region* region,
+                                               heif_item_id image_id,
+                                               double* x, double* y,
+                                               double* radius_x, double* radius_y)
+{
+  const std::shared_ptr<RegionGeometry_Ellipse> ellipse = std::dynamic_pointer_cast<RegionGeometry_Ellipse>(region->region);
+  if (ellipse) {
+    auto t = RegionCoordinateTransform::create(region->context->get_heif_file(), image_id,
+                                               region->region_item->reference_width,
+                                               region->region_item->reference_height);
+
+    RegionCoordinateTransform::Point p = t.transform_point({(double) ellipse->x, (double) ellipse->y});
+    RegionCoordinateTransform::Extent e = t.transform_extent({(double) ellipse->radius_x, (double) ellipse->radius_y});
+
+    *x = p.x;
+    *y = p.y;
+    *radius_x = e.x;
+    *radius_y = e.y;
+    return heif_error_success;
+  }
+
+  return heif_error_invalid_parameter_value;
+}
+
+
+static int heif_region_get_poly_num_points(const heif_region* region)
+{
+  const std::shared_ptr<RegionGeometry_Polygon> polygon = std::dynamic_pointer_cast<RegionGeometry_Polygon>(region->region);
+  if (polygon) {
+    return (int) polygon->points.size();
+  }
+  return 0;
+}
+
+
+int heif_region_get_polygon_num_points(const heif_region* region)
+{
+  return heif_region_get_poly_num_points(region);
+}
+
+
+static heif_error heif_region_get_poly_points(const heif_region* region, int32_t* pts)
+{
+  if (pts == nullptr) {
+    return heif_error_invalid_parameter_value;
+  }
+
+  const std::shared_ptr<RegionGeometry_Polygon> poly = std::dynamic_pointer_cast<RegionGeometry_Polygon>(region->region);
+  if (poly) {
+    for (int i = 0; i < (int) poly->points.size(); i++) {
+      pts[2 * i + 0] = poly->points[i].x;
+      pts[2 * i + 1] = poly->points[i].y;
+    }
+    return heif_error_success;
+  }
+  return heif_error_invalid_parameter_value;
+}
+
+
+heif_error heif_region_get_polygon_points(const heif_region* region, int32_t* pts)
+{
+  return heif_region_get_poly_points(region, pts);
+}
+
+
+static heif_error heif_region_get_poly_points_scaled(const heif_region* region, double* pts, heif_item_id image_id)
+{
+  if (pts == nullptr) {
+    return heif_error_invalid_parameter_value;
+  }
+
+  const std::shared_ptr<RegionGeometry_Polygon> poly = std::dynamic_pointer_cast<RegionGeometry_Polygon>(region->region);
+  if (poly) {
+    auto t = RegionCoordinateTransform::create(region->context->get_heif_file(), image_id,
+                                               region->region_item->reference_width,
+                                               region->region_item->reference_height);
+
+    for (int i = 0; i < (int) poly->points.size(); i++) {
+      RegionCoordinateTransform::Point p = t.transform_point({
+                                                               (double) poly->points[i].x,
+                                                               (double) poly->points[i].y
+                                                             });
+
+      pts[2 * i + 0] = p.x;
+      pts[2 * i + 1] = p.y;
+    }
+    return heif_error_success;
+  }
+  return heif_error_invalid_parameter_value;
+}
+
+
+heif_error heif_region_get_polygon_points_transformed(const heif_region* region, heif_item_id image_id, double* pts)
+{
+  return heif_region_get_poly_points_scaled(region, pts, image_id);
+}
+
+
+int heif_region_get_polyline_num_points(const heif_region* region)
+{
+  return heif_region_get_poly_num_points(region);
+}
+
+
+heif_error heif_region_get_polyline_points(const heif_region* region, int32_t* pts)
+{
+  return heif_region_get_poly_points(region, pts);
+}
+
+
+heif_error heif_region_get_polyline_points_transformed(const heif_region* region, heif_item_id image_id, double* pts)
+{
+  return heif_region_get_poly_points_scaled(region, pts, image_id);
+}
+
+
+heif_error heif_region_get_referenced_mask_ID(const heif_region* region,
+                                              int32_t* x, int32_t* y,
+                                              uint32_t* width, uint32_t* height,
+                                              heif_item_id* mask_item_id)
+{
+  if ((x == nullptr) || (y == nullptr) || (width == nullptr) || (height == nullptr) || (mask_item_id == nullptr)) {
+    return heif_error_null_pointer_argument;
+  }
+
+  const std::shared_ptr<RegionGeometry_ReferencedMask> mask = std::dynamic_pointer_cast<RegionGeometry_ReferencedMask>(region->region);
+  if (mask) {
+    *x = mask->x;
+    *y = mask->y;
+    *width = mask->width;
+    *height = mask->height;
+    *mask_item_id = mask->referenced_item;
+    return heif_error_success;
+  }
+  return heif_error_invalid_parameter_value;
+}
+
+
+size_t heif_region_get_inline_mask_data_len(const heif_region* region)
+{
+  const std::shared_ptr<RegionGeometry_InlineMask> mask = std::dynamic_pointer_cast<RegionGeometry_InlineMask>(region->region);
+  if (mask) {
+    return mask->mask_data.size();
+  }
+  return 0;
+}
+
+
+static heif_region* create_region(const std::shared_ptr<RegionGeometry>& r,
+                                  heif_region_item* item)
+{
+  auto region = new heif_region();
+  region->region = r;
+  region->region_item = item->region_item;
+  region->context = item->context;
+  return region;
+}
+
+
+heif_error heif_region_item_add_region_inline_mask_data(heif_region_item* item,
+                                                        int32_t x, int32_t y,
+                                                        uint32_t width, uint32_t height,
+                                                        const uint8_t* mask_data,
+                                                        size_t mask_data_len,
+                                                        heif_region** out_region)
+{
+  auto region = std::make_shared<RegionGeometry_InlineMask>();
+  region->x = x;
+  region->y = y;
+  region->width = width;
+  region->height = height;
+  region->mask_data.resize(mask_data_len);
+  std::memcpy(region->mask_data.data(), mask_data, region->mask_data.size());
+
+  item->region_item->add_region(region);
+
+  if (out_region) {
+    *out_region = create_region(region, item);
+  }
+
+  return heif_error_success;
+}
+
+
+static heif_error heif_region_get_inline_mask_image(const heif_region* region,
+                                                    int32_t* out_x0, int32_t* out_y0,
+                                                    uint32_t* out_width, uint32_t* out_height,
+                                                    heif_image** out_mask_image)
+{
+  if ((out_x0 == nullptr) || (out_y0 == nullptr) || (out_width == nullptr) || (out_height == nullptr)) {
+    return heif_error_null_pointer_argument;
+  }
+
+  const std::shared_ptr<RegionGeometry_InlineMask> mask = std::dynamic_pointer_cast<RegionGeometry_InlineMask>(region->region);
+  if (mask) {
+    *out_x0 = mask->x;
+    *out_y0 = mask->y;
+    uint32_t width = *out_width = mask->width;
+    uint32_t height = *out_height = mask->height;
+    uint8_t* mask_data = mask->mask_data.data();
+
+    heif_error err = heif_image_create(width, height, heif_colorspace_monochrome, heif_chroma_monochrome, out_mask_image);
+    if (err.code) {
+      return err;
+    }
+    err = heif_image_add_plane(*out_mask_image, heif_channel_Y, width, height, 8);
+    if (err.code) {
+      heif_image_release(*out_mask_image);
+      return err;
+    }
+    size_t stride;
+    uint8_t* p = heif_image_get_plane2(*out_mask_image, heif_channel_Y, &stride);
+    uint64_t pixel_index = 0;
+
+    for (uint32_t y = 0; y < height; y++) {
+      for (uint32_t x = 0; x < width; x++) {
+        uint64_t mask_byte = pixel_index / 8;
+        uint8_t pixel_bit = uint8_t(0x80U >> (pixel_index % 8));
+
+        p[y * stride + x] = (mask_data[mask_byte] & pixel_bit) ? 255 : 0;
+
+        pixel_index++;
+      }
+    }
+    return heif_error_success;
+  }
+  return heif_error_invalid_parameter_value;
+}
+
+
+heif_error heif_region_get_mask_image(const heif_region* region,
+                                      int32_t* x, int32_t* y,
+                                      uint32_t* width, uint32_t* height,
+                                      heif_image** mask_image)
+{
+  if (region->region->getRegionType() == heif_region_type_inline_mask) {
+    return heif_region_get_inline_mask_image(region, x, y, width, height, mask_image);
+  }
+  else if (region->region->getRegionType() == heif_region_type_referenced_mask) {
+    heif_item_id referenced_item_id = 0;
+    heif_error err = heif_region_get_referenced_mask_ID(region, x, y, width, height, &referenced_item_id);
+    if (err.code != heif_error_Ok) {
+      return err;
+    }
+
+    heif_context ctx;
+    ctx.context = region->context;
+
+    heif_image_handle* mski_handle_in;
+    err = heif_context_get_image_handle(&ctx, referenced_item_id, &mski_handle_in);
+    if (err.code != heif_error_Ok) {
+      assert(mski_handle_in == nullptr);
+      return err;
+    }
+
+    err = heif_decode_image(mski_handle_in, mask_image, heif_colorspace_monochrome, heif_chroma_monochrome, NULL);
+
+    heif_image_handle_release(mski_handle_in);
+
+    return err;
+  }
+
+  return heif_error_invalid_parameter_value;
+}
+
+
+heif_error heif_image_handle_add_region_item(heif_image_handle* image_handle,
+                                             uint32_t reference_width, uint32_t reference_height,
+                                             heif_region_item** out_region_item)
+{
+  auto regionItemResult = image_handle->context->add_region_item(reference_width, reference_height);
+  if (!regionItemResult) {
+    return regionItemResult.error_struct(image_handle->context.get());
+  }
+  std::shared_ptr<RegionItem> regionItem = *regionItemResult;
+  image_handle->image->add_region_item_id(regionItem->item_id);
+
+  if (out_region_item) {
+    heif_region_item* item = new heif_region_item();
+    item->context = image_handle->context;
+    item->region_item = std::move(regionItem);
+
+    *out_region_item = item;
+  }
+
+  return heif_error_success;
+}
+
+
+heif_error heif_region_item_add_region_point(heif_region_item* item,
+                                             int32_t x, int32_t y,
+                                             heif_region** out_region)
+{
+  auto region = std::make_shared<RegionGeometry_Point>();
+  region->x = x;
+  region->y = y;
+
+  item->region_item->add_region(region);
+
+  if (out_region) {
+    *out_region = create_region(region, item);
+  }
+
+  return heif_error_success;
+}
+
+
+heif_error heif_region_item_add_region_rectangle(heif_region_item* item,
+                                                 int32_t x, int32_t y,
+                                                 uint32_t width, uint32_t height,
+                                                 heif_region** out_region)
+{
+  auto region = std::make_shared<RegionGeometry_Rectangle>();
+  region->x = x;
+  region->y = y;
+  region->width = width;
+  region->height = height;
+
+  item->region_item->add_region(region);
+
+  if (out_region) {
+    *out_region = create_region(region, item);
+  }
+
+  return heif_error_success;
+}
+
+
+heif_error heif_region_item_add_region_ellipse(heif_region_item* item,
+                                               int32_t x, int32_t y,
+                                               uint32_t radius_x, uint32_t radius_y,
+                                               heif_region** out_region)
+{
+  auto region = std::make_shared<RegionGeometry_Ellipse>();
+  region->x = x;
+  region->y = y;
+  region->radius_x = radius_x;
+  region->radius_y = radius_y;
+
+  item->region_item->add_region(region);
+
+  if (out_region) {
+    *out_region = create_region(region, item);
+  }
+
+  return heif_error_success;
+}
+
+
+heif_error heif_region_item_add_region_polygon(heif_region_item* item,
+                                               const int32_t* pts, int nPoints,
+                                               heif_region** out_region)
+{
+  auto region = std::make_shared<RegionGeometry_Polygon>();
+  region->points.resize(nPoints);
+
+  for (int i = 0; i < nPoints; i++) {
+    region->points[i].x = pts[2 * i + 0];
+    region->points[i].y = pts[2 * i + 1];
+  }
+
+  region->closed = true;
+
+  item->region_item->add_region(region);
+
+  if (out_region) {
+    *out_region = create_region(region, item);
+  }
+
+  return heif_error_success;
+}
+
+
+heif_error heif_region_item_add_region_polyline(heif_region_item* item,
+                                                const int32_t* pts, int nPoints,
+                                                heif_region** out_region)
+{
+  auto region = std::make_shared<RegionGeometry_Polygon>();
+  region->points.resize(nPoints);
+
+  for (int i = 0; i < nPoints; i++) {
+    region->points[i].x = pts[2 * i + 0];
+    region->points[i].y = pts[2 * i + 1];
+  }
+
+  region->closed = false;
+
+  item->region_item->add_region(region);
+
+  if (out_region) {
+    *out_region = create_region(region, item);
+  }
+
+  return heif_error_success;
+}
+
+
+heif_error heif_region_item_add_region_referenced_mask(heif_region_item* item,
+                                                       int32_t x, int32_t y,
+                                                       uint32_t width, uint32_t height,
+                                                       heif_item_id mask_item_id,
+                                                       heif_region** out_region)
+{
+  auto region = std::make_shared<RegionGeometry_ReferencedMask>();
+  region->x = x;
+  region->y = y;
+  region->width = width;
+  region->height = height;
+  region->referenced_item = mask_item_id;
+
+  item->region_item->add_region(region);
+
+  if (out_region) {
+    *out_region = create_region(region, item);
+  }
+
+  /* When the geometry 'mask' of a region is represented by a mask stored in
+   * another image item the image item containing the mask shall be identified
+   * by an item reference of type 'mask' from the region item to the image item
+   * containing the mask. */
+  std::shared_ptr<HeifContext> ctx = item->context;
+  ctx->add_region_referenced_mask_ref(item->region_item->item_id, mask_item_id);
+
+  return heif_error_success;
+}
+
+
+heif_error heif_region_get_inline_mask_data(const heif_region* region,
+                                            int32_t* x, int32_t* y,
+                                            uint32_t* width, uint32_t* height,
+                                            uint8_t* data)
+{
+  if ((x == nullptr) || (y == nullptr) || (width == nullptr) || (height == nullptr)) {
+    return heif_error_null_pointer_argument;
+  }
+
+  const std::shared_ptr<RegionGeometry_InlineMask> mask = std::dynamic_pointer_cast<RegionGeometry_InlineMask>(region->region);
+  if (mask) {
+    *x = mask->x;
+    *y = mask->y;
+    *width = mask->width;
+    *height = mask->height;
+    memcpy(data, mask->mask_data.data(), mask->mask_data.size());
+    return heif_error_success;
+  }
+  return heif_error_invalid_parameter_value;
+}
+
+
+heif_error heif_region_item_add_region_inline_mask(heif_region_item* item,
+                                                   int32_t x0, int32_t y0,
+                                                   uint32_t width, uint32_t height,
+                                                   heif_image* mask_image,
+                                                   heif_region** out_region)
+{
+  if (!heif_image_has_channel(mask_image, heif_channel_Y)) {
+    return {heif_error_Usage_error, heif_suberror_Nonexisting_image_channel_referenced, "Inline mask image must have a Y channel"};
+  }
+  auto region = std::make_shared<RegionGeometry_InlineMask>();
+  region->x = x0;
+  region->y = y0;
+  region->width = width;
+  region->height = height;
+  region->mask_data.resize((width * height + 7) / 8);
+  memset(region->mask_data.data(), 0, region->mask_data.size());
+
+  uint32_t mask_height = mask_image->image->get_height();
+  uint32_t mask_width = mask_image->image->get_width();
+  size_t stride;
+  uint8_t* p = heif_image_get_plane2(mask_image, heif_channel_Y, &stride);
+  uint64_t pixel_index = 0;
+
+  for (uint32_t y = 0; y < mask_height; y++) {
+    for (uint32_t x = 0; x < mask_width; x++) {
+      uint8_t mask_bit = p[y * stride + x] & 0x80; // use high-order bit of the 8-bit mask value as binary mask value
+      region->mask_data.data()[pixel_index / 8] |= uint8_t(mask_bit >> (pixel_index % 8));
+
+      pixel_index++;
+    }
+  }
+
+  item->region_item->add_region(region);
+
+  if (out_region) {
+    *out_region = create_region(region, item);
+  }
+
+  return heif_error_success;
+}
diff --git a/libheif/api/libheif/heif_regions.h b/libheif/api/libheif/heif_regions.h
new file mode 100644
index 0000000000..d9a3f61f73
--- /dev/null
+++ b/libheif/api/libheif/heif_regions.h
@@ -0,0 +1,868 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ * Copyright (c) 2023 Brad Hards <bradh@frogmouth.net>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_HEIF_REGIONS_H
+#define LIBHEIF_HEIF_REGIONS_H
+
+#include "heif_image_handle.h"
+#include "heif_library.h"
+#include "heif_error.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// --- region items and annotations
+
+// See ISO/IEC 23008-12:2022 Section 6.10 "Region items and region annotations"
+
+typedef struct heif_region_item heif_region_item;
+
+/**
+ * Region type.
+ *
+ * Each region item will contain zero or more regions, which may have different geometry or
+ * mask representations.
+*/
+typedef enum heif_region_type
+{
+  /**
+   * Point geometry.
+   *
+   * The region is represented by a single point.
+   */
+  heif_region_type_point = 0,
+
+  /**
+   * Rectangle geometry.
+   *
+   * The region is represented by a top left position, and a size defined
+   * by a width and height. All of the interior points and the edge are
+   * part of the region.
+   */
+  heif_region_type_rectangle = 1,
+
+  /**
+   * Ellipse geometry.
+   *
+   * The region is represented by a centre point, and radii in the X and
+   * Y directions. All of the interior points and the edge are part of the
+   * region.
+   */
+  heif_region_type_ellipse = 2,
+
+  /**
+   * Polygon geometry.
+   *
+   * The region is represented by a sequence of points, which is considered
+   * implicitly closed. All of the interior points and the edge are part
+   * of the region.
+   */
+  heif_region_type_polygon = 3,
+
+  /**
+   * Reference mask.
+   *
+   * The region geometry is described by the pixels in another image item,
+   * which has a item reference of type `mask` from the region item to the
+   * image item containing the mask.
+   *
+   * The image item containing the mask is one of:
+   *
+   * - a mask item (see ISO/IEC 23008-12:2022 Section 6.10.2), or a derived
+   * image from a mask item
+   *
+   * - an image item in monochrome format (4:0:0 chroma)
+   *
+   * - an image item in colour format with luma and chroma planes (e.g. 4:2:0)
+   *
+   * If the pixel value is equal to the minimum sample value (e.g. 0 for unsigned
+   * integer), the pixel is not part of the region. If the pixel value is equal
+   * to the maximum sample value (e.g. 255 for 8 bit unsigned integer), the pixel
+   * is part of the region. If the pixel value is between the minimum sample value
+   * and maximum sample value, the pixel value represents an (application defined)
+   * probability that the pixel is part of the region, where higher pixel values
+   * correspond to higher probability values.
+  */
+  heif_region_type_referenced_mask = 4,
+
+  /**
+   * Inline mask.
+   *
+   * The region geometry is described by a sequence of bits stored in inline
+   * in the region, one bit per pixel. If the bit value is `1`, the pixel is
+   * part of the region. If the bit value is `0`, the pixel is not part of the
+   * region.
+   */
+  heif_region_type_inline_mask = 5,
+
+  /**
+   * Polyline geometry.
+   *
+   * The region is represented by a sequence of points, which are not
+   * considered to form a closed surface. Only the edge is part of the region.
+  */
+  heif_region_type_polyline = 6
+} heif_region_type;
+
+typedef struct heif_region heif_region;
+
+/**
+ * Get the number of region items that are attached to an image.
+ *
+ * @param image_handle the image handle for the image to query.
+ * @return the number of region items, which can be zero.
+ */
+LIBHEIF_API
+int heif_image_handle_get_number_of_region_items(const heif_image_handle* image_handle);
+
+/**
+ * Get the region item identifiers for the region items attached to an image.
+ *
+ * Possible usage (in C++):
+ * @code
+ *  int numRegionItems = heif_image_handle_get_number_of_region_items(handle);
+ *  if (numRegionItems > 0) {
+ *      std::vector<heif_item_id> region_item_ids(numRegionItems);
+ *      heif_image_handle_get_list_of_region_item_ids(handle, region_item_ids.data(), numRegionItems);
+ *      // use region item ids
+ *  }
+ * @endcode
+ *
+ * @param image_handle the image handle for the parent image to query
+ * @param region_item_ids_array array to put the item identifiers into
+ * @param max_count the maximum number of region identifiers
+ * @return the number of region item identifiers that were returned.
+ */
+LIBHEIF_API
+int heif_image_handle_get_list_of_region_item_ids(const heif_image_handle* image_handle,
+                                                  heif_item_id* region_item_ids_array,
+                                                  int max_count);
+
+/**
+ * Get the region item.
+ *
+ * Caller is responsible for release of the output heif_region_item with heif_region_item_release().
+ *
+ * @param context the context to get the region item from, usually from a file operation
+ * @param region_item_id the identifier for the region item
+ * @param out pointer to pointer to the resulting region item
+ * @return heif_error_ok on success, or an error value indicating the problem
+ */
+LIBHEIF_API
+heif_error heif_context_get_region_item(const heif_context* context,
+                                        heif_item_id region_item_id,
+                                        heif_region_item** out);
+
+/**
+ * Get the item identifier for a region item.
+ *
+ * @param region_item the region item to query
+ * @return the region item identifier (or 0 if the region_item is null)
+ */
+LIBHEIF_API
+heif_item_id heif_region_item_get_id(heif_region_item* region_item);
+
+/**
+ * Release a region item.
+ *
+ * This should be called on items from heif_context_get_region_item().
+ *
+ * @param region_item the item to release.
+ */
+LIBHEIF_API
+void heif_region_item_release(heif_region_item* region_item);
+
+/**
+ * Get the reference size for a region item.
+ *
+ * The reference size specifies the coordinate space used for the region items.
+ * When the reference size does not match the image size, the regions need to be
+ * scaled to correspond.
+ *
+ * @param out_width the return value for the reference width (before any transformation)
+ * @param out_height the return value for the reference height (before any transformation)
+ */
+LIBHEIF_API
+void heif_region_item_get_reference_size(heif_region_item*, uint32_t* out_width, uint32_t* out_height);
+
+/**
+ * Get the number of regions within a region item.
+ *
+ * @param region_item the region item to query.
+ * @return the number of regions
+*/
+LIBHEIF_API
+int heif_region_item_get_number_of_regions(const heif_region_item* region_item);
+
+/**
+ * Get the regions that are part of a region item.
+ *
+ * Caller is responsible for releasing the returned `heif_region` objects, using heif_region_release()
+ * on each region, or heif_region_release_many() on the returned array.
+ *
+ * Possible usage (in C++):
+ * @code
+ *  int num_regions = heif_image_handle_get_number_of_regions(region_item);
+ *  if (num_regions > 0) {
+ *      std::vector<heif_region*> regions(num_regions);
+ *      int n = heif_region_item_get_list_of_regions(region_item, regions.data(), (int)regions.size());
+ *      // use regions
+ *      heif_region_release_many(regions.data(), n);
+ *  }
+ * @endcode
+ *
+ * @param region_item the region_item to query
+ * @param out_regions_array array to put the region pointers into
+ * @param max_count the maximum number of regions, which needs to correspond to the size of the out_regions_array
+ * @return the number of regions that were returned.
+ */
+LIBHEIF_API
+int heif_region_item_get_list_of_regions(const heif_region_item* region_item,
+                                         heif_region** out_regions_array,
+                                         int max_count);
+
+/**
+ * Release a region.
+ *
+ * This should be called on regions from heif_region_item_get_list_of_regions().
+ *
+ * @param region the region to release.
+ *
+ * \sa heif_region_release_many() to release the whole list
+ */
+LIBHEIF_API
+void heif_region_release(const heif_region* region);
+
+/**
+ * Release a list of regions.
+ *
+ * This should be called on the list of regions from heif_region_item_get_list_of_regions().
+ *
+ * @param regions_array the regions to release.
+ * @param num_items the number of items in the array
+ *
+ * \sa heif_region_release() to release a single region
+ */
+LIBHEIF_API
+void heif_region_release_many(const heif_region* const* regions_array, int num_items);
+
+/**
+ * Get the region type for a specified region. 
+ *
+ * @param region the region to query
+ * @return the corresponding region type as an enumeration value
+ */
+LIBHEIF_API
+enum heif_region_type heif_region_get_type(const heif_region* region);
+
+// When querying the region geometry, there is a version without and a version with "_transformed" suffix.
+// The version without returns the coordinates in the reference coordinate space.
+// The version with "_transformed" suffix give the coordinates in pixels after all transformative properties have been applied.
+
+/**
+ * Get the values for a point region.
+ *
+ * This returns the coordinates in the reference coordinate space (from the parent region item).
+ *
+ * @param region the region to query, which must be of type #heif_region_type_point.
+ * @param out_x the X coordinate, where 0 is the left-most column.
+ * @param out_y the Y coordinate, where 0 is the top-most row.
+ * @return heif_error_ok on success, or an error value indicating the problem on failure
+ *
+ * \sa heif_region_get_point_transformed() for a version in pixels after all transformative properties have been applied.
+ */
+LIBHEIF_API
+heif_error heif_region_get_point(const heif_region* region, int32_t* out_x, int32_t* out_y);
+
+/**
+ * Get the transformed values for a point region.
+ *
+ * This returns the coordinates in pixels after all transformative properties have been applied.
+ *
+ * @param region the region to query, which must be of type #heif_region_type_point.
+ * @param image_id the identifier for the image to transform / scale the region to
+ * @param out_x the X coordinate, where 0 is the left-most column.
+ * @param out_y the Y coordinate, where 0 is the top-most row.
+ * @return heif_error_ok on success, or an error value indicating the problem on failure
+ *
+ * \sa heif_region_get_point() for a version that returns the values in the reference coordinate space.
+ */
+LIBHEIF_API
+heif_error heif_region_get_point_transformed(const heif_region* region, heif_item_id image_id, double* out_x, double* out_y);
+
+/**
+ * Get the values for a rectangle region.
+ *
+ * This returns the values in the reference coordinate space (from the parent region item).
+ * The rectangle is represented by a top left corner position, and a size defined
+ * by a width and height. All of the interior points and the edge are
+ * part of the region.
+ *
+ * @param region the region to query, which must be of type #heif_region_type_rectangle.
+ * @param out_x the X coordinate for the top left corner, where 0 is the left-most column.
+ * @param out_y the Y coordinate for the top left corner, where 0 is the top-most row.
+ * @param out_width the width of the rectangle
+ * @param out_height the height of the rectangle
+ * @return heif_error_ok on success, or an error value indicating the problem on failure
+ *
+ * \sa heif_region_get_rectangle_transformed() for a version in pixels after all transformative properties have been applied.
+ */
+LIBHEIF_API
+heif_error heif_region_get_rectangle(const heif_region* region,
+                                     int32_t* out_x, int32_t* out_y,
+                                     uint32_t* out_width, uint32_t* out_height);
+
+/**
+ * Get the transformed values for a rectangle region.
+ *
+ * This returns the coordinates in pixels after all transformative properties have been applied.
+ * The rectangle is represented by a top left corner position, and a size defined
+ * by a width and height. All of the interior points and the edge are
+ * part of the region.
+ *
+ * @param region the region to query, which must be of type #heif_region_type_rectangle.
+ * @param image_id the identifier for the image to transform / scale the region to
+ * @param out_x the X coordinate for the top left corner, where 0 is the left-most column.
+ * @param out_y the Y coordinate for the top left corner, where 0 is the top-most row.
+ * @param out_width the width of the rectangle
+ * @param out_height the height of the rectangle
+ * @return heif_error_ok on success, or an error value indicating the problem on failure
+ *
+ * \sa heif_region_get_rectangle() for a version that returns the values in the reference coordinate space.
+ */
+LIBHEIF_API
+heif_error heif_region_get_rectangle_transformed(const heif_region* region,
+                                                 heif_item_id image_id,
+                                                 double* out_x, double* out_y,
+                                                 double* out_width, double* out_height);
+
+/**
+ * Get the values for an ellipse region.
+ *
+ * This returns the values in the reference coordinate space (from the parent region item).
+ * The ellipse is represented by a centre position, and a size defined
+ * by radii in the X and Y directions. All of the interior points and the edge are
+ * part of the region.
+ *
+ * @param region the region to query, which must be of type #heif_region_type_ellipse.
+ * @param out_x the X coordinate for the centre point, where 0 is the left-most column.
+ * @param out_y the Y coordinate for the centre point, where 0 is the top-most row.
+ * @param out_radius_x the radius value in the X direction.
+ * @param out_radius_y the radius value in the Y direction
+ * @return heif_error_ok on success, or an error value indicating the problem on failure
+ *
+ * \sa heif_region_get_ellipse_transformed() for a version in pixels after all transformative properties have been applied.
+ */
+LIBHEIF_API
+heif_error heif_region_get_ellipse(const heif_region* region,
+                                   int32_t* out_x, int32_t* out_y,
+                                   uint32_t* out_radius_x, uint32_t* out_radius_y);
+
+
+/**
+ * Get the transformed values for an ellipse region.
+ *
+ * This returns the coordinates in pixels after all transformative properties have been applied.
+ * The ellipse is represented by a centre position, and a size defined
+ * by radii in the X and Y directions. All of the interior points and the edge are
+ * part of the region.
+ *
+ * @param region the region to query, which must be of type #heif_region_type_ellipse.
+ * @param image_id the identifier for the image to transform / scale the region to
+ * @param out_x the X coordinate for the centre point, where 0 is the left-most column.
+ * @param out_y the Y coordinate for the centre point, where 0 is the top-most row.
+ * @param out_radius_x the radius value in the X direction.
+ * @param out_radius_y the radius value in the Y direction
+ * @return heif_error_ok on success, or an error value indicating the problem on failure
+ *
+ * \sa heif_region_get_ellipse() for a version that returns the values in the reference coordinate space.
+ */
+LIBHEIF_API
+heif_error heif_region_get_ellipse_transformed(const heif_region* region,
+                                               heif_item_id image_id,
+                                               double* out_x, double* out_y,
+                                               double* out_radius_x, double* out_radius_y);
+
+/**
+ * Get the number of points in a polygon.
+ *
+ * @param region the region to query, which must be of type #heif_region_type_polygon
+ * @return the number of points, or -1 on error.
+ */
+LIBHEIF_API
+int heif_region_get_polygon_num_points(const heif_region* region);
+
+/**
+ * Get the points in a polygon region.
+ *
+ * This returns the values in the reference coordinate space (from the parent region item).
+ *
+ * A polygon is a sequence of points that form a closed shape. The first point does
+ * not need to be repeated as the last point. All of the interior points and the edge are
+ * part of the region.
+ * The points are returned as pairs of X,Y coordinates, in the order X<sub>1</sub>,
+ * Y<sub>1</sub>, X<sub>2</sub>, Y<sub>2</sub>, ..., X<sub>n</sub>, Y<sub>n</sub>.
+ *
+ * @param region the region to query, which must be of type #heif_region_type_polygon
+ * @param out_pts_array the array to return the points in, which must have twice as many entries as there are points
+ * in the polygon.
+ * @return heif_error_ok on success, or an error value indicating the problem on failure
+ *
+ * \sa heif_region_get_polygon_points_transformed() for a version in pixels after all transformative properties have been applied.
+ */
+LIBHEIF_API
+heif_error heif_region_get_polygon_points(const heif_region* region,
+                                          int32_t* out_pts_array);
+
+/**
+ * Get the transformed points in a polygon region.
+ *
+ * This returns the coordinates in pixels after all transformative properties have been applied.
+ *
+ * A polygon is a sequence of points that form a closed shape. The first point does
+ * not need to be repeated as the last point. All of the interior points and the edge are
+ * part of the region.
+ * The points are returned as pairs of X,Y coordinates, in the order X<sub>1</sub>,
+ * Y<sub>1</sub>, X<sub>2</sub>, Y<sub>2</sub>, ..., X<sub>n</sub>, Y<sub>n</sub>.
+ *
+ * @param region the region to query, which must be of type #heif_region_type_polygon
+ * @param image_id the identifier for the image to transform / scale the region to
+ * @param out_pts_array the array to return the points in, which must have twice as many entries as there are points
+ * in the polygon.
+ * @return heif_error_ok on success, or an error value indicating the problem on failure
+ *
+ * \sa heif_region_get_polygon_points() for a version that returns the values in the reference coordinate space.
+ */
+LIBHEIF_API
+heif_error heif_region_get_polygon_points_transformed(const heif_region* region,
+                                                      heif_item_id image_id,
+                                                      double* out_pts_array);
+/**
+ * Get the number of points in a polyline.
+ *
+ * @param region the region to query, which must be of type #heif_region_type_polyline
+ * @return the number of points, or -1 on error.
+ */
+LIBHEIF_API
+int heif_region_get_polyline_num_points(const heif_region* region);
+
+/**
+ * Get the points in a polyline region.
+ *
+ * This returns the values in the reference coordinate space (from the parent region item).
+ *
+ * A polyline is a sequence of points that does not form a closed shape. Even if the
+ * polyline is closed, the only points that are part of the region are those that 
+ * intersect (even minimally) a one-pixel line drawn along the polyline.
+ * The points are provided as pairs of X,Y coordinates, in the order X<sub>1</sub>,
+ * Y<sub>1</sub>, X<sub>2</sub>, Y<sub>2</sub>, ..., X<sub>n</sub>, Y<sub>n</sub>.
+ *
+ * Possible usage (in C++):
+ * @code
+ * int num_polyline_points = heif_region_get_polyline_num_points(region);
+ * if (num_polyline_points > 0) {
+ *     std::vector<int32_t> polyline(num_polyline_points * 2);
+ *     heif_region_get_polyline_points(region, polyline.data());
+ *     // do something with points ...
+ * }
+ * @endcode
+ *
+ * @param region the region to query, which must be of type #heif_region_type_polyline
+ * @param out_pts_array the array to return the points in, which must have twice as many entries as there are points
+ * in the polyline.
+ * @return heif_error_ok on success, or an error value indicating the problem on failure
+ *
+ * \sa heif_region_get_polyline_points_transformed() for a version in pixels after all transformative properties have been applied.
+ */
+LIBHEIF_API
+heif_error heif_region_get_polyline_points(const heif_region* region,
+                                           int32_t* out_pts_array);
+
+/**
+ * Get the transformed points in a polyline region.
+ *
+ * This returns the coordinates in pixels after all transformative properties have been applied.
+ *
+ * A polyline is a sequence of points that does not form a closed shape. Even if the
+ * polyline is closed, the only points that are part of the region are those that 
+ * intersect (even minimally) a one-pixel line drawn along the polyline.
+ * The points are provided as pairs of X,Y coordinates, in the order X<sub>1</sub>,
+ * Y<sub>1</sub>, X<sub>2</sub>, Y<sub>2</sub>, ..., X<sub>n</sub>, Y<sub>n</sub>.
+ *
+ * @param region the region to query, which must be of type #heif_region_type_polyline
+ * @param image_id the identifier for the image to transform / scale the region to
+ * @param out_pts_array the array to return the points in, which must have twice as many entries as there are points
+ * in the polyline.
+ * @return heif_error_ok on success, or an error value indicating the problem on failure
+ *
+ * \sa heif_region_get_polyline_points() for a version that returns the values in the reference coordinate space.
+ */
+LIBHEIF_API
+heif_error heif_region_get_polyline_points_transformed(const heif_region* region,
+                                                       heif_item_id image_id,
+                                                       double* out_pts_array);
+
+/**
+ * Get a referenced item mask region.
+ *
+ * This returns the values in the reference coordinate space (from the parent region item).
+ * The mask location is represented by a top left corner position, and a size defined
+ * by a width and height. The value of each sample in that mask identifies whether the
+ * corresponding pixel is part of the region.
+ *
+ * The mask is provided as an image in another item. The image item containing the mask
+ * is one of:
+ *
+ * - a mask item (see ISO/IEC 23008-12:2022 Section 6.10.2), or a derived
+ * image from a mask item
+ *
+ * - an image item in monochrome format (4:0:0 chroma)
+ *
+ * - an image item in colour format with luma and chroma planes (e.g. 4:2:0)
+ *
+ * If the pixel value is equal to the minimum sample value (e.g. 0 for unsigned
+ * integer), the pixel is not part of the region. If the pixel value is equal
+ * to the maximum sample value (e.g. 255 for 8 bit unsigned integer), the pixel
+ * is part of the region. If the pixel value is between the minimum sample value
+ * and maximum sample value, the pixel value represents an (application defined)
+ * probability that the pixel is part of the region, where higher pixel values
+ * correspond to higher probability values.
+ *
+ * @param region the region to query, which must be of type #heif_region_type_referenced_mask.
+ * @param out_x the X coordinate for the top left corner, where 0 is the left-most column.
+ * @param out_y the Y coordinate for the top left corner, where 0 is the top-most row.
+ * @param out_width the width of the mask region
+ * @param out_height the height of the mask region
+ * @param out_mask_item_id the item identifier for the image that provides the mask.
+ * @return heif_error_ok on success, or an error value indicating the problem on failure
+ */
+LIBHEIF_API
+heif_error heif_region_get_referenced_mask_ID(const heif_region* region,
+                                              int32_t* out_x, int32_t* out_y,
+                                              uint32_t* out_width, uint32_t* out_height,
+                                              heif_item_id* out_mask_item_id);
+
+/**
+ * Get the length of the data in an inline mask region.
+ *
+ * @param region the region to query, which must be of type #heif_region_type_inline_mask.
+ * @return the number of bytes in the mask data, or 0 on error.
+ */
+LIBHEIF_API
+size_t heif_region_get_inline_mask_data_len(const heif_region* region);
+
+
+/**
+ * Get data for an inline mask region.
+ *
+ * This returns the values in the reference coordinate space (from the parent region item).
+ * The mask location is represented by a top left corner position, and a size defined
+ * by a width and height.
+ *
+ * The mask is held as inline data on the region, one bit per pixel, most significant
+ * bit first pixel, no padding. If the bit value is `1`, the corresponding pixel is
+ * part of the region. If the bit value is `0`, the corresponding pixel is not part of the
+ * region.
+ *
+ * Possible usage (in C++):
+ * @code
+ * long unsigned int data_len = heif_region_get_inline_mask_data_len(region);
+ * int32_t x, y;
+ * uint32_t width, height;
+ * std::vector<uint8_t> mask_data(data_len);
+ * err = heif_region_get_inline_mask(region, &x, &y, &width, &height, mask_data.data());
+ * @endcode
+ *
+ * @param region the region to query, which must be of type #heif_region_type_inline_mask.
+ * @param out_x the X coordinate for the top left corner, where 0 is the left-most column.
+ * @param out_y the Y coordinate for the top left corner, where 0 is the top-most row.
+ * @param out_width the width of the mask region
+ * @param out_height the height of the mask region
+ * @param out_mask_data the location to return the mask data
+ * @return heif_error_ok on success, or an error value indicating the problem on failure
+ */
+LIBHEIF_API
+heif_error heif_region_get_inline_mask_data(const heif_region* region,
+                                            int32_t* out_x, int32_t* out_y,
+                                            uint32_t* out_width, uint32_t* out_height,
+                                            uint8_t* out_mask_data);
+
+/**
+ * Get a mask region image.
+ *
+ * This returns the values in the reference coordinate space (from the parent region item).
+ * The mask location is represented by a top left corner position, and a size defined
+ * by a width and height.
+ *
+ * This function works when the passed region is either a heif_region_type_referenced_mask or
+ * a heif_region_type_inline_mask.
+ * The returned image is a monochrome image where each pixel represents the (scaled) probability
+ * of the pixel being part of the mask.
+ *
+ * If the region type is an inline mask, which always holds a binary mask, this function
+ * converts the binary inline mask to an 8-bit monochrome image with the values '0' and '255'.
+ * The pixel value is set to `255` where the pixel is part of the region, and `0` where the
+ * pixel is not part of the region.
+ *
+ * @param region the region to query, which must be of type #heif_region_type_inline_mask.
+ * @param out_x the X coordinate for the top left corner, where 0 is the left-most column.
+ * @param out_y the Y coordinate for the top left corner, where 0 is the top-most row.
+ * @param out_width the width of the mask region
+ * @param out_height the height of the mask region
+ * @param out_mask_image the returned mask image
+ * @return heif_error_ok on success, or an error value indicating the problem on failure
+ *
+ * \note the caller is responsible for releasing the mask image
+ */
+LIBHEIF_API
+heif_error heif_region_get_mask_image(const heif_region* region,
+                                      int32_t* out_x, int32_t* out_y,
+                                      uint32_t* out_width, uint32_t* out_height,
+                                      heif_image** out_mask_image);
+
+// --- adding region items
+
+/**
+ * Add a region item to an image.
+ *
+ * The region item is a collection of regions (point, polyline, polygon, rectangle, ellipse or mask)
+ * along with a reference size (width and height) that forms the coordinate basis for the regions.
+ *
+ * The concept is to add the region item, then add one or more regions to the region item.
+ *
+ * @param image_handle the image to attach the region item to.
+ * @param reference_width the width of the reference size.
+ * @param reference_height the height of the reference size.
+ * @param out_region_item the resulting region item
+ * @return heif_error_ok on success, or an error indicating the problem on failure
+*/
+LIBHEIF_API
+heif_error heif_image_handle_add_region_item(heif_image_handle* image_handle,
+                                             uint32_t reference_width, uint32_t reference_height,
+                                             heif_region_item** out_region_item);
+
+/**
+ * Add a point region to the region item.
+ *
+ * @param region_item the region item that holds this point region
+ * @param x the x value for the point location
+ * @param y the y value for the point location
+ * @param out_region pointer to pointer to the returned region (optional, see below)
+ * @return heif_error_ok on success, or an error indicating the problem on failure
+ *
+ * @note The `out_region` parameter is optional, and can be set to `NULL` if not needed.
+ */
+LIBHEIF_API
+heif_error heif_region_item_add_region_point(heif_region_item* region_item,
+                                             int32_t x, int32_t y,
+                                             heif_region** out_region);
+
+/**
+ * Add a rectangle region to the region item.
+ *
+ * @param region_item the region item that holds this rectangle region
+ * @param x the x value for the top-left corner of this rectangle region
+ * @param y the y value for the top-left corner of this rectangle region
+ * @param width the width of this rectangle region
+ * @param height the height of this rectangle region
+ * @param out_region pointer to pointer to the returned region (optional, see below)
+ * @return heif_error_ok on success, or an error indicating the problem on failure
+ *
+ * @note The `out_region` parameter is optional, and can be set to `NULL` if not needed.
+ */
+LIBHEIF_API
+heif_error heif_region_item_add_region_rectangle(heif_region_item* region_item,
+                                                 int32_t x, int32_t y,
+                                                 uint32_t width, uint32_t height,
+                                                 heif_region** out_region);
+
+/**
+ * Add a ellipse region to the region item.
+ *
+ * @param region_item the region item that holds this ellipse region
+ * @param x the x value for the centre of this ellipse region
+ * @param y the y value for the centre of this ellipse region
+ * @param radius_x the radius of the ellipse in the X (horizontal) direction
+ * @param radius_y the radius of the ellipse in the Y (vertical) direction
+ * @param out_region pointer to pointer to the returned region (optional, see below)
+ * @return heif_error_ok on success, or an error indicating the problem on failure
+ *
+ * @note The `out_region` parameter is optional, and can be set to `NULL` if not needed.
+ */
+LIBHEIF_API
+heif_error heif_region_item_add_region_ellipse(heif_region_item* region_item,
+                                               int32_t x, int32_t y,
+                                               uint32_t radius_x, uint32_t radius_y,
+                                               heif_region** out_region);
+
+/**
+ * Add a polygon region to the region item.
+ *
+ * A polygon is a sequence of points that form a closed shape. The first point does
+ * not need to be repeated as the last point.
+ * The points are provided as pairs of X,Y coordinates, in the order X<sub>1</sub>,
+ * Y<sub>1</sub>, X<sub>2</sub>, Y<sub>2</sub>, ..., X<sub>n</sub>, Y<sub>n</sub>.
+ *
+ * @param region_item the region item that holds this polygon region
+ * @param pts_array the array of points in X,Y order (see above)
+ * @param nPoints the number of points
+ * @param out_region pointer to pointer to the returned region (optional, see below)
+ * @return heif_error_ok on success, or an error indicating the problem on failure
+ *
+ * @note `nPoints` is the number of points, not the number of elements in the array
+ * @note The `out_region` parameter is optional, and can be set to `NULL` if not needed.
+ */
+LIBHEIF_API
+heif_error heif_region_item_add_region_polygon(heif_region_item* region_item,
+                                               const int32_t* pts_array, int nPoints,
+                                               heif_region** out_region);
+
+/**
+ * Add a polyline region to the region item.
+ *
+ * A polyline is a sequence of points that does not form a closed shape. Even if the
+ * polyline is closed, the only points that are part of the region are those that
+ * intersect (even minimally) a one-pixel line drawn along the polyline.
+ * The points are provided as pairs of X,Y coordinates, in the order X<sub>1</sub>,
+ * Y<sub>1</sub>, X<sub>2</sub>, Y<sub>2</sub>, ..., X<sub>n</sub>, Y<sub>n</sub>.
+ *
+ * @param region_item the region item that holds this polyline region
+ * @param pts_array the array of points in X,Y order (see above)
+ * @param nPoints the number of points
+ * @param out_region pointer to pointer to the returned region (optional, see below)
+ * @return heif_error_ok on success, or an error indicating the problem on failure
+ *
+ * @note `nPoints` is the number of points, not the number of elements in the array
+ * @note The `out_region` parameter is optional, and can be set to `NULL` if not needed.
+ */
+LIBHEIF_API
+heif_error heif_region_item_add_region_polyline(heif_region_item* region_item,
+                                                const int32_t* pts_array, int nPoints,
+                                                heif_region** out_region);
+
+
+/**
+ * Add a referenced mask region to the region item.
+ *
+ * The region geometry is described by the pixels in another image item,
+ * which has a item reference of type `mask` from the region item to the
+ * image item containing the mask.
+ *
+ * The image item containing the mask is one of:
+ *
+ * - a mask item (see ISO/IEC 23008-12:2022 Section 6.10.2), or a derived
+ * image from a mask item
+ *
+ * - an image item in monochrome format (4:0:0 chroma)
+ *
+ * - an image item in colour format with luma and chroma planes (e.g. 4:2:0)
+ *
+ * If the pixel value is equal to the minimum sample value (e.g. 0 for unsigned
+ * integer), the pixel is not part of the region. If the pixel value is equal
+ * to the maximum sample value (e.g. 255 for 8 bit unsigned integer), the pixel
+ * is part of the region. If the pixel value is between the minimum sample value
+ * and maximum sample value, the pixel value represents an (application defined)
+ * probability that the pixel is part of the region, where higher pixel values
+ * correspond to higher probability values.
+ *
+ * @param region_item the region item that holds this mask region
+ * @param x the x value for the top-left corner of this mask region
+ * @param y the y value for the top-left corner of this mask region
+ * @param width the width of this mask region
+ * @param height the height of this mask region
+ * @param mask_item_id the item identifier for the mask that is referenced
+ * @param out_region pointer to pointer to the returned region (optional, see below)
+ * @return heif_error_ok on success, or an error indicating the problem on failure
+ *
+ * @note The `out_region` parameter is optional, and can be set to `NULL` if not needed.
+ */
+LIBHEIF_API
+heif_error heif_region_item_add_region_referenced_mask(heif_region_item* region_item,
+                                                       int32_t x, int32_t y,
+                                                       uint32_t width, uint32_t height,
+                                                       heif_item_id mask_item_id,
+                                                       heif_region** out_region);
+
+
+/**
+ * Add an inline mask region to the region item.
+ *
+ * The region geometry is described by a top left corner position, and a size defined
+ * by a width and height.
+ *
+ * The mask is held as inline data on the region, one bit per pixel, most significant
+ * bit first pixel, no padding. If the bit value is `1`, the corresponding pixel is
+ * part of the region. If the bit value is `0`, the corresponding pixel is not part of the
+ * region.
+ *
+ * @param region_item the region item that holds this mask region
+ * @param x the x value for the top-left corner of this mask region
+ * @param y the y value for the top-left corner of this mask region
+ * @param width the width of this mask region
+ * @param height the height of this mask region
+ * @param mask_data the location to return the mask data
+ * @param mask_data_len the length of the mask data, in bytes
+ * @param out_region pointer to pointer to the returned region (optional, see below)
+ * @return heif_error_ok on success, or an error value indicating the problem on failure
+ */
+LIBHEIF_API
+heif_error heif_region_item_add_region_inline_mask_data(heif_region_item* region_item,
+                                                        int32_t x, int32_t y,
+                                                        uint32_t width, uint32_t height,
+                                                        const uint8_t* mask_data,
+                                                        size_t mask_data_len,
+                                                        heif_region** out_region);
+
+/**
+ * Add an inline mask region image to the region item.
+ *
+ * The region geometry is described by a top left corner position, and a size defined
+ * by a width and height.
+ *
+ * The mask data is held as inline data on the region, one bit per pixel. The provided
+ * image is converted to inline data, where any pixel with a value >= 0x80 becomes part of the
+ * mask region. If the image width is less that the specified width, it is expanded
+ * to match the width of the region (zero fill on the right). If the image height is
+ * less than the specified height, it is expanded to match the height of the region
+ * (zero fill on the bottom). If the image width or height is greater than the
+ * width or height (correspondingly) of the region, the image is cropped.
+ *
+ * @param region_item the region item that holds this mask region
+ * @param x the x value for the top-left corner of this mask region
+ * @param y the y value for the top-left corner of this mask region
+ * @param width the width of this mask region
+ * @param height the height of this mask region
+ * @param image the image to convert to an inline mask
+ * @param out_region pointer to pointer to the returned region (optional, see below)
+ * @return heif_error_ok on success, or an error value indicating the problem on failure
+ */
+LIBHEIF_API
+heif_error heif_region_item_add_region_inline_mask(heif_region_item* region_item,
+                                                   int32_t x, int32_t y,
+                                                   uint32_t width, uint32_t height,
+                                                   heif_image* image,
+                                                   heif_region** out_region);
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/libheif/api/libheif/heif_security.cc b/libheif/api/libheif/heif_security.cc
new file mode 100644
index 0000000000..05afa8a5b4
--- /dev/null
+++ b/libheif/api/libheif/heif_security.cc
@@ -0,0 +1,67 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017-2025 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "heif_security.h"
+#include "api_structs.h"
+
+#include "context.h"
+
+
+
+const heif_security_limits* heif_get_global_security_limits()
+{
+  return &global_security_limits;
+}
+
+
+const heif_security_limits* heif_get_disabled_security_limits()
+{
+  return &disabled_security_limits;
+}
+
+
+heif_security_limits* heif_context_get_security_limits(const heif_context* ctx)
+{
+  if (!ctx) {
+    return nullptr;
+  }
+
+  return ctx->context->get_security_limits();
+}
+
+
+heif_error heif_context_set_security_limits(heif_context* ctx, const heif_security_limits* limits)
+{
+  if (ctx==nullptr || limits==nullptr) {
+    return heif_error_null_pointer_argument;
+  }
+
+  ctx->context->set_security_limits(limits);
+
+  return heif_error_ok;
+}
+
+
+// DEPRECATED
+
+void heif_context_set_maximum_image_size_limit(heif_context* ctx, int maximum_width)
+{
+  ctx->context->get_security_limits()->max_image_size_pixels = static_cast<uint64_t>(maximum_width) * maximum_width;
+}
diff --git a/libheif/api/libheif/heif_security.h b/libheif/api/libheif/heif_security.h
new file mode 100644
index 0000000000..f63f86c361
--- /dev/null
+++ b/libheif/api/libheif/heif_security.h
@@ -0,0 +1,112 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017-2025 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_HEIF_SECURITY_H
+#define LIBHEIF_HEIF_SECURITY_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <libheif/heif_library.h>
+
+
+// --- security limits
+
+// If you set a limit to 0, the limit is disabled.
+typedef struct heif_security_limits
+{
+  uint8_t version;
+
+  // --- version 1
+
+  // Limit on the maximum image size to avoid allocating too much memory.
+  // For example, setting this to 32768^2 pixels = 1 Gigapixels results
+  // in 1.5 GB memory need for YUV-4:2:0 or 4 GB for RGB32.
+  uint64_t max_image_size_pixels;
+  uint64_t max_number_of_tiles;
+  // Also used for polarization pattern (splz) size limit.
+  uint32_t max_bayer_pattern_pixels;
+  uint32_t max_items;
+
+  uint32_t max_color_profile_size;
+  uint64_t max_memory_block_size;
+
+  uint32_t max_components;
+
+  uint32_t max_iloc_extents_per_item;
+  uint32_t max_size_entity_group;
+
+  uint32_t max_children_per_box; // for all boxes that are not covered by other limits
+
+  // --- version 2
+
+  uint64_t max_total_memory;
+  uint32_t max_sample_description_box_entries;
+  uint32_t max_sample_group_description_box_entries;
+
+  // --- version 3
+
+  uint32_t max_sequence_frames;
+  uint32_t max_number_of_file_brands;
+
+  // --- version 4
+
+  uint32_t max_bad_pixels;
+} heif_security_limits;
+
+
+// The global security limits are the default for new heif_contexts.
+// These global limits cannot be changed, but you can override the limits for a specific heif_context.
+LIBHEIF_API
+const heif_security_limits* heif_get_global_security_limits(void);
+
+// Returns a set of fully disabled security limits. Use with care and only after user confirmation.
+LIBHEIF_API
+const heif_security_limits* heif_get_disabled_security_limits(void);
+
+// Returns the security limits for a heif_context.
+// By default, the limits are set to the global limits, but you can change them in the returned object.
+LIBHEIF_API
+heif_security_limits* heif_context_get_security_limits(const heif_context*);
+
+// Overwrites the security limits of a heif_context.
+// This is a convenience function to easily copy limits.
+LIBHEIF_API
+heif_error heif_context_set_security_limits(heif_context*, const heif_security_limits*);
+
+
+// --- DEPRECATED ---
+
+// Set the maximum image size security limit. This function will set the maximum image area (number of pixels)
+// to maximum_width ^ 2. Alternatively to using this function, you can also set the maximum image area
+// in the security limits structure returned by heif_context_get_security_limits().
+LIBHEIF_API
+void heif_context_set_maximum_image_size_limit(heif_context* ctx, int maximum_width);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/libheif/api/libheif/heif_sequences.cc b/libheif/api/libheif/heif_sequences.cc
new file mode 100644
index 0000000000..eb16d291e1
--- /dev/null
+++ b/libheif/api/libheif/heif_sequences.cc
@@ -0,0 +1,837 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "heif_sequences.h"
+#include "context.h"
+#include "api_structs.h"
+#include "file.h"
+#include "sequences/track.h"
+#include "sequences/track_visual.h"
+#include "sequences/track_metadata.h"
+
+#include <array>
+#include <cstring>
+#include <memory>
+#include <vector>
+#include <string>
+#include <utility>
+
+
+int heif_context_has_sequence(const heif_context* ctx)
+{
+  return ctx->context->has_sequence();
+}
+
+
+uint32_t heif_context_get_sequence_timescale(const heif_context* ctx)
+{
+  return ctx->context->get_sequence_timescale();
+}
+
+
+uint64_t heif_context_get_sequence_duration(const heif_context* ctx)
+{
+  return ctx->context->get_sequence_duration();
+}
+
+
+void heif_track_release(heif_track* track)
+{
+  delete track;
+}
+
+
+int heif_context_number_of_sequence_tracks(const heif_context* ctx)
+{
+  return ctx->context->get_number_of_tracks();
+}
+
+
+void heif_context_get_track_ids(const heif_context* ctx, uint32_t out_track_id_array[])
+{
+  std::vector<uint32_t> IDs;
+  IDs = ctx->context->get_track_IDs();
+
+  for (uint32_t id : IDs) {
+    *out_track_id_array++ = id;
+  }
+}
+
+
+uint32_t heif_track_get_id(const heif_track* track)
+{
+  return track->track->get_id();
+}
+
+
+// Use id=0 for the first visual track.
+heif_track* heif_context_get_track(const heif_context* ctx, uint32_t track_id)
+{
+  auto trackResult = ctx->context->get_track(track_id);
+  if (!trackResult) {
+    return nullptr;
+  }
+
+  auto* track = new heif_track;
+  track->track = *trackResult;
+  track->context = ctx->context;
+
+  return track;
+}
+
+
+uint32_t heif_track_get_track_handler_type(const heif_track* track)
+{
+  return track->track->get_handler();
+}
+
+heif_auxiliary_track_info_type heif_track_get_auxiliary_info_type(const heif_track* track)
+{
+  return track->track->get_auxiliary_info_type();
+}
+
+const char* heif_track_get_auxiliary_info_type_urn(const heif_track* track)
+{
+  std::string type = track->track->get_auxiliary_info_type_urn();
+
+  if (type.empty()) {
+    return nullptr;
+  }
+  else {
+    char* type_c = new char[type.length() + 1];
+    strcpy(type_c, type.c_str());
+    return type_c;
+  }
+}
+
+
+int heif_track_has_alpha_channel(const heif_track* track)
+{
+  return track->track->has_alpha_channel();
+}
+
+
+uint32_t heif_track_get_timescale(const heif_track* track)
+{
+  return track->track->get_timescale();
+}
+
+
+heif_error heif_track_get_image_resolution(const heif_track* track_ptr, uint16_t* out_width, uint16_t* out_height)
+{
+  auto track = track_ptr->track;
+
+  auto visual_track = std::dynamic_pointer_cast<Track_Visual>(track);
+  if (!visual_track) {
+    return {
+      heif_error_Usage_error,
+      heif_suberror_Invalid_parameter_value,
+      "Cannot get resolution of non-visual track."
+    };
+  }
+
+  if (out_width) *out_width = visual_track->get_width();
+  if (out_height) *out_height = visual_track->get_height();
+
+  return heif_error_ok;
+}
+
+
+heif_error heif_track_decode_next_image(heif_track* track_ptr,
+                                        heif_image** out_img,
+                                        heif_colorspace colorspace,
+                                        heif_chroma chroma,
+                                        const heif_decoding_options* options)
+{
+  if (out_img == nullptr) {
+    return heif_error_null_pointer_argument;
+  }
+
+  // --- get the visual track
+
+  auto track = track_ptr->track;
+
+  // --- reached end of sequence ?
+
+  if (track->end_of_sequence_reached()) {
+    *out_img = nullptr;
+    return {heif_error_End_of_sequence, heif_suberror_Unspecified, "End of sequence"};
+  }
+
+  // --- decode next sequence image
+
+  std::unique_ptr<heif_decoding_options, void(*)(heif_decoding_options*)> opts(heif_decoding_options_alloc(), heif_decoding_options_free);
+  heif_decoding_options_copy(opts.get(), options);
+
+
+  auto visual_track = std::dynamic_pointer_cast<Track_Visual>(track);
+  if (!visual_track) {
+    return {
+      heif_error_Usage_error,
+      heif_suberror_Invalid_parameter_value,
+      "Cannot get image from non-visual track."
+    };
+  }
+
+  auto decodingResult = visual_track->decode_next_image_sample(*opts);
+  if (!decodingResult) {
+    return decodingResult.error_struct(track_ptr->context.get());
+  }
+
+  std::shared_ptr<HeifPixelImage> img = *decodingResult;
+
+
+  // --- convert to output colorspace
+
+  auto conversion_result = track_ptr->context->convert_to_output_colorspace(img, colorspace, chroma, *opts);
+  if (!conversion_result) {
+    return conversion_result.error_struct(track_ptr->context.get());
+  }
+  else {
+    img = *conversion_result;
+  }
+
+  *out_img = new heif_image();
+  (*out_img)->image = std::move(img);
+
+  return {};
+}
+
+
+uint32_t heif_image_get_duration(const heif_image* img)
+{
+  return img->image->get_sample_duration();
+}
+
+
+uint32_t heif_track_get_sample_entry_type_of_first_cluster(const heif_track* track)
+{
+  return track->track->get_first_cluster_sample_entry_type();
+}
+
+
+heif_error heif_track_get_urim_sample_entry_uri_of_first_cluster(const heif_track* track, const char** out_uri)
+{
+  Result<std::string> uriResult = track->track->get_first_cluster_urim_uri();
+
+  if (!uriResult) {
+    return uriResult.error_struct(track->context.get());
+  }
+
+  if (out_uri) {
+    const std::string uri = std::move(*uriResult);
+
+    char* s = new char[uri.size() + 1];
+    strncpy(s, uri.c_str(), uri.size());
+    s[uri.size()] = '\0';
+
+    *out_uri = s;
+  }
+
+  return heif_error_ok;
+}
+
+
+heif_error heif_track_get_next_raw_sequence_sample(heif_track* track_ptr,
+                                                   heif_raw_sequence_sample** out_sample)
+{
+  auto track = track_ptr->track;
+
+  // --- reached end of sequence ?
+
+  if (track->end_of_sequence_reached()) {
+    return {heif_error_End_of_sequence, heif_suberror_Unspecified, "End of sequence"};
+  }
+
+  // --- get next raw sample
+
+  // TODO: pass decoding options. We currently have no way to ignore the edit-list.
+  auto decodingResult = track->get_next_sample_raw_data(nullptr);
+  if (!decodingResult) {
+    return decodingResult.error_struct(track_ptr->context.get());
+  }
+
+  *out_sample = *decodingResult;
+
+  return heif_error_success;
+}
+
+
+void heif_raw_sequence_sample_release(heif_raw_sequence_sample* sample)
+{
+  delete sample;
+}
+
+
+const uint8_t* heif_raw_sequence_sample_get_data(const heif_raw_sequence_sample* sample, size_t* out_array_size)
+{
+  if (out_array_size) { *out_array_size = sample->data.size(); }
+
+  return sample->data.data();
+}
+
+
+size_t heif_raw_sequence_sample_get_data_size(const heif_raw_sequence_sample* sample)
+{
+  return sample->data.size();
+}
+
+
+uint32_t heif_raw_sequence_sample_get_duration(const heif_raw_sequence_sample* sample)
+{
+  return sample->duration;
+}
+
+
+// --- writing sequences
+
+
+void heif_context_set_sequence_timescale(heif_context* ctx, uint32_t timescale)
+{
+  ctx->context->set_sequence_timescale(timescale);
+}
+
+
+void heif_context_set_number_of_sequence_repetitions(heif_context* ctx, uint32_t repetitions)
+{
+  ctx->context->set_number_of_sequence_repetitions(repetitions);
+}
+
+
+struct heif_track_options
+{
+  TrackOptions options;
+};
+
+
+heif_track_options* heif_track_options_alloc()
+{
+  return new heif_track_options;
+}
+
+
+void heif_track_options_release(heif_track_options* options)
+{
+  delete options;
+}
+
+
+void heif_track_options_set_timescale(heif_track_options* options, uint32_t timescale)
+{
+  options->options.track_timescale = timescale;
+}
+
+
+void heif_track_options_set_interleaved_sample_aux_infos(heif_track_options* options, int interleaved_flag)
+{
+  options->options.write_sample_aux_infos_interleaved = (interleaved_flag != 0);
+}
+
+
+heif_error heif_track_options_enable_sample_tai_timestamps(heif_track_options* options,
+                                                           const heif_tai_clock_info* tai_info,
+                                                           heif_sample_aux_info_presence presence)
+{
+  if (presence != heif_sample_aux_info_presence_none &&
+      tai_info == nullptr) {
+    return {
+      heif_error_Usage_error,
+      heif_suberror_Unspecified,
+      "NULL tai clock info passed for track with TAI timestamps"
+    };
+  }
+
+  options->options.with_sample_tai_timestamps = presence;
+
+  // delete old object in case we are calling heif_track_options_enable_sample_tai_timestamps() multiple times
+  delete options->options.tai_clock_info;
+
+  if (tai_info != nullptr) {
+    options->options.tai_clock_info = heif_tai_clock_info_alloc();
+    heif_tai_clock_info_copy(options->options.tai_clock_info, tai_info);
+  }
+  else {
+    options->options.tai_clock_info = nullptr;
+  }
+
+  return heif_error_ok;
+}
+
+
+void heif_track_options_enable_sample_gimi_content_ids(heif_track_options* options,
+                                                       heif_sample_aux_info_presence presence)
+{
+  options->options.with_sample_content_ids = presence;
+}
+
+
+void heif_track_options_set_gimi_track_id(heif_track_options* options,
+                                          const char* track_id)
+{
+  if (track_id == nullptr) {
+    options->options.gimi_track_content_id.clear();
+    return;
+  }
+
+  options->options.gimi_track_content_id = track_id;
+}
+
+
+heif_sequence_encoding_options* heif_sequence_encoding_options_alloc()
+{
+  heif_sequence_encoding_options* options = new heif_sequence_encoding_options();
+
+  options->version = 2;
+  options->output_nclx_profile = nullptr;
+
+  options->color_conversion_options.version = 1;
+  options->color_conversion_options.preferred_chroma_downsampling_algorithm = heif_chroma_downsampling_average;
+  options->color_conversion_options.preferred_chroma_upsampling_algorithm = heif_chroma_upsampling_bilinear;
+  options->color_conversion_options.only_use_preferred_chroma_algorithm = false;
+
+  // version 2
+
+  options->gop_structure = heif_sequence_gop_structure_lowdelay;
+  options->keyframe_distance_min = 0;
+  options->keyframe_distance_max = 0;
+  options->save_alpha_channel = 1;
+
+  return options;
+}
+
+
+void heif_sequence_encoding_options_release(heif_sequence_encoding_options* options)
+{
+  delete options;
+}
+
+
+heif_error heif_context_add_visual_sequence_track(heif_context* ctx,
+                                                  uint16_t width, uint16_t height,
+                                                  heif_track_type track_type,
+                                                  const heif_track_options* track_options,
+                                                  const heif_sequence_encoding_options* encoding_options,
+                                                  heif_track** out_track)
+{
+  if (track_type != heif_track_type_video &&
+      track_type != heif_track_type_image_sequence) {
+    return {
+      heif_error_Usage_error,
+      heif_suberror_Invalid_parameter_value,
+      "visual track has to be of type video or image sequence"
+    };
+  }
+
+  TrackOptions default_track_info;
+  const TrackOptions* track_info = &default_track_info;
+  if (track_options != nullptr) {
+    track_info = &track_options->options;
+  }
+
+  Result<std::shared_ptr<Track_Visual> > addResult = ctx->context->add_visual_sequence_track(track_info, track_type, width, height);
+  if (!addResult) {
+    return addResult.error_struct(ctx->context.get());
+  }
+
+  if (out_track) {
+    auto* track = new heif_track;
+    track->track = *addResult;
+    track->context = ctx->context;
+
+    *out_track = track;
+  }
+
+  return heif_error_ok;
+}
+
+
+void heif_image_set_duration(heif_image* img, uint32_t duration)
+{
+  img->image->set_sample_duration(duration);
+}
+
+
+heif_error heif_track_encode_end_of_sequence(heif_track* track,
+                                             heif_encoder* encoder)
+{
+  // the input track must be a visual track
+
+  auto visual_track = std::dynamic_pointer_cast<Track_Visual>(track->track);
+  if (!visual_track) {
+    return {
+      heif_error_Usage_error,
+      heif_suberror_Invalid_parameter_value,
+      "Cannot encode image for non-visual track."
+    };
+  }
+
+  visual_track->encode_end_of_sequence(encoder);
+
+  return heif_error_ok;
+}
+
+
+heif_error heif_track_encode_sequence_image(heif_track* track,
+                                            const heif_image* input_image,
+                                            heif_encoder* encoder,
+                                            const heif_sequence_encoding_options* sequence_encoding_options)
+{
+  // the input track must be a visual track
+
+  auto visual_track = std::dynamic_pointer_cast<Track_Visual>(track->track);
+  if (!visual_track) {
+    return {
+      heif_error_Usage_error,
+      heif_suberror_Invalid_parameter_value,
+      "Cannot encode image for non-visual track."
+    };
+  }
+
+#if 0
+  // convert heif_sequence_encoding_options to heif_encoding_options that is used by track->encode_image()
+
+  heif_encoding_options* encoding_options = heif_encoding_options_alloc();
+  heif_color_profile_nclx nclx;
+  if (sequence_encoding_options) {
+    // the const_cast<> is ok, because output_nclx_profile will not be changed. It should actually be const, but we cannot change that.
+    encoding_options->output_nclx_profile = const_cast<heif_color_profile_nclx*>(sequence_encoding_options->output_nclx_profile);
+    encoding_options->color_conversion_options = sequence_encoding_options->color_conversion_options;
+
+    if (encoding_options->output_nclx_profile == nullptr) {
+      if (input_image->image->has_nclx_color_profile()) {
+        nclx_profile input_nclx = input_image->image->get_color_profile_nclx();
+
+        encoding_options->output_nclx_profile = &nclx;
+        nclx.version = 1;
+        nclx.color_primaries = (enum heif_color_primaries) input_nclx.get_colour_primaries();
+        nclx.transfer_characteristics = (enum heif_transfer_characteristics) input_nclx.get_transfer_characteristics();
+        nclx.matrix_coefficients = (enum heif_matrix_coefficients) input_nclx.get_matrix_coefficients();
+        nclx.full_range_flag = input_nclx.get_full_range_flag();
+      }
+    }
+  }
+#endif
+
+  // encode the image
+
+  auto error = visual_track->encode_image(input_image->image,
+                                          encoder,
+                                          sequence_encoding_options,
+                                          heif_image_input_class_normal);
+#if 0
+  heif_encoding_options_free(encoding_options);
+#endif
+
+  if (error.error_code) {
+    return error.error_struct(track->context.get());
+  }
+
+  return heif_error_ok;
+}
+
+
+heif_error heif_context_add_uri_metadata_sequence_track(heif_context* ctx,
+                                                        const char* uri,
+                                                        const heif_track_options* track_options,
+                                                        heif_track** out_track)
+{
+  TrackOptions default_track_info;
+  const TrackOptions* track_info = &default_track_info;
+  if (track_options != nullptr) {
+    track_info = &track_options->options;
+  }
+
+  Result<std::shared_ptr<Track_Metadata> > addResult = ctx->context->add_uri_metadata_sequence_track(track_info, uri);
+  if (!addResult) {
+    return addResult.error_struct(ctx->context.get());
+  }
+
+  if (out_track) {
+    auto* track = new heif_track;
+    track->track = *addResult;
+    track->context = ctx->context;
+
+    *out_track = track;
+  }
+
+  return heif_error_ok;
+}
+
+
+heif_raw_sequence_sample* heif_raw_sequence_sample_alloc()
+{
+  return new heif_raw_sequence_sample();
+}
+
+
+heif_error heif_raw_sequence_sample_set_data(heif_raw_sequence_sample* sample, const uint8_t* data, size_t size)
+{
+  // TODO: do we have to check the vector memory allocation?
+
+  sample->data.clear();
+  sample->data.insert(sample->data.begin(), data, data + size);
+
+  return heif_error_ok;
+}
+
+
+void heif_raw_sequence_sample_set_duration(heif_raw_sequence_sample* sample, uint32_t duration)
+{
+  sample->duration = duration;
+}
+
+
+heif_error heif_track_add_raw_sequence_sample(heif_track* track,
+                                              const heif_raw_sequence_sample* sample)
+{
+  auto metadata_track = std::dynamic_pointer_cast<Track_Metadata>(track->track);
+  if (!metadata_track) {
+    return {
+      heif_error_Usage_error,
+      heif_suberror_Invalid_parameter_value,
+      "Cannot save metadata in a non-metadata track."
+    };
+  }
+
+  auto error = metadata_track->write_raw_metadata(sample);
+  if (error.error_code) {
+    return error.error_struct(track->context.get());
+  }
+
+  return heif_error_ok;
+}
+
+
+int heif_track_get_number_of_sample_aux_infos(const heif_track* track)
+{
+  std::vector<heif_sample_aux_info_type> aux_info_types = track->track->get_sample_aux_info_types();
+  return (int) aux_info_types.size();
+}
+
+
+void heif_track_get_sample_aux_info_types(const heif_track* track, heif_sample_aux_info_type out_types[])
+{
+  std::vector<heif_sample_aux_info_type> aux_info_types = track->track->get_sample_aux_info_types();
+  for (size_t i = 0; i < aux_info_types.size(); i++) {
+    out_types[i] = aux_info_types[i];
+  }
+}
+
+
+const char* heif_track_get_gimi_track_content_id(const heif_track* track)
+{
+  std::string contentId = track->track->get_track_info().gimi_track_content_id;
+  if (contentId.empty()) {
+    return nullptr;
+  }
+
+  char* id = new char[contentId.length() + 1];
+  strcpy(id, contentId.c_str());
+
+  return id;
+}
+
+
+const char* heif_image_get_gimi_sample_content_id(const heif_image* img)
+{
+  if (!img->image->has_gimi_sample_content_id()) {
+    return nullptr;
+  }
+
+  auto id_string = img->image->get_gimi_sample_content_id();
+  char* id = new char[id_string.length() + 1];
+  strcpy(id, id_string.c_str());
+
+  return id;
+}
+
+
+const char* heif_raw_sequence_sample_get_gimi_sample_content_id(const heif_raw_sequence_sample* sample)
+{
+  char* s = new char[sample->gimi_sample_content_id.size() + 1];
+  strcpy(s, sample->gimi_sample_content_id.c_str());
+  return s;
+}
+
+
+void heif_image_set_gimi_sample_content_id(heif_image* img, const char* contentID)
+{
+  if (contentID) {
+    img->image->set_gimi_sample_content_id(contentID);
+  }
+  else {
+    img->image->set_gimi_sample_content_id({});
+  }
+}
+
+
+void heif_raw_sequence_sample_set_gimi_sample_content_id(heif_raw_sequence_sample* sample, const char* contentID)
+{
+  if (contentID) {
+    sample->gimi_sample_content_id = contentID;
+  }
+  else {
+    sample->gimi_sample_content_id.clear();
+  }
+}
+
+
+int heif_raw_sequence_sample_has_tai_timestamp(const heif_raw_sequence_sample* sample)
+{
+  return sample->timestamp ? 1 : 0;
+}
+
+
+const struct heif_tai_timestamp_packet* heif_raw_sequence_sample_get_tai_timestamp(const heif_raw_sequence_sample* sample)
+{
+  if (!sample->timestamp) {
+    return nullptr;
+  }
+
+  return sample->timestamp;
+}
+
+
+void heif_raw_sequence_sample_set_tai_timestamp(heif_raw_sequence_sample* sample,
+                                                const heif_tai_timestamp_packet* timestamp)
+{
+  // release of timestamp in case we overwrite it
+  heif_tai_timestamp_packet_release(sample->timestamp);
+
+  sample->timestamp = heif_tai_timestamp_packet_alloc();
+  heif_tai_timestamp_packet_copy(sample->timestamp, timestamp);
+}
+
+
+const heif_tai_clock_info* heif_track_get_tai_clock_info_of_first_cluster(heif_track* track)
+{
+  auto first_taic = track->track->get_first_cluster_taic();
+  if (!first_taic) {
+    return nullptr;
+  }
+
+  return first_taic->get_tai_clock_info();
+}
+
+
+void heif_track_add_reference_to_track(heif_track* track, uint32_t reference_type, const heif_track* to_track)
+{
+  track->track->add_reference_to_track(reference_type, to_track->track->get_id());
+}
+
+
+size_t heif_track_get_number_of_track_reference_types(const heif_track* track)
+{
+  auto tref = track->track->get_tref_box();
+  if (!tref) {
+    return 0;
+  }
+
+  return tref->get_number_of_reference_types();
+}
+
+
+void heif_track_get_track_reference_types(const heif_track* track, uint32_t out_reference_types[])
+{
+  auto tref = track->track->get_tref_box();
+  if (!tref) {
+    return;
+  }
+
+  auto refTypes = tref->get_reference_types();
+  for (size_t i = 0; i < refTypes.size(); i++) {
+    out_reference_types[i] = refTypes[i];
+  }
+}
+
+
+size_t heif_track_get_number_of_track_reference_of_type(const heif_track* track, uint32_t reference_type)
+{
+  auto tref = track->track->get_tref_box();
+  if (!tref) {
+    return 0;
+  }
+
+  return tref->get_number_of_references_of_type(reference_type);
+}
+
+
+size_t heif_track_get_references_from_track(const heif_track* track, uint32_t reference_type, uint32_t out_to_track_id[])
+{
+  auto tref = track->track->get_tref_box();
+  if (!tref) {
+    return 0;
+  }
+
+  auto refs = tref->get_references(reference_type);
+  for (size_t i = 0; i < refs.size(); i++) {
+    out_to_track_id[i] = refs[i];
+  }
+
+  return refs.size();
+}
+
+
+size_t heif_track_find_referring_tracks(const heif_track* track, uint32_t reference_type, uint32_t out_track_id[], size_t array_size)
+{
+  size_t nFound = 0;
+
+  // iterate through all tracks
+
+  auto trackIDs = track->context->get_track_IDs();
+  for (auto id : trackIDs) {
+    // a track should never reference itself
+    if (id == track->track->get_id()) {
+      continue;
+    }
+
+    // get the other track object
+
+    auto other_trackResult = track->context->get_track(id);
+    if (!other_trackResult) {
+      continue; // TODO: should we return an error in this case?
+    }
+
+    auto other_track = *other_trackResult;
+
+    // get the references of the other track
+
+    auto tref = other_track->get_tref_box();
+    if (!tref) {
+      continue;
+    }
+
+    // if the other track has a reference that points to the current track, add the other track to the list
+
+    std::vector<uint32_t> refs = tref->get_references(reference_type);
+    for (uint32_t to_track : refs) {
+      if (to_track == track->track->get_id() && nFound < array_size) {
+        out_track_id[nFound++] = other_track->get_id();
+        break;
+      }
+    }
+
+    // quick exit path
+    if (nFound == array_size)
+      break;
+  }
+
+  return nFound;
+}
diff --git a/libheif/api/libheif/heif_sequences.h b/libheif/api/libheif/heif_sequences.h
new file mode 100644
index 0000000000..179d364e08
--- /dev/null
+++ b/libheif/api/libheif/heif_sequences.h
@@ -0,0 +1,644 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2025 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_HEIF_SEQUENCES_H
+#define LIBHEIF_HEIF_SEQUENCES_H
+
+#include "libheif/heif.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// forward declaration of structs defined in heif_tai_timestamps.h
+typedef struct heif_tai_clock_info heif_tai_clock_info;
+typedef struct heif_tai_timestamp_packet heif_tai_timestamp_packet;
+
+
+// --- reading sequence tracks
+
+/**
+ * Check whether there is an image sequence in the HEIF file.
+ *
+ * @return A boolean whether there is an image sequence in the HEIF file.
+ */
+LIBHEIF_API
+int heif_context_has_sequence(const heif_context*);
+
+/**
+ * Get the timescale (clock ticks per second) for timing values in the sequence.
+ *
+ * @note Each track may have its independent timescale.
+ *
+ * @return Clock ticks per second. Returns 0 if there is no sequence in the file.
+ */
+LIBHEIF_API
+uint32_t heif_context_get_sequence_timescale(const heif_context*);
+
+/**
+ * Get the total duration of the sequence in timescale clock ticks.
+ * Use `heif_context_get_sequence_timescale()` to get the clock ticks per second.
+ *
+ * @return Sequence duration in clock ticks. Returns 0 if there is no sequence in the file.
+ */
+LIBHEIF_API
+uint64_t heif_context_get_sequence_duration(const heif_context*);
+
+
+// A track, which may be an image sequence, a video track or a metadata track.
+typedef struct heif_track heif_track;
+
+/**
+ * Free a `heif_track` object received from libheif.
+ * Passing NULL is ok.
+ */
+LIBHEIF_API
+void heif_track_release(heif_track*);
+
+/**
+ * Get the number of tracks in the HEIF file.
+ *
+ * @return Number of tracks or 0 if there is no sequence in the HEIF file.
+ */
+LIBHEIF_API
+int heif_context_number_of_sequence_tracks(const heif_context*);
+
+/**
+ * Returns the IDs for each of the tracks stored in the HEIF file.
+ * The output array must have heif_context_number_of_sequence_tracks() entries.
+ */
+LIBHEIF_API
+void heif_context_get_track_ids(const heif_context* ctx, uint32_t out_track_id_array[]);
+
+/**
+ * Get the ID of the passed track.
+ * The track ID will never be 0.
+ */
+LIBHEIF_API
+uint32_t heif_track_get_id(const heif_track* track);
+
+/**
+ * Get the heif_track object for the given track ID.
+ * If you pass `id=0`, the first visual track will be returned.
+ * If there is no track with the given ID or if 0 is passed and there is no visual track, NULL will be returned.
+ *
+ * @note Tracks never have a zero ID. This is why we can use this as a special value to find the first visual track.
+ *
+ * @param id Track id or 0 for the first visual track.
+ * @return heif_track object. You must free this after use.
+ */
+// Use id=0 for the first visual track.
+LIBHEIF_API
+heif_track* heif_context_get_track(const heif_context*, uint32_t id);
+
+
+typedef uint32_t heif_track_type;
+
+typedef enum heif_track_type_4cc
+{
+  heif_track_type_video = heif_fourcc('v', 'i', 'd', 'e'),
+  heif_track_type_image_sequence = heif_fourcc('p', 'i', 'c', 't'),
+  heif_track_type_auxiliary = heif_fourcc('a', 'u', 'x', 'v'),
+  heif_track_type_metadata = heif_fourcc('m', 'e', 't', 'a')
+} heif_track_type_4cc;
+
+/**
+ * Get the four-cc track handler type.
+ * Typical codes are "vide" for video sequences, "pict" for image sequences, "meta" for metadata tracks.
+ * These are defined in heif_track_type_4cc, but files may also contain other types.
+ *
+ * @return four-cc handler type
+ */
+LIBHEIF_API
+heif_track_type heif_track_get_track_handler_type(const heif_track*);
+
+
+typedef enum heif_auxiliary_track_info_type
+{
+  heif_auxiliary_track_info_type_unknown = 0,
+  heif_auxiliary_track_info_type_alpha = 1
+} heif_auxiliary_track_info_type;
+
+LIBHEIF_API
+enum heif_auxiliary_track_info_type heif_track_get_auxiliary_info_type(const heif_track*);
+
+LIBHEIF_API
+const char* heif_track_get_auxiliary_info_type_urn(const heif_track*);
+
+LIBHEIF_API
+int heif_track_has_alpha_channel(const heif_track*);
+
+/**
+ * Get the timescale (clock ticks per second) for this track.
+ * Note that this can be different from the timescale used at sequence level.
+ *
+ * @return clock ticks per second
+ */
+LIBHEIF_API
+uint32_t heif_track_get_timescale(const heif_track*);
+
+
+// --- reading visual tracks
+
+/**
+ * Get the image resolution of the track.
+ * If the passed track is no visual track, an error is returned.
+ */
+LIBHEIF_API
+heif_error heif_track_get_image_resolution(const heif_track*, uint16_t* out_width, uint16_t* out_height);
+
+/**
+ * Decode the next image in the passed sequence track.
+ * If there is no more image in the sequence, `heif_error_End_of_sequence` is returned.
+ * The parameters `colorspace`, `chroma` and `options` are similar to heif_decode_image().
+ * If you want to let libheif decide the output colorspace and chroma, set these parameters
+ * to heif_colorspace_undefined / heif_chroma_undefined. Usually, libheif will return the
+ * image in the input colorspace, but it may also modify it for example when it has to rotate the image.
+ * If you want to get the image in a specific colorspace/chroma format, you can specify this
+ * and libheif will convert the image to match this format.
+ */
+LIBHEIF_API
+heif_error heif_track_decode_next_image(heif_track* track,
+                                        heif_image** out_img,
+                                        enum heif_colorspace colorspace,
+                                        enum heif_chroma chroma,
+                                        const heif_decoding_options* options);
+
+/**
+ * Get the image display duration in clock ticks of this track.
+ * Make sure to use the timescale of the track and not the timescale of the total sequence.
+ */
+LIBHEIF_API
+uint32_t heif_image_get_duration(const heif_image*);
+
+
+// --- reading metadata track samples
+
+/**
+ * Get the "sample entry type" of the first sample sample cluster in the track.
+ * In the case of metadata tracks, this will usually be "urim" for "URI Meta Sample Entry".
+ * The exact URI can then be obtained with 'heif_track_get_urim_sample_entry_uri_of_first_cluster'.
+ */
+LIBHEIF_API
+uint32_t heif_track_get_sample_entry_type_of_first_cluster(const heif_track*);
+
+/**
+ * Get the URI of the first sample cluster in an 'urim' track.
+ * Only call this for tracks with 'urim' sample entry types. It will return an error otherwise.
+ *
+ * @param out_uri A string with the URI will be returned. Free this string with `heif_string_release()`.
+ */
+LIBHEIF_API
+heif_error heif_track_get_urim_sample_entry_uri_of_first_cluster(const heif_track*,
+                                                                 const char** out_uri);
+
+
+/** Sequence sample object that can hold any raw byte data.
+ * Use this to store and read raw metadata samples.
+ */
+typedef struct heif_raw_sequence_sample heif_raw_sequence_sample;
+
+/**
+ * Get the next raw sample from the (metadata) sequence track.
+ * You have to free the returned sample with heif_raw_sequence_sample_release().
+ */
+LIBHEIF_API
+heif_error heif_track_get_next_raw_sequence_sample(heif_track*,
+                                                   heif_raw_sequence_sample** out_sample);
+
+/**
+ * Release a heif_raw_sequence_sample object.
+ * You may pass NULL.
+ */
+LIBHEIF_API
+void heif_raw_sequence_sample_release(heif_raw_sequence_sample*);
+
+/**
+ * Get a pointer to the data of the (metadata) sample.
+ * The data pointer stays valid until the heif_raw_sequence_sample object is released.
+ *
+ * @param out_array_size Size of the returned array (may be NULL).
+ */
+LIBHEIF_API
+const uint8_t* heif_raw_sequence_sample_get_data(const heif_raw_sequence_sample*, size_t* out_array_size);
+
+/**
+ * Return the size of the raw data contained in the sample.
+ * This is the same as returned through the 'out_array_size' parameter of 'heif_raw_sequence_sample_get_data()'.
+ */
+LIBHEIF_API
+size_t heif_raw_sequence_sample_get_data_size(const heif_raw_sequence_sample*);
+
+/**
+ * Get the sample duration in clock ticks of this track.
+ * Make sure to use the timescale of the track and not the timescale of the total sequence.
+ */
+LIBHEIF_API
+uint32_t heif_raw_sequence_sample_get_duration(const heif_raw_sequence_sample*);
+
+
+// --- writing sequences
+
+/**
+ * Set an independent global timescale for the sequence.
+ * If no timescale is set with this function, the timescale of the first track will be used.
+ */
+LIBHEIF_API
+void heif_context_set_sequence_timescale(heif_context*, uint32_t timescale);
+
+// Number of times the sequence should be played in total (default = 1).
+// Can be set to heif_sequence_maximum_number_of_repetitions.
+LIBHEIF_API
+void heif_context_set_number_of_sequence_repetitions(heif_context*, uint32_t number_of_repetitions);
+
+#define heif_sequence_maximum_number_of_repetitions 0
+
+/**
+ * Specifies whether a 'sample auxiliary info' is stored with the samples.
+ * The difference between `heif_sample_aux_info_presence_optional` and `heif_sample_aux_info_presence_mandatory`
+ * is that `heif_sample_aux_info_presence_mandatory` will throw an error if the data is missing when writing a sample.
+ */
+typedef enum heif_sample_aux_info_presence
+{
+  heif_sample_aux_info_presence_none = 0,
+  heif_sample_aux_info_presence_optional = 1,
+  heif_sample_aux_info_presence_mandatory = 2
+} heif_sample_aux_info_presence;
+
+
+typedef struct heif_track_options heif_track_options;
+
+/**
+ * Allocate track options object that is required to set options for a new track.
+ * When you create a new track, you can also pass a NULL heif_track_options pointer, in which case the default options are used.
+ */
+LIBHEIF_API
+heif_track_options* heif_track_options_alloc(void);
+
+LIBHEIF_API
+void heif_track_options_release(heif_track_options*);
+
+/**
+ * Set the track specific timescale. This is the number of clock ticks per second.
+ * The default is 90,000 Hz.
+ * @param timescale
+ */
+LIBHEIF_API
+void heif_track_options_set_timescale(heif_track_options*, uint32_t timescale);
+
+/**
+ * Set whether the aux-info data should be stored interleaved with the sequence samples.
+ * Default is: false.
+ *
+ * If 'true', the aux_info data blocks will be interleaved with the compressed image.
+ * This has the advantage that the aux_info is localized near the image data.
+ *
+ * If 'false', all aux_info will be written as one block after the compressed image data.
+ * This has the advantage that no aux_info offsets have to be written.
+ *
+ * Note: currently ignored. Interleaved writing is disabled.
+ */
+LIBHEIF_API
+void heif_track_options_set_interleaved_sample_aux_infos(heif_track_options*, int interleaved_flag);
+
+LIBHEIF_API
+heif_error heif_track_options_enable_sample_tai_timestamps(heif_track_options*,
+                                                           const heif_tai_clock_info*,
+                                                           enum heif_sample_aux_info_presence);
+
+LIBHEIF_API
+void heif_track_options_enable_sample_gimi_content_ids(heif_track_options*,
+                                                       enum heif_sample_aux_info_presence);
+
+/**
+ * Set the GIMI format track ID string. If NULL is passed, no track ID is saved.
+ * @param track_id
+ */
+LIBHEIF_API
+void heif_track_options_set_gimi_track_id(heif_track_options*,
+                                          const char* track_id);
+
+
+// --- writing visual tracks
+
+typedef enum heif_sequence_gop_structure
+{
+  // Only independently decodable keyframes.
+  heif_sequence_gop_structure_intra_only,
+
+  // No frame reordering, usually an IPPPP structure.
+  heif_sequence_gop_structure_lowdelay,
+
+  // All frame types are allowed, including frame reordering, to achieve
+  // the best compression ratio.
+  heif_sequence_gop_structure_unrestricted
+} heif_sequence_gop_structure;
+
+
+typedef struct heif_sequence_encoding_options
+{
+  uint8_t version;
+
+  // version 1 options
+
+  // Set this to the NCLX parameters to be used in the output images or set to NULL
+  // when the same parameters as in the input images should be used.
+  const heif_color_profile_nclx* output_nclx_profile;
+
+  heif_color_conversion_options color_conversion_options;
+
+  // version 2 options
+
+  enum heif_sequence_gop_structure gop_structure;
+  int keyframe_distance_min; // 0 - undefined
+  int keyframe_distance_max; // 0 - undefined
+
+  int save_alpha_channel;
+} heif_sequence_encoding_options;
+
+
+LIBHEIF_API
+heif_sequence_encoding_options* heif_sequence_encoding_options_alloc(void);
+
+LIBHEIF_API
+void heif_sequence_encoding_options_release(heif_sequence_encoding_options*);
+
+/**
+ * Add a visual track to the sequence.
+ * The track ID is assigned automatically.
+ *
+ * @param width Image resolution width
+ * @param height Image resolution height
+ * @param track_type Has to be heif_track_type_video or heif_track_type_image_sequence
+ * @param track_options Optional track creation options. If NULL, default options will be used.
+ * @param encoding_options Options for sequence encoding. If NULL, default options will be used.
+ * @param out_track Output parameter to receive the track object for the just created track.
+ * @return
+ */
+LIBHEIF_API
+heif_error heif_context_add_visual_sequence_track(heif_context*,
+                                                  uint16_t width, uint16_t height,
+                                                  heif_track_type track_type,
+                                                  const heif_track_options* track_options,
+                                                  const heif_sequence_encoding_options* encoding_options,
+                                                  heif_track** out_track);
+
+/**
+ * Set the image display duration in the track's timescale units.
+ */
+LIBHEIF_API
+void heif_image_set_duration(heif_image*, uint32_t duration);
+
+/**
+ * Encode the image into a visual track.
+ * If the passed track is no visual track, an error will be returned.
+ *
+ * @param image                     The input image to append to the sequence.
+ * @param encoder                   The encoder used for encoding the image.
+ * @param sequence_encoding_options Options for sequence encoding. If NULL, default options will be used.
+ */
+LIBHEIF_API
+heif_error heif_track_encode_sequence_image(heif_track*,
+                                            const heif_image* image,
+                                            heif_encoder* encoder,
+                                            const heif_sequence_encoding_options* sequence_encoding_options);
+
+/**
+ * When all sequence frames have been sent, you can to call this function to let the
+ * library know that no more frames will follow. This is strongly recommended, but optional
+ * for backwards compatibility.
+ * If you do not end the sequence explicitly with this function, it will be closed
+ * automatically when the HEIF file is written. Using this function has the advantage
+ * that you can free the {@link heif_encoder} afterwards (with {@link heif_encoder_release}).
+ * If you do not use call function, you have to keep the {@link heif_encoder} alive
+ * until the HEIF file is written.
+ */
+LIBHEIF_API
+heif_error heif_track_encode_end_of_sequence(heif_track*,
+                                             heif_encoder* encoder);
+
+// --- metadata tracks
+
+/**
+ * Add a metadata track.
+ * The track is created as a 'urim' "URI Meta Sample Entry".
+ * The track content type is specified by the 'uri' parameter.
+ *
+ * @param uri       Track content type.
+ * @param options   Optional track creation options. If NULL, default options will be used.
+ * @param out_track Returns the created track object. If this is not NULL, you have to
+ *                  free the returned track with {@link heif_track_release}.
+ */
+LIBHEIF_API
+heif_error heif_context_add_uri_metadata_sequence_track(heif_context*,
+                                                        const char* uri,
+                                                        const heif_track_options* options,
+                                                        heif_track** out_track);
+
+/**
+ * Allocate a new heif_raw_sequence_sample object.
+ * Free with heif_raw_sequence_sample_release().
+ */
+LIBHEIF_API
+heif_raw_sequence_sample* heif_raw_sequence_sample_alloc(void);
+
+/**
+ * Set the raw sequence sample data.
+ */
+LIBHEIF_API
+heif_error heif_raw_sequence_sample_set_data(heif_raw_sequence_sample*, const uint8_t* data, size_t size);
+
+/**
+ * Set the sample duration in track timescale units.
+ */
+LIBHEIF_API
+void heif_raw_sequence_sample_set_duration(heif_raw_sequence_sample*, uint32_t duration);
+
+/**
+ * Add a raw sequence sample (usually a metadata sample) to the (metadata) track.
+ */
+LIBHEIF_API
+heif_error heif_track_add_raw_sequence_sample(heif_track*,
+                                              const heif_raw_sequence_sample*);
+
+
+// --- sample auxiliary data
+
+/**
+ * Contains the type of sample auxiliary data assigned to the track samples.
+ */
+typedef struct heif_sample_aux_info_type
+{
+  uint32_t type;
+  uint32_t parameter;
+} heif_sample_aux_info_type;
+
+/**
+ * Returns how many different types of sample auxiliary data units are assigned to this track's samples.
+ */
+LIBHEIF_API
+int heif_track_get_number_of_sample_aux_infos(const heif_track*);
+
+/**
+ * Get get the list of sample auxiliary data types used in the track.
+ * The passed array has to have heif_track_get_number_of_sample_aux_infos() entries.
+ */
+LIBHEIF_API
+void heif_track_get_sample_aux_info_types(const heif_track*, heif_sample_aux_info_type out_types[]);
+
+
+// --- GIMI content IDs
+
+/**
+ * Get the GIMI content ID for the track (as a whole).
+ * If there is no content ID, nullptr is returned.
+ *
+ * @return The returned string has to be released with `heif_string_release()`.
+ */
+LIBHEIF_API
+const char* heif_track_get_gimi_track_content_id(const heif_track*);
+
+/**
+ * Get the GIMI content ID stored in the image sample.
+ * If there is no content ID, NULL is returned.
+ * @return
+ */
+LIBHEIF_API
+const char* heif_image_get_gimi_sample_content_id(const heif_image*);
+
+/**
+ * Get the GIMI content ID stored in the metadata sample.
+ * If there is no content ID, NULL is returned.
+ * @return
+ */
+LIBHEIF_API
+const char* heif_raw_sequence_sample_get_gimi_sample_content_id(const heif_raw_sequence_sample*);
+
+/**
+ * Set the GIMI content ID for an image sample. It will be stored as SAI.
+ * When passing NULL, a previously set ID will be removed.
+ */
+LIBHEIF_API
+void heif_image_set_gimi_sample_content_id(heif_image*, const char* contentID);
+
+/**
+ * Set the GIMI content ID for a (metadata) sample. It will be stored as SAI.
+ * When passing NULL, a previously set ID will be removed.
+ */
+LIBHEIF_API
+void heif_raw_sequence_sample_set_gimi_sample_content_id(heif_raw_sequence_sample*, const char* contentID);
+
+
+// --- TAI timestamps
+
+// Note: functions for setting timestamps on images are in heif_tai_timestamps.h
+
+/**
+ * Returns whether the raw (metadata) sample has a TAI timestamp attached to it (stored as SAI).
+ *
+ * @return boolean flag whether a TAI exists for this sample.
+ */
+LIBHEIF_API
+int heif_raw_sequence_sample_has_tai_timestamp(const heif_raw_sequence_sample*);
+
+/**
+ * Get the TAI timestamp of the (metadata) sample.
+ * If there is no timestamp assigned to it, NULL will be returned.
+ *
+ * @note You should NOT free the returned timestamp with 'heif_tai_timestamp_packet_release()'.
+ *       The returned struct stays valid until the heif_raw_sequence_sample is released.
+ */
+LIBHEIF_API
+const heif_tai_timestamp_packet* heif_raw_sequence_sample_get_tai_timestamp(const heif_raw_sequence_sample*);
+
+/**
+ * Set the TAI timestamp for a raw sequence sample.
+ * The timestamp will be copied, you can release it after calling this function.
+ */
+LIBHEIF_API
+void heif_raw_sequence_sample_set_tai_timestamp(heif_raw_sequence_sample* sample,
+                                                const heif_tai_timestamp_packet* timestamp);
+
+/**
+ * Returns the TAI clock info of the track.
+ * If there is no TAI clock info, NULL is returned.
+ * You should NOT free the returned heif_tai_clock_info.
+ * The structure stays valid until the heif_track object is released.
+ */
+LIBHEIF_API
+const heif_tai_clock_info* heif_track_get_tai_clock_info_of_first_cluster(heif_track*);
+
+
+// --- track references
+
+typedef enum heif_track_reference_type
+{
+  heif_track_reference_type_description = heif_fourcc('c', 'd', 's', 'c'), // track_description
+  heif_track_reference_type_thumbnails = heif_fourcc('t', 'h', 'm', 'b'), // thumbnails
+  heif_track_reference_type_auxiliary = heif_fourcc('a', 'u', 'x', 'l') // auxiliary data (e.g. depth maps or alpha channel)
+} heif_track_reference_type;
+
+/**
+ * Add a reference between tracks.
+ * 'reference_type' can be one of the four-cc codes listed in heif_track_reference_type or any other type.
+ */
+LIBHEIF_API
+void heif_track_add_reference_to_track(heif_track*, uint32_t reference_type, const heif_track* to_track);
+
+/**
+ * Return the number of different reference types used in this track's tref box.
+ */
+LIBHEIF_API
+size_t heif_track_get_number_of_track_reference_types(const heif_track*);
+
+/**
+ * List the reference types used in this track.
+ * The passed array must have heif_track_get_number_of_track_reference_types() entries.
+ */
+LIBHEIF_API
+void heif_track_get_track_reference_types(const heif_track*, uint32_t out_reference_types[]);
+
+/**
+ * Get the number of references of the passed type.
+ */
+LIBHEIF_API
+size_t heif_track_get_number_of_track_reference_of_type(const heif_track*, uint32_t reference_type);
+
+/**
+ * List the track ids this track points to with the passed reference type.
+ * The passed array must have heif_track_get_number_of_track_reference_of_type() entries.
+ */
+LIBHEIF_API
+size_t heif_track_get_references_from_track(const heif_track*, uint32_t reference_type, uint32_t out_to_track_id[]);
+
+/**
+ * Find tracks that are referring to the current track through the passed reference_type.
+ * The found track IDs will be filled into the passed array, but no more than `array_size` entries will be filled.
+ *
+ * @return number of tracks found. If this is equal to 'array_size', you should ask again with a larger array size to be sure you got all tracks.
+ */
+LIBHEIF_API
+size_t heif_track_find_referring_tracks(const heif_track*, uint32_t reference_type, uint32_t out_track_id[], size_t array_size);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/libheif/api/libheif/heif_tai_timestamps.cc b/libheif/api/libheif/heif_tai_timestamps.cc
new file mode 100644
index 0000000000..b5b4a9a100
--- /dev/null
+++ b/libheif/api/libheif/heif_tai_timestamps.cc
@@ -0,0 +1,273 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2025 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <libheif/heif_tai_timestamps.h>
+#include "api_structs.h"
+#include "box.h"
+#include "file.h"
+#include <memory>
+
+
+void initialize_heif_tai_clock_info(heif_tai_clock_info* taic)
+{
+  taic->version = 1;
+  taic->time_uncertainty = heif_tai_clock_info_time_uncertainty_unknown;
+  taic->clock_resolution = 0;
+  taic->clock_drift_rate = heif_tai_clock_info_clock_drift_rate_unknown;
+  taic->clock_type = heif_tai_clock_info_clock_type_unknown;
+}
+
+heif_tai_clock_info* heif_tai_clock_info_alloc()
+{
+  auto* taic = new heif_tai_clock_info;
+  initialize_heif_tai_clock_info(taic);
+
+  return taic;
+}
+
+
+void initialize_heif_tai_timestamp_packet(heif_tai_timestamp_packet* itai)
+{
+  itai->version = 1;
+  itai->tai_timestamp = 0;
+  itai->synchronization_state = false;
+  itai->timestamp_generation_failure = false;
+  itai->timestamp_is_modified = false;
+}
+
+heif_tai_timestamp_packet* heif_tai_timestamp_packet_alloc()
+{
+  auto* itai = new heif_tai_timestamp_packet;
+  initialize_heif_tai_timestamp_packet(itai);
+
+  return itai;
+}
+
+
+void heif_tai_timestamp_packet_copy(heif_tai_timestamp_packet* dst, const heif_tai_timestamp_packet* src)
+{
+  if (dst->version >= 1 && src->version >= 1) {
+    dst->tai_timestamp = src->tai_timestamp;
+    dst->synchronization_state = src->synchronization_state;
+    dst->timestamp_is_modified = src->timestamp_is_modified;
+    dst->timestamp_generation_failure = src->timestamp_generation_failure;
+  }
+
+  // in the future when copying with "src->version > dst->version",
+  // the remaining dst fields have to be filled with defaults
+}
+
+void heif_tai_clock_info_copy(heif_tai_clock_info* dst, const heif_tai_clock_info* src)
+{
+  if (dst->version >= 1 && src->version >= 1) {
+    dst->time_uncertainty = src->time_uncertainty;
+    dst->clock_resolution = src->clock_resolution;
+    dst->clock_drift_rate = src->clock_drift_rate;
+    dst->clock_type = src->clock_type;
+  }
+
+  // in the future when copying with "src->version > dst->version",
+  // the remaining dst fields have to be filled with defaults
+}
+
+
+heif_error heif_item_set_property_tai_clock_info(heif_context* ctx,
+                                                 heif_item_id itemId,
+                                                 const heif_tai_clock_info* clock,
+                                                 heif_property_id* out_propertyId)
+{
+  if (!ctx || !clock) {
+    return heif_error_null_pointer_argument;
+  }
+
+  // Check if itemId exists
+  auto file = ctx->context->get_heif_file();
+  if (!file->item_exists(itemId)) {
+    return {heif_error_Input_does_not_exist, heif_suberror_Invalid_parameter_value, "itemId does not exist"};
+  }
+
+  // make sure that we do not add two taic boxes to one image
+
+  if (auto img = ctx->context->get_image(itemId, false)) {
+    auto existing_taic = img->get_property<Box_taic>();
+    if (existing_taic) {
+      return {heif_error_Usage_error, heif_suberror_Invalid_parameter_value, "item already has an taic property"};
+    }
+  }
+
+  // Create new taic (it will be deduplicated automatically in add_property())
+
+  auto taic = std::make_shared<Box_taic>();
+  taic->set_from_tai_clock_info(clock);
+
+  heif_property_id id = ctx->context->add_property(itemId, taic, false);
+
+  if (out_propertyId) {
+    *out_propertyId = id;
+  }
+
+  return heif_error_success;
+}
+
+
+heif_error heif_item_get_property_tai_clock_info(const heif_context* ctx,
+                                                 heif_item_id itemId,
+                                                 heif_tai_clock_info** out_clock)
+{
+  if (!ctx || !out_clock) {
+    return heif_error_null_pointer_argument;
+  }
+
+  *out_clock = nullptr;
+
+  // Check if itemId exists
+  auto file = ctx->context->get_heif_file();
+  if (!file->item_exists(itemId)) {
+    return {heif_error_Input_does_not_exist, heif_suberror_Invalid_parameter_value, "item ID does not exist"};
+  }
+
+  // Check if taic exists for itemId
+  auto taic = file->get_property_for_item<Box_taic>(itemId);
+  if (!taic) {
+    // return NULL heif_tai_clock_info
+    return heif_error_success;
+  }
+
+  *out_clock = new heif_tai_clock_info;
+  **out_clock = *taic->get_tai_clock_info();
+
+  return heif_error_success;
+}
+
+
+void heif_tai_clock_info_release(heif_tai_clock_info* clock_info)
+{
+  delete clock_info;
+}
+
+
+void heif_tai_timestamp_packet_release(heif_tai_timestamp_packet* tai)
+{
+  delete tai;
+}
+
+
+heif_error heif_item_set_property_tai_timestamp(heif_context* ctx,
+                                                heif_item_id itemId,
+                                                const heif_tai_timestamp_packet* timestamp,
+                                                heif_property_id* out_propertyId)
+{
+  if (!ctx) {
+    return heif_error_null_pointer_argument;
+  }
+
+  // Check if itemId exists
+  auto file = ctx->context->get_heif_file();
+  if (!file->item_exists(itemId)) {
+    return {heif_error_Input_does_not_exist, heif_suberror_Invalid_parameter_value, "item does not exist"};
+  }
+
+  // make sure that we do not add two TAI timestamps to one image
+
+  if (auto img = ctx->context->get_image(itemId, false)) {
+    auto existing_itai = img->get_property<Box_itai>();
+    if (existing_itai) {
+      return {heif_error_Usage_error, heif_suberror_Invalid_parameter_value, "item already has an itai property"};
+    }
+  }
+
+  // Create new itai (it will be deduplicated automatically in add_property())
+
+  auto itai = std::make_shared<Box_itai>();
+  itai->set_from_tai_timestamp_packet(timestamp);
+
+  heif_property_id id = ctx->context->add_property(itemId, itai, false);
+
+  if (out_propertyId) {
+    *out_propertyId = id;
+  }
+
+  return heif_error_success;
+}
+
+
+heif_error heif_item_get_property_tai_timestamp(const heif_context* ctx,
+                                                heif_item_id itemId,
+                                                heif_tai_timestamp_packet** out_timestamp)
+{
+  if (!ctx || !out_timestamp) {
+    return heif_error_null_pointer_argument;
+  }
+
+  *out_timestamp = nullptr;
+
+  // Check if itemId exists
+  auto file = ctx->context->get_heif_file();
+  if (!file->item_exists(itemId)) {
+    return {heif_error_Input_does_not_exist, heif_suberror_Invalid_parameter_value, "item does not exist"};
+  }
+
+  // Check if itai exists for itemId
+  auto itai = file->get_property_for_item<Box_itai>(itemId);
+  if (!itai) {
+    // return NULL heif_tai_timestamp_packet;
+    return heif_error_success;
+  }
+
+  *out_timestamp = new heif_tai_timestamp_packet;
+  **out_timestamp = *itai->get_tai_timestamp_packet();
+
+  return heif_error_success;
+}
+
+
+heif_error heif_image_set_tai_timestamp(heif_image* img,
+                                        const heif_tai_timestamp_packet* timestamp)
+{
+  Error err = img->image->set_tai_timestamp(timestamp);
+  if (err) {
+    return err.error_struct(img->image.get());
+  }
+  else {
+    return heif_error_success;
+  }
+}
+
+
+heif_error heif_image_get_tai_timestamp(const heif_image* img,
+                                        heif_tai_timestamp_packet** out_timestamp)
+{
+  if (!out_timestamp) {
+    return heif_error_null_pointer_argument;
+  }
+
+  *out_timestamp = nullptr;
+
+  auto* tai = img->image->get_tai_timestamp();
+  if (!tai) {
+    *out_timestamp = nullptr;
+    return heif_error_success;
+  }
+
+  *out_timestamp = new heif_tai_timestamp_packet;
+  **out_timestamp = *tai;
+
+  return heif_error_success;
+}
diff --git a/libheif/api/libheif/heif_tai_timestamps.h b/libheif/api/libheif/heif_tai_timestamps.h
new file mode 100644
index 0000000000..ceb57a2aed
--- /dev/null
+++ b/libheif/api/libheif/heif_tai_timestamps.h
@@ -0,0 +1,202 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2025 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_HEIF_TAI_TIMESTAMPS_H
+#define LIBHEIF_HEIF_TAI_TIMESTAMPS_H
+
+#include <libheif/heif.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct heif_tai_clock_info
+{
+  uint8_t version;
+
+  // --- version 1
+
+  // Standard deviation for timestamp generation process.
+  // May be `heif_tai_clock_info_time_uncertainty_unknown` if unknown.
+  uint64_t time_uncertainty;
+
+  // Receptor clock resolution in nanoseconds.
+  uint32_t clock_resolution;
+
+  // Clock drift rate in picoseconds/second when synchronization is stopped.
+  // Maybe `heif_tai_clock_info_clock_drift_rate_unknown` if unknown.
+  int32_t clock_drift_rate;
+
+  // Whether clock is synchronized to an atomic source,
+  // see the clock_type defines below.
+  uint8_t clock_type;
+} heif_tai_clock_info;
+
+#define heif_tai_clock_info_time_uncertainty_unknown UINT64_C(0xFFFFFFFFFFFFFFFF)
+#define heif_tai_clock_info_clock_drift_rate_unknown INT32_C(0x7FFFFFFF)
+#define heif_tai_clock_info_clock_type_unknown 0
+#define heif_tai_clock_info_clock_type_not_synchronized_to_atomic_source 1
+#define heif_tai_clock_info_clock_type_synchronized_to_atomic_source 2
+
+
+/**
+ * Allocate a new heif_tai_clock_info object and initialize with default values.
+ */
+LIBHEIF_API
+heif_tai_clock_info* heif_tai_clock_info_alloc(void);
+
+/**
+ * Copies the source object into the destination object.
+ * Only the fields that are present in both objects are copied.
+ * The version property has to be set in both structs.
+ */
+LIBHEIF_API
+void heif_tai_clock_info_copy(heif_tai_clock_info* dst, const heif_tai_clock_info* src);
+
+LIBHEIF_API
+void heif_tai_clock_info_release(heif_tai_clock_info* clock_info);
+
+
+typedef struct heif_tai_timestamp_packet
+{
+  uint8_t version;
+
+  // --- version 1
+
+  // number of nanoseconds since TAI epoch (1958-01-01T00:00:00.0)
+  uint64_t tai_timestamp;
+
+  // whether the remote and receiptor clocks are in sync
+  uint8_t synchronization_state;         // bool
+
+  // whether the receptor clock failed to generate a timestamp
+  uint8_t timestamp_generation_failure;  // bool
+
+  // whether the original clock value has been modified
+  uint8_t timestamp_is_modified;         // bool
+} heif_tai_timestamp_packet;
+
+/**
+ * Allocate a new heif_tai_timestamp_packet object and initialize with default values.
+ */
+LIBHEIF_API
+heif_tai_timestamp_packet* heif_tai_timestamp_packet_alloc(void);
+
+/**
+ * Copies the source object into the destination object.
+ * Only the fields that are present in both objects are copied.
+ * The version property has to be set in both structs.
+ */
+LIBHEIF_API
+void heif_tai_timestamp_packet_copy(heif_tai_timestamp_packet* dst, const heif_tai_timestamp_packet* src);
+
+LIBHEIF_API
+void heif_tai_timestamp_packet_release(heif_tai_timestamp_packet*);
+
+
+
+/**
+ * Creates a new clock info property if it doesn't exist yet.
+ * You can only add one tai_clock_info to an image.
+ *
+ * @param clock_info The TAI clock info to set for the item. This object will be copied.
+ * @param out_optional_propertyId Output parameter for the property ID of the tai_clock_info.
+ *                                This parameter may be NULL if the info is not required.
+ */
+LIBHEIF_API
+heif_error heif_item_set_property_tai_clock_info(heif_context* ctx,
+                                                 heif_item_id itemId,
+                                                 const heif_tai_clock_info* clock_info,
+                                                 heif_property_id* out_optional_propertyId);
+
+/**
+ * Get the heif_tai_clock_info attached to the item.
+ * This function allocates a new heif_tai_clock_info and returns it through out_clock.
+ *
+ * @param out_clock This parameter must not be nullptr. The object returned through this parameter must
+ *                  be released with heif_tai_clock_info_release().
+ *                  If no tai_clock_info property exists for the item, out_clock is set to NULL and
+ *                  no error is returned.
+ */
+LIBHEIF_API
+heif_error heif_item_get_property_tai_clock_info(const heif_context* ctx,
+                                                 heif_item_id itemId,
+                                                 heif_tai_clock_info** out_clock);
+
+
+/**
+ * Creates a new TAI timestamp property if it doesn't exist yet.
+ * You can only add one tai_timestamp to an image.
+ *
+ * @param timestamp The TAI timestamp to set for the item. This object will be copied.
+ * @param out_optional_propertyId Output parameter for the property ID of the TAI timestamp.
+ *                                This parameter may be NULL if the info is not required.
+ */
+LIBHEIF_API
+heif_error heif_item_set_property_tai_timestamp(heif_context* ctx,
+                                                heif_item_id itemId,
+                                                const heif_tai_timestamp_packet* timestamp,
+                                                heif_property_id* out_optional_propertyId);
+
+/**
+ * Get the heif_tai_timestamp_packet attached to the item.
+ * This function allocates a new heif_tai_timestamp_packet and returns it through out_timestamp.
+ *
+ * @param out_timestamp This parameter must not be NULL. The object returned through this parameter must
+ *                  be released with heif_tai_timestamp_packet_release().
+ *                  If no tai_timestamp_packet property exists for the item, *out_timestamp is set to NULL and
+ *                  no error is returned.
+ */
+LIBHEIF_API
+heif_error heif_item_get_property_tai_timestamp(const heif_context* ctx,
+                                                heif_item_id itemId,
+                                                heif_tai_timestamp_packet** out_timestamp);
+
+/**
+ * Attach a TAI timestamp to the image.
+ * The main use of this function is for image sequences, but it can also be used for still images.
+ * If used for still images, note that you also have to set the heif_tai_clock_info to the image item
+ * through heif_item_set_property_tai_clock_info().
+ *
+ * @param timestamp The TAI timestamp to set to the image. This object will be copied.
+ */
+LIBHEIF_API
+heif_error heif_image_set_tai_timestamp(heif_image* img,
+                                        const heif_tai_timestamp_packet* timestamp);
+
+/**
+ * Get the heif_tai_timestamp_packet attached to the image.
+ * The main use of this function is for image sequences, but it can also be used for still images.
+ * This function allocates a new heif_tai_timestamp_packet and returns it through out_timestamp.
+ *
+ * @param out_timestamp This parameter must not be NULL. The object returned through this parameter must
+ *                  be released with heif_tai_timestamp_packet_release().
+ *                  If no tai_timestamp_packet property exists for the image, *out_timestamp is set to NULL and
+ *                  no error is returned.
+ */
+LIBHEIF_API
+heif_error heif_image_get_tai_timestamp(const heif_image* img,
+                                        heif_tai_timestamp_packet** out_timestamp);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif //LIBHEIF_HEIF_TAI_TIMESTAMPS_H
diff --git a/libheif/api/libheif/heif_text.cc b/libheif/api/libheif/heif_text.cc
new file mode 100644
index 0000000000..4b0d6c307a
--- /dev/null
+++ b/libheif/api/libheif/heif_text.cc
@@ -0,0 +1,162 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ * Copyright (c) 2025 Brad Hards <bradh@frogmouth.net>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "heif_text.h"
+#include "api_structs.h"
+#include "file.h"
+#include "text.h"
+#include <algorithm>
+#include <cstring>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+heif_error heif_image_handle_add_text_item(heif_image_handle *image_handle,
+                                           const char *content_type,
+                                           const char *text,
+                                           heif_text_item** out_text_item)
+{
+
+  auto textItemResult = image_handle->context->add_text_item(content_type, text);
+  if (!textItemResult) {
+    return textItemResult.error_struct(image_handle->context.get());
+  }
+  std::shared_ptr<TextItem> textItem = *textItemResult;
+  image_handle->image->add_text_item_id(textItem->get_item_id());
+  if (out_text_item) {
+    heif_text_item* item = new heif_text_item();
+    item->context = image_handle->context;
+    item->text_item = std::move(textItem);
+    *out_text_item = item;
+  }
+  return heif_error_success;
+}
+
+void heif_text_item_release(heif_text_item* text_item)
+{
+  delete text_item;
+}
+
+int heif_image_handle_get_number_of_text_items(const heif_image_handle* handle)
+{
+  return (int) handle->image->get_text_item_ids().size();
+}
+
+int heif_image_handle_get_list_of_text_item_ids(const heif_image_handle* handle,
+                                                  heif_item_id* item_ids,
+                                                  int max_count)
+{
+  auto text_item_ids = handle->image->get_text_item_ids();
+  int num = std::min((int) text_item_ids.size(), max_count);
+
+  memcpy(item_ids, text_item_ids.data(), num * sizeof(heif_item_id));
+
+  return num;
+}
+
+
+heif_error heif_context_get_text_item(const heif_context* context,
+                                             heif_item_id text_item_id,
+                                             heif_text_item** out)
+{
+  if (out==nullptr) {
+    return heif_error_null_pointer_argument;
+  }
+
+  auto r = context->context->get_text_item(text_item_id);
+
+  if (r==nullptr) {
+    return {heif_error_Usage_error, heif_suberror_Nonexisting_item_referenced, "Text item does not exist"};
+  }
+
+  heif_text_item* item = new heif_text_item();
+  item->context = context->context;
+  item->text_item = std::move(r);
+  *out = item;
+
+  return heif_error_success;
+}
+
+heif_item_id heif_text_item_get_id(heif_text_item* text_item)
+{
+  if (text_item == nullptr) {
+    return 0;
+  }
+
+  return text_item->text_item->get_item_id();
+}
+
+const char* heif_text_item_get_content(heif_text_item* text_item)
+{
+  if (text_item == nullptr) {
+    return nullptr;
+  }
+
+  // return text as c-string
+
+  std::string txt = text_item->text_item->get_item_text();
+
+  char* text_c = new char[txt.length() + 1];
+  strcpy(text_c, txt.c_str());
+
+  return text_c;
+}
+
+
+heif_error heif_text_item_get_property_extended_language(const heif_text_item* text_item, char** out_language)
+{
+  if (!out_language || !text_item) {
+    return {heif_error_Usage_error, heif_suberror_Invalid_parameter_value, "NULL passed"};
+  }
+
+  auto elng = text_item->context->find_property<Box_elng>(text_item->text_item->get_item_id());
+  if (!elng) {
+    return elng.error_struct(text_item->context.get());
+  }
+
+  std::string lang = (*elng)->get_extended_language();
+  *out_language = new char[lang.length() + 1];
+  strcpy(*out_language, lang.c_str());
+
+  return heif_error_success;
+}
+
+
+heif_error heif_text_item_set_extended_language(heif_text_item* text_item, const char *language, heif_property_id* out_optional_propertyId)
+{
+  if (!text_item || !language) {
+    return {heif_error_Usage_error, heif_suberror_Null_pointer_argument, "NULL passed"};
+  }
+
+  Result<heif_property_id> property_id_result = text_item->context->add_text_property(text_item->text_item->get_item_id(),
+                                                                                      language);
+
+  if (auto err = property_id_result.error()) {
+    return err.error_struct(text_item->context.get());
+  }
+
+  if (out_optional_propertyId) {
+    *out_optional_propertyId = *property_id_result;
+  }
+
+  return heif_error_success;
+}
\ No newline at end of file
diff --git a/libheif/api/libheif/heif_text.h b/libheif/api/libheif/heif_text.h
new file mode 100644
index 0000000000..878e2d42e1
--- /dev/null
+++ b/libheif/api/libheif/heif_text.h
@@ -0,0 +1,161 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ * Copyright (c) 2025 Brad Hards <bradh@frogmouth.net>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_HEIF_TEXT_H
+#define LIBHEIF_HEIF_TEXT_H
+
+#include "heif_image_handle.h"
+#include "heif_library.h"
+#include "heif_error.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// --- text items and fonts
+
+// See ISO/IEC 23008-12:2025 Section 6.10 "Text and font items"
+
+typedef struct heif_text_item heif_text_item;
+
+/**
+ * Get the number of text items that are attached to an image.
+ *
+ * @param image_handle the image handle for the image to query.
+ * @return the number of text items, which can be zero.
+ */
+LIBHEIF_API
+int heif_image_handle_get_number_of_text_items(const heif_image_handle* image_handle);
+
+/**
+ * Get the text item identifiers for the text items attached to an image.
+ *
+ * Possible usage (in C++):
+ * @code
+ *  int numTextItems = heif_image_handle_get_number_of_text_items(handle);
+ *  if (numTextItems > 0) {
+ *      std::vector<heif_item_id> text_item_ids(numTextItems);
+ *      heif_image_handle_get_list_of_text_item_ids(handle, text_item_ids.data(), numTextItems);
+ *      // use text item ids
+ *  }
+ * @endcode
+ *
+ * @param image_handle the image handle for the parent image to query
+ * @param text_item_ids_array array to put the item identifiers into
+ * @param max_count the maximum number of text identifiers
+ * @return the number of text item identifiers that were returned.
+ */
+LIBHEIF_API
+int heif_image_handle_get_list_of_text_item_ids(const heif_image_handle* image_handle,
+                                                heif_item_id* text_item_ids_array,
+                                                int max_count);
+
+
+/**
+ * Get the text item.
+ *
+ * Caller is responsible for release of the output heif_text_item with heif_text_item_release().
+ *
+ * @param context the context to get the text item from, usually from a file operation
+ * @param text_item_id the identifier for the text item
+ * @param out pointer to pointer to the resulting text item
+ * @return heif_error_ok on success, or an error value indicating the problem
+ */
+LIBHEIF_API
+heif_error heif_context_get_text_item(const heif_context* context,
+                                      heif_item_id text_item_id,
+                                      heif_text_item** out);
+
+/**
+ * Get the item identifier for a text item.
+ *
+ * @param text_item the text item to query
+ * @return the text item identifier (or 0 if the text_item is null)
+ */
+LIBHEIF_API
+heif_item_id heif_text_item_get_id(heif_text_item* text_item);
+
+/**
+ * Get the item content for a text item.
+ *
+ * This is the payload text, in the format given by the associated content_type.
+ *
+ * @param text_item the text item to query
+ * @return the text item content (or null if the text_item is null). The returned string shall be released
+ * with heif_string_release().
+ */
+LIBHEIF_API
+const char* heif_text_item_get_content(heif_text_item* text_item);
+
+/**
+ * This function is similar to heif_item_get_property_extended_language(), but
+ * takes a `heif_text_item` as parameter.
+ *
+ * @param text_item The text item for which we are requesting the language.
+ * @param out_language Output parameter for the text language. Free with heif_string_release().
+ * @return
+ */
+LIBHEIF_API
+heif_error heif_text_item_get_property_extended_language(const heif_text_item* text_item,
+                                                         char** out_language);
+
+// --- adding text items
+
+/**
+ * Add a text item to an image.
+*/
+LIBHEIF_API
+heif_error heif_image_handle_add_text_item(heif_image_handle *image_handle,
+                                           const char *content_type,
+                                           const char *text,
+                                           heif_text_item** out_text_item);
+
+/**
+ * Release a text item.
+ *
+ * This should be called on items from heif_context_add_text_item().
+ *
+ * @param text_item the item to release.
+ */
+LIBHEIF_API
+void heif_text_item_release(heif_text_item* text_item);
+
+/**
+ * Set the extended language property to the text item.
+ *
+ * This adds an RFC 5346 (IETF BCP 47) extended language tag, such as "en-AU".
+ *
+ * @param text_item the text item to query
+ * @param language the language to set
+ * @param out_optional_propertyId Output parameter for the property ID of the language property.
+ *                                This parameter may be NULL if the info is not required.
+ * @return heif_error_ok on success, or an error value indicating the problem
+ */
+LIBHEIF_API
+heif_error heif_text_item_set_extended_language(heif_text_item* text_item,
+                                                const char *language,
+                                                heif_property_id* out_optional_propertyId);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/libheif/api/libheif/heif_tiling.cc b/libheif/api/libheif/heif_tiling.cc
new file mode 100644
index 0000000000..4b874e819a
--- /dev/null
+++ b/libheif/api/libheif/heif_tiling.cc
@@ -0,0 +1,279 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017-2025 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "heif_tiling.h"
+#include "api_structs.h"
+#include "image-items/grid.h"
+#include "image-items/tiled.h"
+
+#if WITH_UNCOMPRESSED_CODEC
+#include "image-items/unc_image.h"
+#endif
+
+#include <memory>
+#include <utility>
+#include <vector>
+#include <array>
+
+
+heif_error heif_image_handle_get_image_tiling(const heif_image_handle* handle, int process_image_transformations, struct heif_image_tiling* tiling)
+{
+  if (!handle || !tiling) {
+    return heif_error_null_pointer_argument;
+  }
+
+  *tiling = handle->image->get_heif_image_tiling();
+
+  if (process_image_transformations) {
+    Error error = handle->image->process_image_transformations_on_tiling(*tiling);
+    if (error) {
+      return error.error_struct(handle->context.get());
+    }
+  }
+
+  return heif_error_ok;
+}
+
+
+heif_error heif_image_handle_get_grid_image_tile_id(const heif_image_handle* handle,
+                                                    int process_image_transformations,
+                                                    uint32_t tile_x, uint32_t tile_y,
+                                                    heif_item_id* tile_item_id)
+{
+  if (!handle || !tile_item_id) {
+    return heif_error_null_pointer_argument;
+  }
+
+  std::shared_ptr<ImageItem_Grid> gridItem = std::dynamic_pointer_cast<ImageItem_Grid>(handle->image);
+  if (!gridItem) {
+    return {
+      heif_error_Usage_error,
+      heif_suberror_Unspecified,
+      "Image is no grid image"
+    };
+  }
+
+  const ImageGrid& gridspec = gridItem->get_grid_spec();
+  if (tile_x >= gridspec.get_columns() || tile_y >= gridspec.get_rows()) {
+    return {
+      heif_error_Usage_error,
+      heif_suberror_Unspecified,
+      "Grid tile index out of range"
+    };
+  }
+
+  if (process_image_transformations) {
+    gridItem->transform_requested_tile_position_to_original_tile_position(tile_x, tile_y);
+  }
+
+  *tile_item_id = gridItem->get_grid_tiles()[tile_y * gridspec.get_columns() + tile_x];
+
+  return heif_error_ok;
+}
+
+
+heif_error heif_image_handle_decode_image_tile(const heif_image_handle* in_handle,
+                                               heif_image** out_img,
+                                               heif_colorspace colorspace,
+                                               heif_chroma chroma,
+                                               const heif_decoding_options* input_options,
+                                               uint32_t x0, uint32_t y0)
+{
+  if (!in_handle) {
+    return heif_error_null_pointer_argument;
+  }
+
+  heif_item_id id = in_handle->image->get_id();
+
+  heif_decoding_options* dec_options = heif_decoding_options_alloc();
+  heif_decoding_options_copy(dec_options, input_options);
+
+  Result<std::shared_ptr<HeifPixelImage> > decodingResult = in_handle->context->decode_image(id,
+                                                                                             colorspace,
+                                                                                             chroma,
+                                                                                             *dec_options,
+                                                                                             true, x0, y0,
+                                                                                             {});
+  heif_decoding_options_free(dec_options);
+
+  if (!decodingResult) {
+    return decodingResult.error_struct(in_handle->image.get());
+  }
+
+  std::shared_ptr<HeifPixelImage> img = *decodingResult;
+
+  *out_img = new heif_image();
+  (*out_img)->image = std::move(img);
+
+  return Error::Ok.error_struct(in_handle->image.get());
+}
+
+
+// --- encoding ---
+
+heif_error heif_context_encode_grid(heif_context* ctx,
+                                    heif_image** tiles,
+                                    uint16_t columns,
+                                    uint16_t rows,
+                                    heif_encoder* encoder,
+                                    const heif_encoding_options* input_options,
+                                    heif_image_handle** out_image_handle)
+{
+  if (!encoder || !tiles) {
+    return heif_error_null_pointer_argument;
+  }
+  else if (rows == 0 || columns == 0) {
+    return Error(heif_error_Usage_error,
+                 heif_suberror_Invalid_parameter_value).error_struct(ctx->context.get());
+  }
+
+  // TODO: Don't repeat this code from heif_context_encode_image()
+  heif_encoding_options* options = heif_encoding_options_alloc();
+
+  heif_color_profile_nclx nclx;
+  if (input_options) {
+    heif_encoding_options_copy(options, input_options);
+
+    if (options->output_nclx_profile == nullptr) {
+      if (tiles[0]->image->has_nclx_color_profile()) {
+        nclx_profile input_nclx = tiles[0]->image->get_color_profile_nclx();
+
+        options->output_nclx_profile = &nclx;
+        nclx.version = 1;
+        nclx.color_primaries = input_nclx.get_colour_primaries();
+        nclx.transfer_characteristics = input_nclx.get_transfer_characteristics();
+        nclx.matrix_coefficients = input_nclx.get_matrix_coefficients();
+        nclx.full_range_flag = input_nclx.get_full_range_flag();
+      }
+    }
+  }
+
+  // Convert heif_images to a vector of HeifPixelImages
+  std::vector<std::shared_ptr<HeifPixelImage> > pixel_tiles;
+  for (int i = 0; i < rows * columns; i++) {
+    pixel_tiles.push_back(tiles[i]->image);
+  }
+
+  // Encode Grid
+  std::shared_ptr<ImageItem> out_grid;
+  auto addGridResult = ImageItem_Grid::add_and_encode_full_grid(ctx->context.get(),
+                                                                pixel_tiles,
+                                                                rows, columns,
+                                                                encoder,
+                                                                *options);
+  heif_encoding_options_free(options);
+
+  if (!addGridResult) {
+    return addGridResult.error_struct(ctx->context.get());
+  }
+
+  out_grid = *addGridResult;
+
+  // Mark as primary image
+  if (ctx->context->is_primary_image_set() == false) {
+    ctx->context->set_primary_image(out_grid);
+  }
+
+  if (out_image_handle) {
+    *out_image_handle = new heif_image_handle;
+    (*out_image_handle)->image = std::move(out_grid);
+    (*out_image_handle)->context = ctx->context;
+  }
+
+  return heif_error_success;
+}
+
+
+heif_error heif_context_add_grid_image(heif_context* ctx,
+                                       uint32_t image_width,
+                                       uint32_t image_height,
+                                       uint32_t tile_columns,
+                                       uint32_t tile_rows,
+                                       const heif_encoding_options* encoding_options,
+                                       heif_image_handle** out_grid_image_handle)
+{
+  if (!ctx) {
+    return heif_error_null_pointer_argument;
+  }
+
+  if (tile_rows == 0 || tile_columns == 0) {
+    return Error(heif_error_Usage_error,
+                 heif_suberror_Invalid_parameter_value).error_struct(ctx->context.get());
+  }
+  else if (tile_rows > 0xFFFF || tile_columns > 0xFFFF) {
+    return heif_error{
+      heif_error_Usage_error,
+      heif_suberror_Invalid_image_size,
+      "Number of tile rows/columns may not exceed 65535"
+    };
+  }
+
+  auto generateGridItemResult = ImageItem_Grid::add_new_grid_item(ctx->context.get(),
+                                                                  image_width,
+                                                                  image_height,
+                                                                  static_cast<uint16_t>(tile_rows),
+                                                                  static_cast<uint16_t>(tile_columns),
+                                                                  encoding_options);
+  if (!generateGridItemResult) {
+    return generateGridItemResult.error_struct(ctx->context.get());
+  }
+
+  if (out_grid_image_handle) {
+    *out_grid_image_handle = new heif_image_handle;
+    (*out_grid_image_handle)->image = *generateGridItemResult;
+    (*out_grid_image_handle)->context = ctx->context;
+  }
+
+  return heif_error_success;
+}
+
+
+heif_error heif_context_add_image_tile(heif_context* ctx,
+                                       heif_image_handle* tiled_image,
+                                       uint32_t tile_x, uint32_t tile_y,
+                                       const heif_image* image,
+                                       heif_encoder* encoder)
+{
+  if (!ctx || !tiled_image || !image || !encoder) {
+    return heif_error_null_pointer_argument;
+  }
+
+  if (auto tili_image = std::dynamic_pointer_cast<ImageItem_Tiled>(tiled_image->image)) {
+    Error err = tili_image->add_image_tile(tile_x, tile_y, image->image, encoder);
+    return err.error_struct(ctx->context.get());
+  }
+#if WITH_UNCOMPRESSED_CODEC
+  else if (auto unci = std::dynamic_pointer_cast<ImageItem_uncompressed>(tiled_image->image)) {
+    Error err = unci->add_image_tile(tile_x, tile_y, image->image, true); // TODO: how do we handle 'save_alpha=false' ?
+    return err.error_struct(ctx->context.get());
+  }
+#endif
+  else if (auto grid_item = std::dynamic_pointer_cast<ImageItem_Grid>(tiled_image->image)) {
+    Error err = grid_item->add_image_tile(tile_x, tile_y, image->image, encoder);
+    return err.error_struct(ctx->context.get());
+  }
+  else {
+    return {
+      heif_error_Usage_error,
+      heif_suberror_Unspecified,
+      "Cannot add tile to a non-tiled image"
+    };
+  }
+}
diff --git a/libheif/api/libheif/heif_tiling.h b/libheif/api/libheif/heif_tiling.h
new file mode 100644
index 0000000000..bc3f038a30
--- /dev/null
+++ b/libheif/api/libheif/heif_tiling.h
@@ -0,0 +1,137 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017-2025 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_HEIF_TILING_H
+#define LIBHEIF_HEIF_TILING_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <libheif/heif_library.h>
+#include <libheif/heif_error.h>
+#include <libheif/heif_image.h>
+
+// forward declaration from other headers
+typedef struct heif_encoder heif_encoder;
+typedef struct heif_encoding_options heif_encoding_options;
+
+
+typedef struct heif_image_tiling
+{
+  int version;
+
+  // --- version 1
+
+  uint32_t num_columns;
+  uint32_t num_rows;
+  uint32_t tile_width;
+  uint32_t tile_height;
+
+  uint32_t image_width;
+  uint32_t image_height;
+
+  // Position of the top left tile.
+  // Usually, this is (0;0), but if a tiled image is rotated or cropped, it may be that the top left tile should be placed at a negative position.
+  // The offsets define this negative shift.
+  uint32_t top_offset;
+  uint32_t left_offset;
+
+  uint8_t number_of_extra_dimensions;  // 0 for normal images, 1 for volumetric (3D), ...
+  uint32_t extra_dimension_size[8];    // size of extra dimensions (first 8 dimensions)
+} heif_image_tiling;
+
+
+// --- decoding ---
+
+// If 'process_image_transformations' is true, this returns modified sizes.
+// If it is false, the top_offset and left_offset will always be (0;0).
+LIBHEIF_API
+heif_error heif_image_handle_get_image_tiling(const heif_image_handle* handle, int process_image_transformations, struct heif_image_tiling* out_tiling);
+
+
+// For grid images, return the image item ID of a specific grid tile.
+// If 'process_image_transformations' is true, the tile positions are given in the transformed image coordinate system and
+// are internally mapped to the original image tile positions.
+LIBHEIF_API
+heif_error heif_image_handle_get_grid_image_tile_id(const heif_image_handle* handle,
+                                                    int process_image_transformations,
+                                                    uint32_t tile_x, uint32_t tile_y,
+                                                    heif_item_id* out_tile_item_id);
+
+
+typedef struct heif_decoding_options heif_decoding_options;
+
+// The tile position is given in tile indices, not in pixel coordinates.
+// If the image transformations are processed (option->ignore_image_transformations==false), the tile position
+// is given in the transformed coordinates.
+LIBHEIF_API
+heif_error heif_image_handle_decode_image_tile(const heif_image_handle* in_handle,
+                                               heif_image** out_img,
+                                               enum heif_colorspace colorspace,
+                                               enum heif_chroma chroma,
+                                               const heif_decoding_options* options,
+                                               uint32_t tile_x, uint32_t tile_y);
+
+
+// --- encoding ---
+
+/**
+ * @brief Encodes an array of images into a grid.
+ *
+ * @param ctx The file context
+ * @param tiles User allocated array of images that will form the grid.
+ * @param rows The number of rows in the grid.
+ * @param columns The number of columns in the grid.
+ * @param encoder Defines the encoder to use. See heif_context_get_encoder_for_format()
+ * @param input_options Optional, may be nullptr.
+ * @param out_image_handle Returns a handle to the grid. The caller is responsible for freeing it.
+ * @return Returns an error if ctx, tiles, or encoder is nullptr. If rows or columns is 0.
+ */
+LIBHEIF_API
+heif_error heif_context_encode_grid(heif_context* ctx,
+                                    heif_image** tiles,
+                                    uint16_t rows,
+                                    uint16_t columns,
+                                    heif_encoder* encoder,
+                                    const heif_encoding_options* input_options,
+                                    heif_image_handle** out_image_handle);
+
+LIBHEIF_API
+heif_error heif_context_add_grid_image(heif_context* ctx,
+                                       uint32_t image_width,
+                                       uint32_t image_height,
+                                       uint32_t tile_columns,
+                                       uint32_t tile_rows,
+                                       const heif_encoding_options* encoding_options,
+                                       heif_image_handle** out_grid_image_handle);
+
+LIBHEIF_API
+heif_error heif_context_add_image_tile(heif_context* ctx,
+                                       heif_image_handle* tiled_image,
+                                       uint32_t tile_x, uint32_t tile_y,
+                                       const heif_image* image,
+                                       heif_encoder* encoder);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/libheif/api/libheif/heif_uncompressed.cc b/libheif/api/libheif/heif_uncompressed.cc
new file mode 100644
index 0000000000..22ea296b59
--- /dev/null
+++ b/libheif/api/libheif/heif_uncompressed.cc
@@ -0,0 +1,822 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "heif_uncompressed.h"
+#include "context.h"
+#include "api_structs.h"
+#include "pixelimage.h"
+#include "image-items/unc_image.h"
+
+#include <array>
+#include <cstring>
+#include <memory>
+#include <algorithm>
+
+
+heif_error heif_image_set_bayer_pattern(heif_image* image,
+                                        uint16_t pattern_width,
+                                        uint16_t pattern_height,
+                                        const struct heif_bayer_pattern_pixel* patternPixels)
+{
+  if (image == nullptr || patternPixels == nullptr) {
+    return heif_error_null_pointer_argument;
+  }
+
+  if (pattern_width == 0 || pattern_height == 0) {
+    return {heif_error_Usage_error,
+            heif_suberror_Invalid_parameter_value,
+            "Bayer pattern dimensions must be non-zero."};
+  }
+
+  BayerPattern pattern;
+  pattern.pattern_width = pattern_width;
+  pattern.pattern_height = pattern_height;
+
+  size_t num_pixels = size_t{pattern_width} * pattern_height;
+  pattern.pixels.assign(patternPixels, patternPixels + num_pixels);
+
+  image->image->set_bayer_pattern(pattern);
+
+  return heif_error_success;
+}
+
+
+int heif_image_has_bayer_pattern(const heif_image* image,
+                                 uint16_t* out_pattern_width,
+                                 uint16_t* out_pattern_height)
+{
+  if (image == nullptr || !image->image->has_bayer_pattern()) {
+    if (out_pattern_width) {
+      *out_pattern_width = 0;
+    }
+    if (out_pattern_height) {
+      *out_pattern_height = 0;
+    }
+    return 0;
+  }
+
+  const BayerPattern& pattern = image->image->get_bayer_pattern();
+
+  if (out_pattern_width) {
+    *out_pattern_width = pattern.pattern_width;
+  }
+  if (out_pattern_height) {
+    *out_pattern_height = pattern.pattern_height;
+  }
+
+  return 1;
+}
+
+
+heif_error heif_image_get_bayer_pattern(const heif_image* image,
+                                        struct heif_bayer_pattern_pixel* out_patternPixels)
+{
+  if (image == nullptr || out_patternPixels == nullptr) {
+    return heif_error_null_pointer_argument;
+  }
+
+  if (!image->image->has_bayer_pattern()) {
+    return {heif_error_Usage_error,
+            heif_suberror_Invalid_parameter_value,
+            "Image does not have a Bayer pattern."};
+  }
+
+  const BayerPattern& pattern = image->image->get_bayer_pattern();
+  size_t num_pixels = size_t{pattern.pattern_width} * pattern.pattern_height;
+  std::copy(pattern.pixels.begin(), pattern.pixels.begin() + num_pixels, out_patternPixels);
+
+  return heif_error_success;
+}
+
+
+float heif_polarization_angle_no_filter()
+{
+  uint32_t bits = 0xFFFFFFFF;
+  float f;
+  memcpy(&f, &bits, sizeof(f));
+  return f;
+}
+
+
+int heif_polarization_angle_is_no_filter(float angle)
+{
+  uint32_t bits;
+  memcpy(&bits, &angle, sizeof(bits));
+  return bits == 0xFFFFFFFF;
+}
+
+
+heif_error heif_image_add_polarization_pattern(heif_image* image,
+                                               uint32_t num_component_indices,
+                                               const uint32_t* component_indices,
+                                               uint16_t pattern_width,
+                                               uint16_t pattern_height,
+                                               const float* polarization_angles)
+{
+  if (image == nullptr || polarization_angles == nullptr) {
+    return heif_error_null_pointer_argument;
+  }
+
+  if (num_component_indices > 0 && component_indices == nullptr) {
+    return heif_error_null_pointer_argument;
+  }
+
+  if (pattern_width == 0 || pattern_height == 0) {
+    return {heif_error_Usage_error,
+            heif_suberror_Invalid_parameter_value,
+            "Polarization pattern dimensions must be non-zero."};
+  }
+
+  PolarizationPattern pattern;
+  pattern.component_indices.assign(component_indices, component_indices + num_component_indices);
+  pattern.pattern_width = pattern_width;
+  pattern.pattern_height = pattern_height;
+
+  size_t num_pixels = size_t{pattern_width} * pattern_height;
+  pattern.polarization_angles.assign(polarization_angles, polarization_angles + num_pixels);
+
+  image->image->add_polarization_pattern(pattern);
+
+  return heif_error_success;
+}
+
+
+int heif_image_get_number_of_polarization_patterns(const heif_image* image)
+{
+  if (image == nullptr) {
+    return 0;
+  }
+
+  return static_cast<int>(image->image->get_polarization_patterns().size());
+}
+
+
+heif_error heif_image_get_polarization_pattern_info(const heif_image* image,
+                                                    int pattern_index,
+                                                    uint32_t* out_num_component_indices,
+                                                    uint16_t* out_pattern_width,
+                                                    uint16_t* out_pattern_height)
+{
+  if (image == nullptr) {
+    return heif_error_null_pointer_argument;
+  }
+
+  const auto& patterns = image->image->get_polarization_patterns();
+  if (pattern_index < 0 || static_cast<size_t>(pattern_index) >= patterns.size()) {
+    return {heif_error_Usage_error,
+            heif_suberror_Invalid_parameter_value,
+            "Polarization pattern index out of range."};
+  }
+
+  const auto& p = patterns[pattern_index];
+  if (out_num_component_indices) {
+    *out_num_component_indices = static_cast<uint32_t>(p.component_indices.size());
+  }
+  if (out_pattern_width) {
+    *out_pattern_width = p.pattern_width;
+  }
+  if (out_pattern_height) {
+    *out_pattern_height = p.pattern_height;
+  }
+
+  return heif_error_success;
+}
+
+
+heif_error heif_image_get_polarization_pattern_data(const heif_image* image,
+                                                    int pattern_index,
+                                                    uint32_t* out_component_indices,
+                                                    float* out_polarization_angles)
+{
+  if (image == nullptr || out_polarization_angles == nullptr) {
+    return heif_error_null_pointer_argument;
+  }
+
+  const auto& patterns = image->image->get_polarization_patterns();
+  if (pattern_index < 0 || static_cast<size_t>(pattern_index) >= patterns.size()) {
+    return {heif_error_Usage_error,
+            heif_suberror_Invalid_parameter_value,
+            "Polarization pattern index out of range."};
+  }
+
+  const auto& p = patterns[pattern_index];
+
+  if (out_component_indices && !p.component_indices.empty()) {
+    std::copy(p.component_indices.begin(), p.component_indices.end(), out_component_indices);
+  }
+
+  size_t num_pixels = size_t{p.pattern_width} * p.pattern_height;
+  std::copy(p.polarization_angles.begin(), p.polarization_angles.begin() + num_pixels, out_polarization_angles);
+
+  return heif_error_success;
+}
+
+
+int heif_image_get_polarization_pattern_index_for_component(const heif_image* image,
+                                                            uint32_t component_index)
+{
+  if (image == nullptr) {
+    return -1;
+  }
+
+  const auto& patterns = image->image->get_polarization_patterns();
+  for (size_t i = 0; i < patterns.size(); i++) {
+    const auto& p = patterns[i];
+    if (p.component_indices.empty()) {
+      // Empty component list means pattern applies to all components.
+      return static_cast<int>(i);
+    }
+    for (uint32_t idx : p.component_indices) {
+      if (idx == component_index) {
+        return static_cast<int>(i);
+      }
+    }
+  }
+
+  return -1;
+}
+
+
+heif_error heif_image_add_sensor_bad_pixels_map(heif_image* image,
+                                                 uint32_t num_component_indices,
+                                                 const uint32_t* component_indices,
+                                                 int correction_applied,
+                                                 uint32_t num_bad_rows,
+                                                 const uint32_t* bad_rows,
+                                                 uint32_t num_bad_columns,
+                                                 const uint32_t* bad_columns,
+                                                 uint32_t num_bad_pixels,
+                                                 const struct heif_bad_pixel* bad_pixels)
+{
+  if (image == nullptr) {
+    return heif_error_null_pointer_argument;
+  }
+
+  if (num_component_indices > 0 && component_indices == nullptr) {
+    return heif_error_null_pointer_argument;
+  }
+
+  if (num_bad_rows > 0 && bad_rows == nullptr) {
+    return heif_error_null_pointer_argument;
+  }
+
+  if (num_bad_columns > 0 && bad_columns == nullptr) {
+    return heif_error_null_pointer_argument;
+  }
+
+  if (num_bad_pixels > 0 && bad_pixels == nullptr) {
+    return heif_error_null_pointer_argument;
+  }
+
+  SensorBadPixelsMap map;
+  map.component_indices.assign(component_indices, component_indices + num_component_indices);
+  map.correction_applied = (correction_applied != 0);
+
+  map.bad_rows.assign(bad_rows, bad_rows + num_bad_rows);
+  map.bad_columns.assign(bad_columns, bad_columns + num_bad_columns);
+
+  map.bad_pixels.resize(num_bad_pixels);
+  for (uint32_t i = 0; i < num_bad_pixels; i++) {
+    map.bad_pixels[i].row = bad_pixels[i].row;
+    map.bad_pixels[i].column = bad_pixels[i].column;
+  }
+
+  image->image->add_sensor_bad_pixels_map(map);
+
+  return heif_error_success;
+}
+
+
+int heif_image_get_number_of_sensor_bad_pixels_maps(const heif_image* image)
+{
+  if (image == nullptr) {
+    return 0;
+  }
+
+  return static_cast<int>(image->image->get_sensor_bad_pixels_maps().size());
+}
+
+
+heif_error heif_image_get_sensor_bad_pixels_map_info(const heif_image* image,
+                                                      int map_index,
+                                                      uint32_t* out_num_component_indices,
+                                                      int* out_correction_applied,
+                                                      uint32_t* out_num_bad_rows,
+                                                      uint32_t* out_num_bad_columns,
+                                                      uint32_t* out_num_bad_pixels)
+{
+  if (image == nullptr) {
+    return heif_error_null_pointer_argument;
+  }
+
+  const auto& maps = image->image->get_sensor_bad_pixels_maps();
+  if (map_index < 0 || static_cast<size_t>(map_index) >= maps.size()) {
+    return {heif_error_Usage_error,
+            heif_suberror_Invalid_parameter_value,
+            "Sensor bad pixels map index out of range."};
+  }
+
+  const auto& m = maps[map_index];
+  if (out_num_component_indices) {
+    *out_num_component_indices = static_cast<uint32_t>(m.component_indices.size());
+  }
+  if (out_correction_applied) {
+    *out_correction_applied = m.correction_applied ? 1 : 0;
+  }
+  if (out_num_bad_rows) {
+    *out_num_bad_rows = static_cast<uint32_t>(m.bad_rows.size());
+  }
+  if (out_num_bad_columns) {
+    *out_num_bad_columns = static_cast<uint32_t>(m.bad_columns.size());
+  }
+  if (out_num_bad_pixels) {
+    *out_num_bad_pixels = static_cast<uint32_t>(m.bad_pixels.size());
+  }
+
+  return heif_error_success;
+}
+
+
+heif_error heif_image_get_sensor_bad_pixels_map_data(const heif_image* image,
+                                                      int map_index,
+                                                      uint32_t* out_component_indices,
+                                                      uint32_t* out_bad_rows,
+                                                      uint32_t* out_bad_columns,
+                                                      struct heif_bad_pixel* out_bad_pixels)
+{
+  if (image == nullptr) {
+    return heif_error_null_pointer_argument;
+  }
+
+  const auto& maps = image->image->get_sensor_bad_pixels_maps();
+  if (map_index < 0 || static_cast<size_t>(map_index) >= maps.size()) {
+    return {heif_error_Usage_error,
+            heif_suberror_Invalid_parameter_value,
+            "Sensor bad pixels map index out of range."};
+  }
+
+  const auto& m = maps[map_index];
+
+  if (out_component_indices && !m.component_indices.empty()) {
+    std::copy(m.component_indices.begin(), m.component_indices.end(), out_component_indices);
+  }
+
+  if (out_bad_rows && !m.bad_rows.empty()) {
+    std::copy(m.bad_rows.begin(), m.bad_rows.end(), out_bad_rows);
+  }
+
+  if (out_bad_columns && !m.bad_columns.empty()) {
+    std::copy(m.bad_columns.begin(), m.bad_columns.end(), out_bad_columns);
+  }
+
+  if (out_bad_pixels && !m.bad_pixels.empty()) {
+    for (size_t i = 0; i < m.bad_pixels.size(); i++) {
+      out_bad_pixels[i].row = m.bad_pixels[i].row;
+      out_bad_pixels[i].column = m.bad_pixels[i].column;
+    }
+  }
+
+  return heif_error_success;
+}
+
+
+heif_error heif_image_add_sensor_nuc(heif_image* image,
+                                      uint32_t num_component_indices,
+                                      const uint32_t* component_indices,
+                                      int nuc_is_applied,
+                                      uint32_t image_width,
+                                      uint32_t image_height,
+                                      const float* nuc_gains,
+                                      const float* nuc_offsets)
+{
+  if (image == nullptr || nuc_gains == nullptr || nuc_offsets == nullptr) {
+    return heif_error_null_pointer_argument;
+  }
+
+  if (num_component_indices > 0 && component_indices == nullptr) {
+    return heif_error_null_pointer_argument;
+  }
+
+  if (image_width == 0 || image_height == 0) {
+    return {heif_error_Usage_error,
+            heif_suberror_Invalid_parameter_value,
+            "NUC image dimensions must be non-zero."};
+  }
+
+  SensorNonUniformityCorrection nuc;
+  nuc.component_indices.assign(component_indices, component_indices + num_component_indices);
+  nuc.nuc_is_applied = (nuc_is_applied != 0);
+  nuc.image_width = image_width;
+  nuc.image_height = image_height;
+
+  size_t num_pixels = size_t{image_width} * image_height;
+  nuc.nuc_gains.assign(nuc_gains, nuc_gains + num_pixels);
+  nuc.nuc_offsets.assign(nuc_offsets, nuc_offsets + num_pixels);
+
+  image->image->add_sensor_nuc(nuc);
+
+  return heif_error_success;
+}
+
+
+int heif_image_get_number_of_sensor_nucs(const heif_image* image)
+{
+  if (image == nullptr) {
+    return 0;
+  }
+
+  return static_cast<int>(image->image->get_sensor_nuc().size());
+}
+
+
+heif_error heif_image_get_sensor_nuc_info(const heif_image* image,
+                                           int nuc_index,
+                                           uint32_t* out_num_component_indices,
+                                           int* out_nuc_is_applied,
+                                           uint32_t* out_image_width,
+                                           uint32_t* out_image_height)
+{
+  if (image == nullptr) {
+    return heif_error_null_pointer_argument;
+  }
+
+  const auto& nucs = image->image->get_sensor_nuc();
+  if (nuc_index < 0 || static_cast<size_t>(nuc_index) >= nucs.size()) {
+    return {heif_error_Usage_error,
+            heif_suberror_Invalid_parameter_value,
+            "Sensor NUC index out of range."};
+  }
+
+  const auto& n = nucs[nuc_index];
+  if (out_num_component_indices) {
+    *out_num_component_indices = static_cast<uint32_t>(n.component_indices.size());
+  }
+  if (out_nuc_is_applied) {
+    *out_nuc_is_applied = n.nuc_is_applied ? 1 : 0;
+  }
+  if (out_image_width) {
+    *out_image_width = n.image_width;
+  }
+  if (out_image_height) {
+    *out_image_height = n.image_height;
+  }
+
+  return heif_error_success;
+}
+
+
+heif_error heif_image_get_sensor_nuc_data(const heif_image* image,
+                                           int nuc_index,
+                                           uint32_t* out_component_indices,
+                                           float* out_nuc_gains,
+                                           float* out_nuc_offsets)
+{
+  if (image == nullptr) {
+    return heif_error_null_pointer_argument;
+  }
+
+  const auto& nucs = image->image->get_sensor_nuc();
+  if (nuc_index < 0 || static_cast<size_t>(nuc_index) >= nucs.size()) {
+    return {heif_error_Usage_error,
+            heif_suberror_Invalid_parameter_value,
+            "Sensor NUC index out of range."};
+  }
+
+  const auto& n = nucs[nuc_index];
+
+  if (out_component_indices && !n.component_indices.empty()) {
+    std::copy(n.component_indices.begin(), n.component_indices.end(), out_component_indices);
+  }
+
+  size_t num_pixels = size_t{n.image_width} * n.image_height;
+
+  if (out_nuc_gains && !n.nuc_gains.empty()) {
+    std::copy(n.nuc_gains.begin(), n.nuc_gains.begin() + num_pixels, out_nuc_gains);
+  }
+
+  if (out_nuc_offsets && !n.nuc_offsets.empty()) {
+    std::copy(n.nuc_offsets.begin(), n.nuc_offsets.begin() + num_pixels, out_nuc_offsets);
+  }
+
+  return heif_error_success;
+}
+
+
+heif_error heif_image_set_chroma_location(heif_image* image, uint8_t chroma_location)
+{
+  if (image == nullptr) {
+    return heif_error_null_pointer_argument;
+  }
+
+  if (chroma_location > 6) {
+    return {heif_error_Usage_error,
+            heif_suberror_Invalid_parameter_value,
+            "Chroma location must be in the range 0-6."};
+  }
+
+  image->image->set_chroma_location(chroma_location);
+
+  return heif_error_success;
+}
+
+
+int heif_image_has_chroma_location(const heif_image* image)
+{
+  if (image == nullptr) {
+    return 0;
+  }
+
+  return image->image->has_chroma_location() ? 1 : 0;
+}
+
+
+uint8_t heif_image_get_chroma_location(const heif_image* image)
+{
+  if (image == nullptr) {
+    return 0;
+  }
+
+  return image->image->get_chroma_location();
+}
+
+
+heif_unci_image_parameters* heif_unci_image_parameters_alloc()
+{
+  auto* params = new heif_unci_image_parameters();
+
+  params->version = 1;
+
+  // --- version 1
+
+  params->image_width = 0;
+  params->image_height = 0;
+
+  // TODO: should we define that tile size = 0 means no tiling?
+  params->tile_width = 0;
+  params->tile_height = 0;
+
+  params->compression = heif_unci_compression_off;
+
+  return params;
+}
+
+
+void heif_unci_image_parameters_copy(heif_unci_image_parameters* dst,
+                                     const heif_unci_image_parameters* src)
+{
+  if (src == nullptr || dst == nullptr) {
+    return;
+  }
+
+  int min_version = std::min(src->version, dst->version);
+
+  switch (min_version) {
+    case 1:
+      dst->image_width = src->image_width;
+      dst->image_height = src->image_height;
+      dst->tile_width = src->tile_width;
+      dst->tile_height = src->tile_height;
+      dst->compression = src->compression;
+      break;
+  }
+}
+
+
+void heif_unci_image_parameters_release(heif_unci_image_parameters* params)
+{
+  delete params;
+}
+
+
+// --- index-based component access
+
+uint32_t heif_image_get_number_of_used_components(const heif_image* image)
+{
+  if (!image || !image->image) {
+    return 0;
+  }
+  return image->image->get_number_of_used_components();
+}
+
+
+uint32_t heif_image_get_total_number_of_cmpd_components(const heif_image* image)
+{
+  if (!image || !image->image) {
+    return 0;
+  }
+  return image->image->get_total_number_of_cmpd_components();
+}
+
+
+void heif_image_get_used_component_indices(const heif_image* image, uint32_t* out_component_indices)
+{
+  if (!image || !image->image || !out_component_indices) {
+    return;
+  }
+
+  auto indices = image->image->get_used_component_indices();
+  for (size_t i = 0; i < indices.size(); i++) {
+    out_component_indices[i] = indices[i];
+  }
+}
+
+
+heif_channel heif_image_get_component_channel(const heif_image* image, uint32_t component_idx)
+{
+  if (!image || !image->image) {
+    return heif_channel_Y;
+  }
+  return image->image->get_component_channel(component_idx);
+}
+
+
+uint32_t heif_image_get_component_width(const heif_image* image, uint32_t component_idx)
+{
+  if (!image || !image->image) {
+    return 0;
+  }
+  return image->image->get_component_width(component_idx);
+}
+
+
+uint32_t heif_image_get_component_height(const heif_image* image, uint32_t component_idx)
+{
+  if (!image || !image->image) {
+    return 0;
+  }
+  return image->image->get_component_height(component_idx);
+}
+
+
+int heif_image_get_component_bits_per_pixel(const heif_image* image, uint32_t component_idx)
+{
+  if (!image || !image->image) {
+    return 0;
+  }
+  return image->image->get_component_bits_per_pixel(component_idx);
+}
+
+
+uint16_t heif_image_get_component_type(const heif_image* image, uint32_t component_idx)
+{
+  if (!image || !image->image) {
+    return 0;
+  }
+  return image->image->get_component_type(component_idx);
+}
+
+
+heif_error heif_image_add_component(heif_image* image,
+                                    int width, int height,
+                                    uint16_t component_type,
+                                    heif_channel_datatype datatype,
+                                    int bit_depth,
+                                    uint32_t* out_component_idx)
+{
+  if (!image || !image->image) {
+    return heif_error_null_pointer_argument;
+  }
+
+  auto result = image->image->add_component(width, height, component_type, datatype, bit_depth, nullptr);
+  if (!result) {
+    return result.error_struct(image->image.get());
+  }
+
+  if (out_component_idx) {
+    *out_component_idx = *result;
+  }
+
+  return heif_error_success;
+}
+
+
+const uint8_t* heif_image_get_component_readonly(const heif_image* image, uint32_t component_idx, size_t* out_stride)
+{
+  if (!image || !image->image) {
+    if (out_stride) *out_stride = 0;
+    return nullptr;
+  }
+  return image->image->get_component(component_idx, out_stride);
+}
+
+
+uint8_t* heif_image_get_component(heif_image* image, uint32_t component_idx, size_t* out_stride)
+{
+  if (!image || !image->image) {
+    if (out_stride) *out_stride = 0;
+    return nullptr;
+  }
+  return image->image->get_component(component_idx, out_stride);
+}
+
+
+#define heif_image_get_component_X(name, type) \
+const type* heif_image_get_component_ ## name ## _readonly(const struct heif_image* image, \
+                                                            uint32_t component_idx, \
+                                                            size_t* out_stride) \
+{                                                            \
+  if (!image || !image->image) {                             \
+    if (out_stride) *out_stride = 0;                         \
+    return nullptr;                                          \
+  }                                                          \
+  return image->image->get_component_data<type>(component_idx, out_stride); \
+}                                                            \
+                                                             \
+type* heif_image_get_component_ ## name (struct heif_image* image, \
+                                         uint32_t component_idx,  \
+                                         size_t* out_stride)      \
+{                                                            \
+  if (!image || !image->image) {                             \
+    if (out_stride) *out_stride = 0;                         \
+    return nullptr;                                          \
+  }                                                          \
+  return image->image->get_component_data<type>(component_idx, out_stride); \
+}
+
+heif_image_get_component_X(uint16, uint16_t)
+heif_image_get_component_X(uint32, uint32_t)
+heif_image_get_component_X(uint64, uint64_t)
+heif_image_get_component_X(int8, int8_t)
+heif_image_get_component_X(int16, int16_t)
+heif_image_get_component_X(int32, int32_t)
+heif_image_get_component_X(int64, int64_t)
+heif_image_get_component_X(float32, float)
+heif_image_get_component_X(float64, double)
+heif_image_get_component_X(complex32, heif_complex32)
+heif_image_get_component_X(complex64, heif_complex64)
+
+
+void heif_image_set_gimi_component_content_id(heif_image* image,
+                                              uint32_t component_idx,
+                                              const char* content_id)
+{
+  if (!image || !image->image || !content_id) {
+    return;
+  }
+
+  auto ids = image->image->get_component_content_ids();
+  if (component_idx >= ids.size()) {
+    ids.resize(component_idx + 1);
+  }
+  ids[component_idx] = content_id;
+  image->image->set_component_content_ids(ids);
+}
+
+
+heif_error heif_context_add_empty_unci_image(heif_context* ctx,
+                                                    const heif_unci_image_parameters* parameters,
+                                                    const heif_encoding_options* encoding_options,
+                                                    const heif_image* prototype,
+                                                    heif_image_handle** out_unci_image_handle)
+{
+#if WITH_UNCOMPRESSED_CODEC
+  if (prototype == nullptr || out_unci_image_handle == nullptr) {
+    return heif_error_null_pointer_argument;
+  }
+
+  heif_encoding_options* default_options = nullptr;
+  if (encoding_options == nullptr) {
+    default_options = heif_encoding_options_alloc();
+    encoding_options = default_options;
+  }
+
+  Result<std::shared_ptr<ImageItem_uncompressed>> unciImageResult;
+  unciImageResult = ImageItem_uncompressed::add_unci_item(ctx->context.get(), parameters, encoding_options, prototype->image);
+
+  if (encoding_options) {
+    heif_encoding_options_free(default_options);
+  }
+
+  if (!unciImageResult) {
+    return unciImageResult.error_struct(ctx->context.get());
+  }
+
+  assert(out_unci_image_handle);
+  *out_unci_image_handle = new heif_image_handle;
+  (*out_unci_image_handle)->image = *unciImageResult;
+  (*out_unci_image_handle)->context = ctx->context;
+
+  return heif_error_success;
+#else
+  return {heif_error_Unsupported_feature,
+          heif_suberror_Unspecified,
+          "support for uncompressed images (ISO23001-17) has been disabled."};
+#endif
+}
diff --git a/libheif/api/libheif/heif_uncompressed.h b/libheif/api/libheif/heif_uncompressed.h
new file mode 100644
index 0000000000..966c5b5958
--- /dev/null
+++ b/libheif/api/libheif/heif_uncompressed.h
@@ -0,0 +1,409 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024-2025 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_HEIF_UNCOMPRESSED_H
+#define LIBHEIF_HEIF_UNCOMPRESSED_H
+
+#include "libheif/heif_uncompressed_types.h"
+#include "libheif/heif.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* @file heif_uncompressed.h
+ * @brief Functions for adding ISO 23001-17 (uncompressed) images to a HEIF file.
+ *        Despite its name, this is not limited to uncompressed images.
+ *        It is also possible to add images with lossless compression methods.
+ *        See heif_metadata_compression for more information.
+ */
+
+// heif_uncompressed_component_type and heif_bayer_pattern_pixel are defined in heif_uncompressed_types.h.
+
+// Set a Bayer / filter array pattern on an image.
+// The pattern is a 2D array of component indices with dimensions pattern_width x pattern_height.
+// The number of entries in patternPixels must be pattern_width * pattern_height.
+// The component_index values are indices into the cmpd component definition table.
+// On the encoder path, these indices are generated by heif_image_add_component() and the
+// encoder adds reference components to cmpd for pattern entries that don't have image planes.
+// On the decoder path, they come directly from the cpat box.
+LIBHEIF_API
+heif_error heif_image_set_bayer_pattern(heif_image*,
+                                        uint16_t pattern_width,
+                                        uint16_t pattern_height,
+                                        const heif_bayer_pattern_pixel* patternPixels);
+
+// Returns whether the image has a Bayer / filter array pattern.
+// If the image has a pattern, out_pattern_width and out_pattern_height are set.
+// Either output pointer may be NULL if the caller does not need that value.
+LIBHEIF_API
+int heif_image_has_bayer_pattern(const heif_image*,
+                                 uint16_t* out_pattern_width,
+                                 uint16_t* out_pattern_height);
+
+// Get the Bayer / filter array pattern pixels.
+// The caller must provide an array large enough for pattern_width * pattern_height entries
+// (use heif_image_has_bayer_pattern() to query the dimensions first).
+// Returns heif_error_Ok on success, or an error if no pattern is set.
+LIBHEIF_API
+heif_error heif_image_get_bayer_pattern(const heif_image*,
+                                        heif_bayer_pattern_pixel* out_patternPixels);
+
+// --- Polarization pattern (ISO 23001-17, Section 6.1.5)
+
+// Special float value indicating "no polarization filter" at a pattern position.
+// On the wire this is the IEEE 754 bit pattern 0xFFFFFFFF (a signaling NaN).
+// Test with heif_polarization_angle_is_no_filter() below, or with isnan()/std::isnan().
+
+// Returns a float with the 0xFFFFFFFF bit pattern (NaN) representing "no polarization filter".
+LIBHEIF_API
+float heif_polarization_angle_no_filter(void);
+
+// Returns non-zero if the given angle has the "no filter" bit pattern (0xFFFFFFFF).
+LIBHEIF_API
+int heif_polarization_angle_is_no_filter(float angle);
+
+// Add a polarization pattern to an image.
+// component_indices: array of component indices this pattern applies to (may be NULL if num_component_indices == 0,
+//                    meaning the pattern applies to all components).
+// polarization_angles: array of pattern_width * pattern_height float values.
+//                      Each is an angle in degrees [0.0, 360.0), or heif_polarization_angle_no_filter() for "no filter".
+// Multiple patterns can be added (one per distinct component group).
+LIBHEIF_API
+heif_error heif_image_add_polarization_pattern(heif_image*,
+                                               uint32_t num_component_indices,
+                                               const uint32_t* component_indices,
+                                               uint16_t pattern_width,
+                                               uint16_t pattern_height,
+                                               const float* polarization_angles);
+
+// Returns the number of polarization patterns on this image (0 if none).
+LIBHEIF_API
+int heif_image_get_number_of_polarization_patterns(const heif_image*);
+
+// Get the sizes/dimensions of a polarization pattern (to allocate arrays for the data query).
+LIBHEIF_API
+heif_error heif_image_get_polarization_pattern_info(const heif_image*,
+                                                    int pattern_index,
+                                                    uint32_t* out_num_component_indices,
+                                                    uint16_t* out_pattern_width,
+                                                    uint16_t* out_pattern_height);
+
+// Get the actual data of a polarization pattern.
+// Caller must provide pre-allocated arrays:
+//   out_component_indices: num_component_indices entries (may be NULL if num_component_indices == 0)
+//   out_polarization_angles: pattern_width * pattern_height entries
+LIBHEIF_API
+heif_error heif_image_get_polarization_pattern_data(const heif_image*,
+                                                    int pattern_index,
+                                                    uint32_t* out_component_indices,
+                                                    float* out_polarization_angles);
+
+// Find the polarization pattern index that applies to a given component index.
+// Returns the pattern index (>= 0), or -1 if no pattern matches.
+// A pattern with an empty component list (component_count == 0) matches all components.
+LIBHEIF_API
+int heif_image_get_polarization_pattern_index_for_component(const heif_image*,
+                                                            uint32_t component_index);
+
+
+// --- Sensor bad pixels map (ISO 23001-17, Section 6.1.7)
+
+// struct heif_bad_pixel is defined in heif_uncompressed_types.h.
+
+// Add a sensor bad pixels map to an image.
+// component_indices: array of component indices this map applies to (may be NULL if num_component_indices == 0,
+//                    meaning the map applies to all components).
+// Multiple maps can be added (one per distinct component group with different defects).
+LIBHEIF_API
+heif_error heif_image_add_sensor_bad_pixels_map(heif_image*,
+                                                 uint32_t num_component_indices,
+                                                 const uint32_t* component_indices,
+                                                 int correction_applied,
+                                                 uint32_t num_bad_rows,
+                                                 const uint32_t* bad_rows,
+                                                 uint32_t num_bad_columns,
+                                                 const uint32_t* bad_columns,
+                                                 uint32_t num_bad_pixels,
+                                                 const heif_bad_pixel* bad_pixels);
+
+// Returns the number of sensor bad pixels maps on this image (0 if none).
+LIBHEIF_API
+int heif_image_get_number_of_sensor_bad_pixels_maps(const heif_image*);
+
+// Get the sizes of a sensor bad pixels map (to allocate arrays for the data query).
+LIBHEIF_API
+heif_error heif_image_get_sensor_bad_pixels_map_info(const heif_image*,
+                                                      int map_index,
+                                                      uint32_t* out_num_component_indices,
+                                                      int* out_correction_applied,
+                                                      uint32_t* out_num_bad_rows,
+                                                      uint32_t* out_num_bad_columns,
+                                                      uint32_t* out_num_bad_pixels);
+
+// Get the actual data of a sensor bad pixels map.
+// Caller must provide pre-allocated arrays:
+//   out_component_indices: num_component_indices entries (may be NULL if num_component_indices == 0)
+//   out_bad_rows: num_bad_rows entries (may be NULL if num_bad_rows == 0)
+//   out_bad_columns: num_bad_columns entries (may be NULL if num_bad_columns == 0)
+//   out_bad_pixels: num_bad_pixels entries (may be NULL if num_bad_pixels == 0)
+LIBHEIF_API
+heif_error heif_image_get_sensor_bad_pixels_map_data(const heif_image*,
+                                                      int map_index,
+                                                      uint32_t* out_component_indices,
+                                                      uint32_t* out_bad_rows,
+                                                      uint32_t* out_bad_columns,
+                                                      struct heif_bad_pixel* out_bad_pixels);
+
+
+// --- Sensor non-uniformity correction (ISO 23001-17, Section 6.1.6)
+
+// Add a sensor non-uniformity correction table to an image.
+// component_indices: array of component indices this NUC applies to (may be NULL if num_component_indices == 0,
+//                    meaning it applies to all components).
+// nuc_gains and nuc_offsets: arrays of image_width * image_height float values.
+// Correction equation: y = nuc_gain * x + nuc_offset.
+// Multiple NUC tables can be added (one per distinct component group).
+LIBHEIF_API
+heif_error heif_image_add_sensor_nuc(heif_image*,
+                                      uint32_t num_component_indices,
+                                      const uint32_t* component_indices,
+                                      int nuc_is_applied,
+                                      uint32_t image_width,
+                                      uint32_t image_height,
+                                      const float* nuc_gains,
+                                      const float* nuc_offsets);
+
+// Returns the number of sensor NUC tables on this image (0 if none).
+LIBHEIF_API
+int heif_image_get_number_of_sensor_nucs(const heif_image*);
+
+// Get the sizes of a sensor NUC table (to allocate arrays for the data query).
+LIBHEIF_API
+heif_error heif_image_get_sensor_nuc_info(const heif_image*,
+                                           int nuc_index,
+                                           uint32_t* out_num_component_indices,
+                                           int* out_nuc_is_applied,
+                                           uint32_t* out_image_width,
+                                           uint32_t* out_image_height);
+
+// Get the actual data of a sensor NUC table.
+// Caller must provide pre-allocated arrays:
+//   out_component_indices: num_component_indices entries (may be NULL if num_component_indices == 0)
+//   out_nuc_gains: image_width * image_height entries
+//   out_nuc_offsets: image_width * image_height entries
+LIBHEIF_API
+heif_error heif_image_get_sensor_nuc_data(const heif_image*,
+                                           int nuc_index,
+                                           uint32_t* out_component_indices,
+                                           float* out_nuc_gains,
+                                           float* out_nuc_offsets);
+
+
+// heif_chroma420_sample_location is defined in heif_uncompressed_types.h.
+
+// --- Chroma sample location (ISO 23001-17, Section 6.1.4)
+
+// Set the chroma sample location on an image.
+// chroma_location must be in the range 0-6 (see heif_chroma420_sample_location).
+LIBHEIF_API
+heif_error heif_image_set_chroma_location(heif_image*, uint8_t chroma_location);
+
+// Returns non-zero if the image has a chroma sample location set.
+LIBHEIF_API
+int heif_image_has_chroma_location(const heif_image*);
+
+// Returns the chroma sample location (0-6), or 0 if none is set.
+LIBHEIF_API
+uint8_t heif_image_get_chroma_location(const heif_image*);
+
+
+// --- 'unci' images
+
+// heif_unci_compression and heif_unci_image_parameters are defined in heif_uncompressed_types.h.
+
+LIBHEIF_API
+heif_unci_image_parameters* heif_unci_image_parameters_alloc(void);
+
+LIBHEIF_API
+void heif_unci_image_parameters_copy(heif_unci_image_parameters* dst,
+                                     const heif_unci_image_parameters* src);
+
+LIBHEIF_API
+void heif_unci_image_parameters_release(heif_unci_image_parameters*);
+
+
+/*
+ * This adds an empty iso23001-17 (uncompressed) image to the HEIF file.
+ * The actual image data is added later using heif_context_add_image_tile().
+ * If you do not need tiling, you can use heif_context_encode_image() instead.
+ * However, this will by default disable any compression and any control about
+ * the data layout.
+ *
+ * @param ctx The file context
+ * @param parameters The parameters for the image, must not be NULL.
+ * @param encoding_options Optional, may be NULL.
+ * @param prototype An image with the same channel configuration as the image data
+ *                  that will be later inserted. The image size need not match this.
+ *                  Must not be NULL.
+ * @param out_unci_image_handle Returns a handle to the image. The caller is responsible for freeing it.
+ *                  Must not be NULL because this is required to fill in image data.
+ * @return Returns an error if the passed parameters are incorrect.
+ *         If ISO23001-17 images are not supported, returns heif_error_Unsupported_feature.
+ */
+LIBHEIF_API
+heif_error heif_context_add_empty_unci_image(heif_context* ctx,
+                                             const heif_unci_image_parameters* parameters,
+                                             const heif_encoding_options* encoding_options,
+                                             const heif_image* prototype,
+                                             heif_image_handle** out_unci_image_handle);
+
+// heif_channel_datatype, heif_complex32, heif_complex64 are defined in heif_uncompressed_types.h.
+
+// --- index-based component access (for ISO 23001-17 multi-component images)
+
+// Returns the number of components that have pixel data (planes) in this image.
+LIBHEIF_API
+uint32_t heif_image_get_number_of_used_components(const heif_image*);
+
+// Returns the total number of components declared in the cmpd box.
+LIBHEIF_API
+uint32_t heif_image_get_total_number_of_cmpd_components(const heif_image*);
+
+// Fills `out_component_indices` with the valid component indices.
+// The caller must allocate an array of at least heif_image_get_number_of_used_components() elements.
+LIBHEIF_API
+void heif_image_get_used_component_indices(const heif_image*, uint32_t* out_component_indices);
+
+LIBHEIF_API
+enum heif_channel heif_image_get_component_channel(const heif_image*, uint32_t component_idx);
+
+LIBHEIF_API
+uint32_t heif_image_get_component_width(const heif_image*, uint32_t component_idx);
+
+LIBHEIF_API
+uint32_t heif_image_get_component_height(const heif_image*, uint32_t component_idx);
+
+LIBHEIF_API
+int heif_image_get_component_bits_per_pixel(const heif_image*, uint32_t component_idx);
+
+LIBHEIF_API
+uint16_t heif_image_get_component_type(const heif_image*, uint32_t component_idx);
+
+// TODO
+//LIBHEIF_API
+//heif_error heif_image_get_component_indices_of_interleaved_channel(const heif_image* image, uint32_t* component_indices, uint8_t* nComponents_in_out);
+
+LIBHEIF_API
+heif_error heif_image_add_component(heif_image* image,
+                                    int width, int height,
+                                    uint16_t component_type,
+                                    heif_channel_datatype datatype,
+                                    int bit_depth,
+                                    uint32_t* out_component_idx);
+
+LIBHEIF_API
+const uint8_t* heif_image_get_component_readonly(const heif_image*, uint32_t component_idx, size_t* out_stride);
+
+LIBHEIF_API
+uint8_t* heif_image_get_component(heif_image*, uint32_t component_idx, size_t* out_stride);
+
+LIBHEIF_API
+const uint16_t* heif_image_get_component_uint16_readonly(const heif_image*, uint32_t component_idx, size_t* out_stride);
+
+LIBHEIF_API
+uint16_t* heif_image_get_component_uint16(heif_image*, uint32_t component_idx, size_t* out_stride);
+
+LIBHEIF_API
+const uint32_t* heif_image_get_component_uint32_readonly(const heif_image*, uint32_t component_idx, size_t* out_stride);
+
+LIBHEIF_API
+uint32_t* heif_image_get_component_uint32(heif_image*, uint32_t component_idx, size_t* out_stride);
+
+LIBHEIF_API
+const uint64_t* heif_image_get_component_uint64_readonly(const heif_image*, uint32_t component_idx, size_t* out_stride);
+
+LIBHEIF_API
+uint64_t* heif_image_get_component_uint64(heif_image*, uint32_t component_idx, size_t* out_stride);
+
+LIBHEIF_API
+const int8_t* heif_image_get_component_int8_readonly(const heif_image*, uint32_t component_idx, size_t* out_stride);
+
+LIBHEIF_API
+int8_t* heif_image_get_component_int8(heif_image*, uint32_t component_idx, size_t* out_stride);
+
+LIBHEIF_API
+const int16_t* heif_image_get_component_int16_readonly(const heif_image*, uint32_t component_idx, size_t* out_stride);
+
+LIBHEIF_API
+int16_t* heif_image_get_component_int16(heif_image*, uint32_t component_idx, size_t* out_stride);
+
+LIBHEIF_API
+const int32_t* heif_image_get_component_int32_readonly(const heif_image*, uint32_t component_idx, size_t* out_stride);
+
+LIBHEIF_API
+int32_t* heif_image_get_component_int32(heif_image*, uint32_t component_idx, size_t* out_stride);
+
+LIBHEIF_API
+const int64_t* heif_image_get_component_int64_readonly(const heif_image*, uint32_t component_idx, size_t* out_stride);
+
+LIBHEIF_API
+int64_t* heif_image_get_component_int64(heif_image*, uint32_t component_idx, size_t* out_stride);
+
+LIBHEIF_API
+const float* heif_image_get_component_float32_readonly(const heif_image*, uint32_t component_idx, size_t* out_stride);
+
+LIBHEIF_API
+float* heif_image_get_component_float32(heif_image*, uint32_t component_idx, size_t* out_stride);
+
+LIBHEIF_API
+const double* heif_image_get_component_float64_readonly(const heif_image*, uint32_t component_idx, size_t* out_stride);
+
+LIBHEIF_API
+double* heif_image_get_component_float64(heif_image*, uint32_t component_idx, size_t* out_stride);
+
+LIBHEIF_API
+const heif_complex32* heif_image_get_component_complex32_readonly(const heif_image*, uint32_t component_idx, size_t* out_stride);
+
+LIBHEIF_API
+heif_complex32* heif_image_get_component_complex32(heif_image*, uint32_t component_idx, size_t* out_stride);
+
+LIBHEIF_API
+const heif_complex64* heif_image_get_component_complex64_readonly(const heif_image*, uint32_t component_idx, size_t* out_stride);
+
+LIBHEIF_API
+heif_complex64* heif_image_get_component_complex64(heif_image*, uint32_t component_idx, size_t* out_stride);
+
+
+// --- GIMI component content IDs (set before encoding)
+
+// Set a GIMI component content ID for a single cmpd component.
+// If the internal array is too small, it will be resized (new entries default to empty strings).
+// These are written into an ItemComponentContentIDProperty box during encoding.
+LIBHEIF_API
+void heif_image_set_gimi_component_content_id(heif_image*,
+                                              uint32_t component_idx,
+                                              const char* content_id);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/libheif/api/libheif/heif_uncompressed_types.h b/libheif/api/libheif/heif_uncompressed_types.h
new file mode 100644
index 0000000000..1a00dcc9bc
--- /dev/null
+++ b/libheif/api/libheif/heif_uncompressed_types.h
@@ -0,0 +1,143 @@
+/*6
+ * HEIF codec.
+ * Copyright (c) 2026 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_HEIF_UNCOMPRESSED_TYPES_H
+#define LIBHEIF_HEIF_UNCOMPRESSED_TYPES_H
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// --- ISO 23001-17 component types (Table 1)
+
+typedef enum heif_uncompressed_component_type
+{
+  heif_uncompressed_component_type_monochrome = 0,
+  heif_uncompressed_component_type_Y = 1,
+  heif_uncompressed_component_type_Cb = 2,
+  heif_uncompressed_component_type_Cr = 3,
+  heif_uncompressed_component_type_red = 4,
+  heif_uncompressed_component_type_green = 5,
+  heif_uncompressed_component_type_blue = 6,
+  heif_uncompressed_component_type_alpha = 7,
+  heif_uncompressed_component_type_depth = 8,
+  heif_uncompressed_component_type_disparity = 9,
+  heif_uncompressed_component_type_palette = 10,
+  heif_uncompressed_component_type_filter_array = 11,
+  heif_uncompressed_component_type_padded = 12,
+  heif_uncompressed_component_type_cyan = 13,
+  heif_uncompressed_component_type_magenta = 14,
+  heif_uncompressed_component_type_yellow = 15,
+  heif_uncompressed_component_type_key_black = 16
+} heif_uncompressed_component_type;
+
+
+// --- Bayer / filter array pattern
+
+typedef struct heif_bayer_pattern_pixel
+{
+  uint16_t component_index;  // index into the component definition (cmpd)
+  float component_gain;
+} heif_bayer_pattern_pixel;
+
+
+// --- Sensor bad pixels map (ISO 23001-17, Section 6.1.7)
+
+struct heif_bad_pixel { uint32_t row; uint32_t column; };
+
+
+// --- Chroma sample location (ISO 23091-2 / ITU-T H.273 + ISO 23001-17)
+
+typedef enum heif_chroma420_sample_location {
+  // values 0-5 according to ISO 23091-2 / ITU-T H.273
+  heif_chroma420_sample_location_00_05 = 0,
+  heif_chroma420_sample_location_05_05 = 1,
+  heif_chroma420_sample_location_00_00 = 2,
+  heif_chroma420_sample_location_05_00 = 3,
+  heif_chroma420_sample_location_00_10 = 4,
+  heif_chroma420_sample_location_05_10 = 5,
+
+  // value 6 according to ISO 23001-17
+  heif_chroma420_sample_location_00_00_01_00 = 6
+} heif_chroma420_sample_location;
+
+
+// Compression methods for 'unci' (ISO 23001-17) images.
+// This is similar to heif_metadata_compression. We should try to keep the integers compatible, but each enum will just
+// contain the allowed values.
+typedef enum heif_unci_compression
+{
+  heif_unci_compression_off = 0,
+  //heif_unci_compression_auto = 1,
+  //heif_unci_compression_unknown = 2, // only used when reading unknown method from input file
+  heif_unci_compression_deflate = 3,
+  heif_unci_compression_zlib = 4,
+  heif_unci_compression_brotli = 5
+} heif_unci_compression;
+
+
+// --- 'unci' image parameters
+
+typedef struct heif_unci_image_parameters
+{
+  int version;
+
+  // --- version 1
+
+  uint32_t image_width;
+  uint32_t image_height;
+
+  uint32_t tile_width;
+  uint32_t tile_height;
+
+  heif_unci_compression compression;
+
+  // TODO: interleave type, padding
+} heif_unci_image_parameters;
+
+
+// --- pixel datatype support
+
+typedef enum heif_channel_datatype
+{
+  heif_channel_datatype_undefined = 0,
+  heif_channel_datatype_unsigned_integer = 1,
+  heif_channel_datatype_signed_integer = 2,
+  heif_channel_datatype_floating_point = 3,
+  heif_channel_datatype_complex_number = 4
+} heif_channel_datatype;
+
+typedef struct heif_complex32
+{
+  float real, imaginary;
+} heif_complex32;
+
+typedef struct heif_complex64
+{
+  double real, imaginary;
+} heif_complex64;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/libheif/heif_version.h.in b/libheif/api/libheif/heif_version.h.in
similarity index 86%
rename from libheif/heif_version.h.in
rename to libheif/api/libheif/heif_version.h.in
index 8eae5b472e..fae2cb810f 100644
--- a/libheif/heif_version.h.in
+++ b/libheif/api/libheif/heif_version.h.in
@@ -1,6 +1,6 @@
 /*
  * HEIF codec.
- * Copyright (c) 2017 struktur AG, Dirk Farin <farin@struktur.de>
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
  *
  * This file is part of libheif.
  *
@@ -20,7 +20,7 @@
 
 /* heif_version.h
  *
- * This file was generated by autoconf when libheif was built.
+ * This file was automatically generated when libheif was built.
  *
  * DO NOT EDIT THIS FILE.
  */
@@ -28,9 +28,11 @@
 #define LIBHEIF_HEIF_VERSION_H
 
 /* Numeric representation of the version */
-#define LIBHEIF_NUMERIC_VERSION ((@PROJECT_VERSION_MAJOR@<<24) | (@PROJECT_VERSION_MINOR@<<16) | (@PROJECT_VERSION_PATCH@<<8) | @PROJECT_VERSION_TWEAK@)
+#define LIBHEIF_NUMERIC_VERSION ((@PROJECT_VERSION_MAJOR@<<24) | (@PROJECT_VERSION_MINOR@<<16) | (@PROJECT_VERSION_PATCH@<<8) | 0)
 
 /* Version string */
 #define LIBHEIF_VERSION "@PROJECT_VERSION_MAJOR@.@PROJECT_VERSION_MINOR@.@PROJECT_VERSION_PATCH@"
 
+#define LIBHEIF_PLUGIN_DIRECTORY "@PLUGIN_DIRECTORY@"
+
 #endif  // LIBHEIF_HEIF_VERSION_H
diff --git a/libheif/api_structs.h b/libheif/api_structs.h
new file mode 100644
index 0000000000..3dd7ec9340
--- /dev/null
+++ b/libheif/api_structs.h
@@ -0,0 +1,114 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef HEIF_API_STRUCTS_H
+#define HEIF_API_STRUCTS_H
+
+#include "pixelimage.h"
+#include "context.h"
+
+#include <memory>
+#include <vector>
+#include <string>
+#include "image-items/image_item.h"
+
+struct heif_image_handle
+{
+  std::shared_ptr<ImageItem> image;
+
+  // store reference to keep the context alive while we are using the handle (issue #147)
+  std::shared_ptr<HeifContext> context;
+};
+
+
+struct heif_track
+{
+  std::shared_ptr<Track> track;
+
+  // store reference to keep the context alive while we are using the handle (issue #147)
+  std::shared_ptr<HeifContext> context;
+};
+
+struct heif_raw_sequence_sample
+{
+  ~heif_raw_sequence_sample()
+  {
+    heif_tai_timestamp_packet_release(timestamp);
+  }
+
+  std::vector<uint8_t> data;
+  uint32_t duration = 0;
+
+  heif_tai_timestamp_packet* timestamp = nullptr;
+  std::string gimi_sample_content_id;
+};
+
+
+struct heif_image
+{
+  std::shared_ptr<HeifPixelImage> image;
+};
+
+
+struct heif_context
+{
+  std::shared_ptr<HeifContext> context;
+};
+
+
+struct heif_encoder
+{
+  explicit heif_encoder(const heif_encoder_plugin* plugin);
+
+  ~heif_encoder();
+
+  heif_error alloc();
+
+  void release();
+
+
+  const struct heif_encoder_plugin* plugin;
+  void* encoder = nullptr;
+};
+
+
+struct heif_region_item
+{
+  std::shared_ptr<HeifContext> context;
+  std::shared_ptr<RegionItem> region_item;
+};
+
+
+struct heif_region
+{
+  std::shared_ptr<HeifContext> context; // we need this to perform coordinate transformation
+  //heif_item_id parent_region_item_id; // we need this to perform coordinate transformation
+  std::shared_ptr<RegionItem> region_item;
+  std::shared_ptr<RegionGeometry> region;
+};
+
+struct heif_text_item
+{
+  std::shared_ptr<HeifContext> context;
+  std::shared_ptr<TextItem> text_item;
+};
+
+
+#endif
diff --git a/libheif/bitstream.cc b/libheif/bitstream.cc
index a0c92415f9..4ac2805d46 100644
--- a/libheif/bitstream.cc
+++ b/libheif/bitstream.cc
@@ -1,6 +1,6 @@
 /*
  * HEIF codec.
- * Copyright (c) 2017 struktur AG, Dirk Farin <farin@struktur.de>
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
  *
  * This file is part of libheif.
  *
@@ -24,9 +24,15 @@
 #include <cstring>
 #include <cassert>
 
-#define MAX_UVLC_LEADING_ZEROS 20
+#include "common_utils.h"
 
-using namespace heif;
+#if !defined(HAVE_BIT)
+#include <type_traits>
+#else
+#include <bit>
+#endif
+
+#define MAX_UVLC_LEADING_ZEROS 20
 
 
 StreamReader_istream::StreamReader_istream(std::unique_ptr<std::istream>&& istr)
@@ -37,19 +43,19 @@ StreamReader_istream::StreamReader_istream(std::unique_ptr<std::istream>&& istr)
   m_istr->seekg(0, std::ios_base::beg);
 }
 
-int64_t StreamReader_istream::get_position() const
+uint64_t StreamReader_istream::get_position() const
 {
   return m_istr->tellg();
 }
 
-StreamReader::grow_status StreamReader_istream::wait_for_file_size(int64_t target_size)
+StreamReader::grow_status StreamReader_istream::wait_for_file_size(uint64_t target_size)
 {
-  return (target_size > m_length) ? size_beyond_eof : size_reached;
+  return (target_size > m_length) ? grow_status::size_beyond_eof : grow_status::size_reached;
 }
 
 bool StreamReader_istream::read(void* data, size_t size)
 {
-  int64_t end_pos = get_position() + size;
+  uint64_t end_pos = get_position() + size;
   if (end_pos > m_length) {
     return false;
   }
@@ -58,7 +64,7 @@ bool StreamReader_istream::read(void* data, size_t size)
   return true;
 }
 
-bool StreamReader_istream::seek(int64_t position)
+bool StreamReader_istream::seek(uint64_t position)
 {
   if (position > m_length)
     return false;
@@ -68,13 +74,13 @@ bool StreamReader_istream::seek(int64_t position)
 }
 
 
-StreamReader_memory::StreamReader_memory(const uint8_t* data, int64_t size, bool copy)
+StreamReader_memory::StreamReader_memory(const uint8_t* data, size_t size, bool copy)
     : m_length(size),
       m_position(0)
 {
   if (copy) {
     m_owned_data = new uint8_t[m_length];
-    memcpy(m_owned_data, data, m_length);
+    memcpy(m_owned_data, data, size);
 
     m_data = m_owned_data;
   }
@@ -90,19 +96,19 @@ StreamReader_memory::~StreamReader_memory()
   }
 }
 
-int64_t StreamReader_memory::get_position() const
+uint64_t StreamReader_memory::get_position() const
 {
   return m_position;
 }
 
-StreamReader::grow_status StreamReader_memory::wait_for_file_size(int64_t target_size)
+StreamReader::grow_status StreamReader_memory::wait_for_file_size(uint64_t target_size)
 {
-  return (target_size > m_length) ? size_beyond_eof : size_reached;
+  return (target_size > m_length) ? grow_status::size_beyond_eof : grow_status::size_reached;
 }
 
 bool StreamReader_memory::read(void* data, size_t size)
 {
-  int64_t end_pos = m_position + size;
+  uint64_t end_pos = m_position + size;
   if (end_pos > m_length) {
     return false;
   }
@@ -113,9 +119,9 @@ bool StreamReader_memory::read(void* data, size_t size)
   return true;
 }
 
-bool StreamReader_memory::seek(int64_t position)
+bool StreamReader_memory::seek(uint64_t position)
 {
-  if (position > m_length || position < 0)
+  if (position > m_length)
     return false;
 
   m_position = position;
@@ -128,38 +134,45 @@ StreamReader_CApi::StreamReader_CApi(const heif_reader* func_table, void* userda
 {
 }
 
-StreamReader::grow_status StreamReader_CApi::wait_for_file_size(int64_t target_size)
+StreamReader::grow_status StreamReader_CApi::wait_for_file_size(uint64_t target_size)
 {
   heif_reader_grow_status status = m_func_table->wait_for_file_size(target_size, m_userdata);
   switch (status) {
     case heif_reader_grow_status_size_reached:
-      return size_reached;
+      return grow_status::size_reached;
     case heif_reader_grow_status_timeout:
-      return timeout;
+      return grow_status::timeout;
     case heif_reader_grow_status_size_beyond_eof:
-      return size_beyond_eof;
+      return grow_status::size_beyond_eof;
     default:
       assert(0);
-      return size_beyond_eof;
+      return grow_status::size_beyond_eof;
   }
 }
 
 
 BitstreamRange::BitstreamRange(std::shared_ptr<StreamReader> istr,
-                               uint64_t length,
+                               size_t length,
                                BitstreamRange* parent)
+    : m_istr(std::move(istr)), m_parent_range(parent), m_remaining(length)
 {
-  m_remaining = length;
-
-  m_istr = istr;
-  m_parent_range = parent;
-
   if (parent) {
     m_nesting_level = parent->m_nesting_level + 1;
   }
 }
 
 
+BitstreamRange::BitstreamRange(std::shared_ptr<StreamReader> istr,
+                               size_t start,
+                               size_t end) // one past end
+  : m_istr(std::move(istr)), m_remaining(end)
+{
+  bool success = m_istr->seek(start);
+  assert(success);
+  (void)success; // TODO
+}
+
+
 StreamReader::grow_status BitstreamRange::wait_until_range_is_available()
 {
   return m_istr->wait_for_file_size(m_istr->get_position() + m_remaining);
@@ -206,6 +219,41 @@ uint16_t BitstreamRange::read16()
 }
 
 
+int16_t BitstreamRange::read16s()
+{
+  uint16_t v = read16();
+
+  if (v & 0x8000) {
+    auto val = static_cast<int16_t>((~v) & 0x7fff);
+    return static_cast<int16_t>(-val - 1);
+  }
+  else {
+    return static_cast<int16_t>(v);
+  }
+}
+
+
+uint32_t BitstreamRange::read24()
+{
+  if (!prepare_read(3)) {
+    return 0;
+  }
+
+  uint8_t buf[3];
+
+  auto istr = get_istream();
+  bool success = istr->read((char*) buf, 3);
+
+  if (!success) {
+    set_eof_while_reading();
+    return 0;
+  }
+
+  return (uint32_t) ((buf[0] << 16) |
+                     (buf[1] << 8) |
+                     (buf[2]));
+}
+
 uint32_t BitstreamRange::read32()
 {
   if (!prepare_read(4)) {
@@ -222,10 +270,117 @@ uint32_t BitstreamRange::read32()
     return 0;
   }
 
-  return ((buf[0] << 24) |
-          (buf[1] << 16) |
-          (buf[2] << 8) |
-          (buf[3]));
+  return four_bytes_to_uint32(buf[0], buf[1], buf[2], buf[3]);
+}
+
+
+uint64_t BitstreamRange::read_uint(int len)
+{
+  switch (len)
+  {
+    case 8:
+      return read8();
+    case 16:
+      return read16();
+    case 24:
+      return read24();
+    case 32:
+      return read32();
+    case 64:
+      return read64();
+    default:
+      assert(false);
+      return 0;
+  }
+}
+
+
+int32_t BitstreamRange::read32s()
+{
+  uint32_t v = read32();
+
+  if (v & 0x80000000) {
+    return -static_cast<int32_t>((~v) & 0x7fffffff) -1;
+  }
+  else {
+    return static_cast<int32_t>(v);
+  }
+}
+
+
+uint64_t BitstreamRange::read64()
+{
+  if (!prepare_read(8)) {
+    return 0;
+  }
+
+  uint8_t buf[8];
+
+  auto istr = get_istream();
+  bool success = istr->read((char*) buf, 8);
+
+  if (!success) {
+    set_eof_while_reading();
+    return 0;
+  }
+
+  return ((static_cast<uint64_t>(buf[0]) << 56) |
+          (static_cast<uint64_t>(buf[1]) << 48) |
+          (static_cast<uint64_t>(buf[2]) << 40) |
+          (static_cast<uint64_t>(buf[3]) << 32) |
+          (static_cast<uint64_t>(buf[4]) << 24) |
+          (static_cast<uint64_t>(buf[5]) << 16) |
+          (static_cast<uint64_t>(buf[6]) << 8) |
+          (static_cast<uint64_t>(buf[7])));
+}
+
+
+int64_t BitstreamRange::read64s()
+{
+  uint64_t v = read64();
+
+  if (v & 0x8000000000000000) {
+    return -static_cast<int64_t >((~v) & 0x7fffffffffffffff) -1;
+  }
+  else {
+    return static_cast<int64_t >(v);
+  }
+}
+
+
+float BitstreamRange::read_float32()
+{
+#if __cpp_lib_bit_cast >= 201806L
+  uint32_t i = read32();
+  return std::bit_cast<float>(i); // this works directly on the value layout, thus we do not have to worry about memory layout
+#else
+  // compiler too old to support bit_cast
+
+  // TODO: I am not sure this works everywhere as there seem to be systems where
+  //       the float byte order is different from the integer endianness
+  //       https://en.wikipedia.org/wiki/Endianness#Floating_point
+  uint32_t i = read32();
+  float f;
+  memcpy(&f, &i, sizeof(float));
+  return f;
+#endif
+}
+
+
+void StreamWriter::write_float32(float v)
+{
+#if __cpp_lib_bit_cast >= 201806L
+  write32(std::bit_cast<uint32_t>(v)); // this works directly on the value layout, thus we do not have to worry about memory layout
+#else
+  // compiler too old to support bit_cast
+
+  // TODO: I am not sure this works everywhere as there seem to be systems where
+  //       the float byte order is different from the integer endianness
+  //       https://en.wikipedia.org/wiki/Endianness#Floating_point
+  uint32_t i;
+  memcpy(&i, &v, sizeof(float));
+  write32(i);
+#endif
 }
 
 
@@ -239,12 +394,13 @@ std::string BitstreamRange::read_string()
     return std::string();
   }
 
+  auto istr = get_istream();
+
   for (;;) {
     if (!prepare_read(1)) {
       return std::string();
     }
 
-    auto istr = get_istream();
     char c;
     bool success = istr->read(&c, 1);
 
@@ -253,7 +409,7 @@ std::string BitstreamRange::read_string()
       return std::string();
     }
 
-    if (c == 0) {
+    if (c == 0 || m_remaining==0) {
       break;
     }
     else {
@@ -265,7 +421,56 @@ std::string BitstreamRange::read_string()
 }
 
 
-bool BitstreamRange::read(uint8_t* data, int64_t n)
+std::string BitstreamRange::read_fixed_string(int len)
+{
+  std::string str;
+
+  if (!prepare_read(len)) {
+    return std::string();
+  }
+
+  auto istr = get_istream();
+
+  uint8_t n;
+  bool success = istr->read(&n, 1);
+  if (!success || n > len - 1) {
+    return {};
+  }
+
+  for (int i = 0; i < n; i++) {
+    char c;
+    success = istr->read(&c, 1);
+
+    if (!success) {
+      set_eof_while_reading();
+      return std::string();
+    }
+
+    str += (char) c;
+  }
+
+  istr->seek_cur(len-n-1);
+
+  return str;
+}
+
+
+std::string BitstreamRange::read_string_until_eof()
+{
+  size_t n = get_remaining_bytes();
+
+  [[maybe_unused]] bool success = prepare_read(n);
+  assert(success); // we are reading exactly the rest of the box
+
+  std::string str;
+  str.resize(n);
+  get_istream()->read(str.data(), n);
+
+  return str;
+}
+
+
+bool BitstreamRange::read(uint8_t* data, size_t n)
 {
   if (!prepare_read(n)) {
     return false;
@@ -282,15 +487,11 @@ bool BitstreamRange::read(uint8_t* data, int64_t n)
 }
 
 
-bool BitstreamRange::prepare_read(int64_t nBytes)
+bool BitstreamRange::prepare_read(size_t nBytes)
 {
-  if (nBytes < 0) {
-    // --- we cannot read negative amounts of bytes
+  // Note: we do not test for negative nBytes anymore because we now use the unsigned size_t
 
-    assert(false);
-    return false;
-  }
-  else if (m_remaining < nBytes) {
+  if (m_remaining < nBytes) {
     // --- not enough data left in box -> move to end of box and set error flag
 
     skip_to_end_of_box();
@@ -314,7 +515,7 @@ bool BitstreamRange::prepare_read(int64_t nBytes)
 }
 
 
-StreamReader::grow_status BitstreamRange::wait_for_available_bytes(int64_t nBytes)
+StreamReader::grow_status BitstreamRange::wait_for_available_bytes(size_t nBytes)
 {
   int64_t target_size = m_istr->get_position() + nBytes;
 
@@ -322,7 +523,7 @@ StreamReader::grow_status BitstreamRange::wait_for_available_bytes(int64_t nByte
 }
 
 
-void BitstreamRange::skip_without_advancing_file_pos(int64_t n)
+void BitstreamRange::skip_without_advancing_file_pos(size_t n)
 {
   assert(n <= m_remaining);
 
@@ -335,9 +536,10 @@ void BitstreamRange::skip_without_advancing_file_pos(int64_t n)
 
 
 BitReader::BitReader(const uint8_t* buffer, int len)
+  : data_start(buffer),
+    data_length(len)
 {
   data = buffer;
-  data_length = len;
   bytes_remaining = len;
 
   nextbits = 0;
@@ -346,8 +548,23 @@ BitReader::BitReader(const uint8_t* buffer, int len)
   refill();
 }
 
-int BitReader::get_bits(int n)
+
+void BitReader::reset()
+{
+  data = data_start;
+  bytes_remaining = data_length;
+
+  nextbits = 0;
+  nextbits_cnt = 0;
+
+  refill();
+}
+
+
+uint32_t BitReader::get_bits(int n)
 {
+  assert(n <= 32);
+
   if (nextbits_cnt < n) {
     refill();
   }
@@ -355,10 +572,56 @@ int BitReader::get_bits(int n)
   uint64_t val = nextbits;
   val >>= 64 - n;
 
+#if AVOID_FUZZER_FALSE_POSITIVE
+  // Shifting an unsigned integer left such that some MSBs fall out is well defined in C++ despite the fuzzer claiming otherwise.
+  nextbits &= (0xffffffffffffffffULL >> n);
+#endif
+
   nextbits <<= n;
   nextbits_cnt -= n;
 
-  return (int) val;
+  return static_cast<uint32_t>(val);
+}
+
+
+uint8_t BitReader::get_bits8(int n)
+{
+  assert(n>0 && n <= 8);
+  return static_cast<uint8_t>(get_bits(n));
+}
+
+uint16_t BitReader::get_bits16(int n)
+{
+  assert(n>0 && n <= 16);
+  return static_cast<uint16_t>(get_bits(n));
+}
+
+uint32_t BitReader::get_bits32(int n)
+{
+  assert(n>0 && n <= 32);
+  return static_cast<uint32_t>(get_bits(n));
+}
+
+int32_t BitReader::get_bits32s()
+{
+  uint32_t bits = get_bits(32);
+  return static_cast<int32_t>(bits);
+}
+
+
+bool BitReader::get_flag()
+{
+  return (get_bits(1) == 0x01);
+}
+
+std::vector<uint8_t> BitReader::read_bytes(uint32_t n)
+{
+  // TODO: this implementation isn't very efficient
+  std::vector<uint8_t> bytes;
+  for (uint32_t i = 0; i < n; i++) {
+    bytes.push_back(get_bits8(8));
+  }
+  return bytes;
 }
 
 int BitReader::get_bits_fast(int n)
@@ -400,12 +663,20 @@ void BitReader::skip_bits(int n)
     refill();
   }
 
+#if AVOID_FUZZER_FALSE_POSITIVE
+  nextbits &= (0xffffffffffffffffULL >> n);
+#endif
+
   nextbits <<= n;
   nextbits_cnt -= n;
 }
 
 void BitReader::skip_bits_fast(int n)
 {
+#if AVOID_FUZZER_FALSE_POSITIVE
+  nextbits &= (0xffffffffffffffffULL >> n);
+#endif
+
   nextbits <<= n;
   nextbits_cnt -= n;
 }
@@ -414,6 +685,10 @@ void BitReader::skip_to_byte_boundary()
 {
   int nskip = (nextbits_cnt & 7);
 
+#if AVOID_FUZZER_FALSE_POSITIVE
+  nextbits &= (0xffffffffffffffffULL >> nskip);
+#endif
+
   nextbits <<= nskip;
   nextbits_cnt -= nskip;
 }
@@ -511,6 +786,35 @@ void StreamWriter::write16(uint16_t v)
 }
 
 
+void StreamWriter::write16s(int16_t v16s)
+{
+  uint16_t v;
+  if (v16s >= 0) {
+    v = static_cast<uint16_t>(v16s);
+  }
+  else {
+    auto val = static_cast<uint16_t>((-v16s-1));
+    v = static_cast<uint16_t>(~val);
+  }
+
+  write16(v);
+}
+
+
+void StreamWriter::write24(uint32_t v)
+{
+  size_t required_size = m_position + 3;
+
+  if (required_size > m_data.size()) {
+    m_data.resize(required_size);
+  }
+
+  m_data[m_position++] = uint8_t((v >> 16) & 0xFF);
+  m_data[m_position++] = uint8_t((v >> 8) & 0xFF);
+  m_data[m_position++] = uint8_t(v & 0xFF);
+}
+
+
 void StreamWriter::write32(uint32_t v)
 {
   size_t required_size = m_position + 4;
@@ -526,6 +830,20 @@ void StreamWriter::write32(uint32_t v)
 }
 
 
+void StreamWriter::write32s(int32_t v32s)
+{
+  uint32_t v;
+  if (v32s >= 0) {
+    v = static_cast<uint32_t>(v32s);
+  }
+  else {
+    v = ~static_cast<uint32_t>((-v32s-1));
+  }
+
+  write32(v);
+}
+
+
 void StreamWriter::write64(uint64_t v)
 {
   size_t required_size = m_position + 8;
@@ -545,6 +863,12 @@ void StreamWriter::write64(uint64_t v)
 }
 
 
+void StreamWriter::write64s(int64_t v)
+{
+  write64(reinterpret_cast<uint64_t&>(v));
+}
+
+
 void StreamWriter::write(int size, uint64_t value)
 {
   if (size == 1) {
@@ -568,9 +892,9 @@ void StreamWriter::write(int size, uint64_t value)
 }
 
 
-void StreamWriter::write(const std::string& str)
+void StreamWriter::write(const std::string& str, bool end_with_null)
 {
-  size_t required_size = m_position + str.size() + 1;
+  size_t required_size = m_position + str.size() + (end_with_null ? 1 : 0);
 
   if (required_size > m_data.size()) {
     m_data.resize(required_size);
@@ -580,7 +904,31 @@ void StreamWriter::write(const std::string& str)
     m_data[m_position++] = str[i];
   }
 
-  m_data[m_position++] = 0;
+  if (end_with_null) {
+    m_data[m_position++] = 0;
+  }
+}
+
+
+void StreamWriter::write_fixed_string(std::string s, size_t len)
+{
+  size_t required_size = m_position + len;
+
+  if (required_size > m_data.size()) {
+    m_data.resize(required_size);
+  }
+
+  size_t n_chars = std::min(s.length(), len - 1);
+  assert(n_chars <= 255);
+  m_data[m_position++] = static_cast<uint8_t>(n_chars);
+
+  for (size_t i = 0; i < s.size() && i < len - 1; i++) {
+    m_data[m_position++] = s[i];
+  }
+
+  for (size_t i = s.size(); i < len - 1; i++) {
+    m_data[m_position++] = 0;
+  }
 }
 
 
diff --git a/libheif/bitstream.h b/libheif/bitstream.h
index b694cf4d2d..70c462a03d 100644
--- a/libheif/bitstream.h
+++ b/libheif/bitstream.h
@@ -1,6 +1,6 @@
 /*
  * HEIF codec.
- * Copyright (c) 2017 struktur AG, Dirk Farin <farin@struktur.de>
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
  *
  * This file is part of libheif.
  *
@@ -21,10 +21,6 @@
 #ifndef LIBHEIF_BITSTREAM_H
 #define LIBHEIF_BITSTREAM_H
 
-#if defined(HAVE_CONFIG_H)
-#include "config.h"
-#endif
-
 #include <cinttypes>
 #include <cstddef>
 
@@ -34,301 +30,494 @@
 #include <limits>
 #include <istream>
 #include <string>
+#include <cassert>
 
 #include "error.h"
+#include <algorithm>
 
 
-namespace heif {
+class StreamReader
+{
+public:
+  virtual ~StreamReader() = default;
 
-  class StreamReader
+  virtual uint64_t get_position() const = 0;
+
+  enum class grow_status : uint8_t
   {
-  public:
-    virtual ~StreamReader()
-    {}
+    size_reached,   // requested size has been reached
+    timeout,        // size has not been reached yet, but it may still grow further
+    size_beyond_eof // size has not been reached and never will. The file has grown to its full size
+  };
 
-    virtual int64_t get_position() const = 0;
+  // a StreamReader can maintain a timeout for waiting for new data
+  virtual grow_status wait_for_file_size(uint64_t target_size) = 0;
 
-    enum grow_status
-    {
-      size_reached,   // requested size has been reached
-      timeout,        // size has not been reached yet, but it may still grow further
-      size_beyond_eof // size has not been reached and never will. The file has grown to its full size
-    };
+  // returns 'false' when we read out of the available file size
+  virtual bool read(void* data, size_t size) = 0;
 
-    // a StreamReader can maintain a timeout for waiting for new data
-    virtual grow_status wait_for_file_size(int64_t target_size) = 0;
+  virtual bool seek(uint64_t position) = 0;
 
-    // returns 'false' when we read out of the available file size
-    virtual bool read(void* data, size_t size) = 0;
+  bool seek_cur(uint64_t position_offset)
+  {
+    return seek(get_position() + position_offset);
+  }
 
-    virtual bool seek(int64_t position) = 0;
+  // Informs the reader implementation that we will process data in the given range.
+  // The reader can use this information to retrieve a larger chunk of data instead of individual read() calls.
+  // Returns the file size that was made available, but you still have to check each read() call.
+  // Returning a value shorter than the requested range end indicates to libheif that the data is not available.
+  // Returns 0 on error.
+  virtual uint64_t request_range(uint64_t start, uint64_t end_pos) {
+    return std::numeric_limits<uint64_t>::max();
+  }
 
-    bool seek_cur(int64_t position_offset)
-    {
-      return seek(get_position() + position_offset);
-    }
-  };
+  virtual void release_range(uint64_t start, uint64_t end_pos) { }
 
+  virtual void preload_range_hint(uint64_t start, uint64_t end_pos) { }
 
-  class StreamReader_istream : public StreamReader
-  {
-  public:
-    StreamReader_istream(std::unique_ptr<std::istream>&& istr);
+  Error get_error() const {
+    return m_last_error;
+  }
 
-    int64_t get_position() const override;
+  void clear_last_error() { m_last_error = {}; }
 
-    grow_status wait_for_file_size(int64_t target_size) override;
+protected:
+  Error m_last_error;
+};
 
-    bool read(void* data, size_t size) override;
+#include <iostream>
 
-    bool seek(int64_t position) override;
+class StreamReader_istream : public StreamReader
+{
+public:
+  StreamReader_istream(std::unique_ptr<std::istream>&& istr);
 
-  private:
-    std::unique_ptr<std::istream> m_istr;
-    int64_t m_length;
-  };
+  uint64_t get_position() const override;
 
+  grow_status wait_for_file_size(uint64_t target_size) override;
 
-  class StreamReader_memory : public StreamReader
-  {
-  public:
-    StreamReader_memory(const uint8_t* data, int64_t size, bool copy);
+  bool read(void* data, size_t size) override;
 
-    ~StreamReader_memory();
+  bool seek(uint64_t position) override;
 
-    int64_t get_position() const override;
+  uint64_t request_range(uint64_t start, uint64_t end_pos) override {
+    // std::cout << "[istream] request_range " << start << " - " << end_pos << "\n";
+    return std::min(end_pos, m_length);
+  }
 
-    grow_status wait_for_file_size(int64_t target_size) override;
+  void release_range(uint64_t start, uint64_t end_pos) override {
+    // std::cout << "[istream] release_range " << start << " - " << end_pos << "\n";
+  }
 
-    bool read(void* data, size_t size) override;
+  void preload_range_hint(uint64_t start, uint64_t end_pos) override {
+    // std::cout << "[istream] preload_range_hint " << start << " - " << end_pos << "\n";
+  }
 
-    bool seek(int64_t position) override;
+private:
+  std::unique_ptr<std::istream> m_istr;
+  uint64_t m_length;
+};
 
-  private:
-    const uint8_t* m_data;
-    int64_t m_length;
-    int64_t m_position;
 
-    // if we made a copy of the data, we store a pointer to the owned memory area here
-    uint8_t* m_owned_data = nullptr;
-  };
+class StreamReader_memory : public StreamReader
+{
+public:
+  StreamReader_memory(const uint8_t* data, size_t size, bool copy);
 
+  ~StreamReader_memory() override;
 
-  class StreamReader_CApi : public StreamReader
-  {
-  public:
-    StreamReader_CApi(const heif_reader* func_table, void* userdata);
+  uint64_t get_position() const override;
 
-    int64_t get_position() const override
-    { return m_func_table->get_position(m_userdata); }
+  grow_status wait_for_file_size(uint64_t target_size) override;
 
-    StreamReader::grow_status wait_for_file_size(int64_t target_size) override;
+  bool read(void* data, size_t size) override;
 
-    bool read(void* data, size_t size) override
-    { return !m_func_table->read(data, size, m_userdata); }
+  bool seek(uint64_t position) override;
 
-    bool seek(int64_t position) override
-    { return !m_func_table->seek(position, m_userdata); }
+  // end_pos is last byte to read + 1. I.e. like a file size.
+  uint64_t request_range(uint64_t start, uint64_t end_pos) override {
+    return m_length;
+  }
 
-  private:
-    const heif_reader* m_func_table;
-    void* m_userdata;
-  };
+private:
+  const uint8_t* m_data;
+  uint64_t m_length;
+  uint64_t m_position;
 
+  // if we made a copy of the data, we store a pointer to the owned memory area here
+  uint8_t* m_owned_data = nullptr;
+};
 
-  // This class simplifies safely reading part of a file (e.g. a box).
-  // It makes sure that we do not read past the boundaries of a box.
-  class BitstreamRange
-  {
-  public:
-    BitstreamRange(std::shared_ptr<StreamReader> istr,
-                   uint64_t length,
-                   BitstreamRange* parent = nullptr);
 
-    // This function tries to make sure that the full data of this range is
-    // available. You should call this before starting reading the range.
-    // If you don't, you have to make sure that you do not read past the available data.
-    StreamReader::grow_status wait_until_range_is_available();
+class StreamReader_CApi : public StreamReader
+{
+public:
+  StreamReader_CApi(const heif_reader* func_table, void* userdata);
 
-    uint8_t read8();
+  uint64_t get_position() const override { return m_func_table->get_position(m_userdata); }
 
-    uint16_t read16();
+  StreamReader::grow_status wait_for_file_size(uint64_t target_size) override;
 
-    uint32_t read32();
+  bool read(void* data, size_t size) override { return !m_func_table->read(data, size, m_userdata); }
 
-    std::string read_string();
+  bool seek(uint64_t position) override { return !m_func_table->seek(position, m_userdata); }
 
-    bool read(uint8_t* data, int64_t n);
+  uint64_t request_range(uint64_t start, uint64_t end_pos) override {
+    if (m_func_table->reader_api_version >= 2) {
+      heif_reader_range_request_result result = m_func_table->request_range(start, end_pos, m_userdata);
 
-    bool prepare_read(int64_t nBytes);
+      // convert error message string and release input string memory
 
-    StreamReader::grow_status wait_for_available_bytes(int64_t nBytes);
+      std::string error_msg;
+      if (result.reader_error_msg) {
+        error_msg = std::string{result.reader_error_msg};
 
-    void skip_to_end_of_file()
-    {
-      // we do not actually move the file position here (because the stream may still be incomplete),
-      // but we set all m_remaining to zero
-      m_remaining = 0;
+        if (m_func_table->release_error_msg) {
+          m_func_table->release_error_msg(result.reader_error_msg);
+        }
+      }
 
-      if (m_parent_range) {
-        m_parent_range->skip_to_end_of_file();
+      switch (result.status) {
+        case heif_reader_grow_status_size_reached:
+          return end_pos;
+        case heif_reader_grow_status_timeout:
+          return 0; // invalid return value from callback
+        case heif_reader_grow_status_size_beyond_eof:
+          m_last_error = {heif_error_Invalid_input, heif_suberror_End_of_data, "Read beyond file size"};
+          return result.range_end;
+        case heif_reader_grow_status_error: {
+          if (result.reader_error_msg) {
+            std::stringstream sstr;
+            sstr << "Input error (" << result.reader_error_code << ") : " << error_msg;
+            m_last_error = {heif_error_Invalid_input, heif_suberror_Unspecified, sstr.str()};
+          }
+          else {
+            std::stringstream sstr;
+            sstr << "Input error (" << result.reader_error_code << ")";
+            m_last_error = {heif_error_Invalid_input, heif_suberror_Unspecified, sstr.str()};
+          }
+
+          return 0; // error occurred
+        }
+        default:
+          m_last_error = {heif_error_Invalid_input, heif_suberror_Unspecified, "Invalid input reader return value"};
+          return 0;
       }
     }
+    else {
+      auto result = m_func_table->wait_for_file_size(end_pos, m_userdata);
+      if (result == heif_reader_grow_status_size_reached) {
+        return end_pos;
+      }
+      else {
+        uint64_t pos = m_func_table->get_position(m_userdata);
+        return bisect_filesize(pos,end_pos);
+      }
+    }
+  }
 
-    void skip_to_end_of_box()
-    {
-      if (m_remaining > 0) {
-        if (m_parent_range) {
-          // also advance position in parent range
-          m_parent_range->skip_without_advancing_file_pos(m_remaining);
-        }
+  uint64_t bisect_filesize(uint64_t mini, uint64_t maxi) {
+    // mini - <= filesize
+    // maxi - >  filesize
 
-        m_istr->seek_cur(m_remaining);
-        m_remaining = 0;
-      }
+    if (maxi == mini + 1) {
+      return mini;
     }
 
-    void set_eof_while_reading()
-    {
-      m_remaining = 0;
+    uint64_t pos = (mini + maxi) / 2;
+    auto result = m_func_table->wait_for_file_size(pos, m_userdata);
+    if (result == heif_reader_grow_status_size_reached) {
+      return bisect_filesize(pos, maxi);
+    }
+    else {
+      return bisect_filesize(mini, pos);
+    }
+  }
 
-      if (m_parent_range) {
-        m_parent_range->set_eof_while_reading();
-      }
+  void release_range(uint64_t start, uint64_t end_pos) override {
+    if (m_func_table->reader_api_version >= 2) {
+      m_func_table->release_file_range(start, end_pos, m_userdata);
+    }
+  }
 
-      m_error = true;
+  void preload_range_hint(uint64_t start, uint64_t end_pos) override {
+    if (m_func_table->reader_api_version >= 2) {
+      m_func_table->preload_range_hint(start, end_pos, m_userdata);
     }
+  }
+
+private:
+  const heif_reader* m_func_table;
+  void* m_userdata;
+};
+
+
+// This class simplifies safely reading part of a file (e.g. a box).
+// It makes sure that we do not read past the boundaries of a box.
+class BitstreamRange
+{
+public:
+  BitstreamRange(std::shared_ptr<StreamReader> istr,
+                 size_t length,
+                 BitstreamRange* parent = nullptr);
+
+  BitstreamRange(std::shared_ptr<StreamReader> istr,
+                 size_t start,
+                 size_t end); // one past end
+
+  // This function tries to make sure that the full data of this range is
+  // available. You should call this before starting reading the range.
+  // If you don't, you have to make sure that you do not read past the available data.
+  StreamReader::grow_status wait_until_range_is_available();
+
+  uint8_t read8();
+
+  uint16_t read16();
+
+  int16_t read16s();
+
+  /**
+   * Read 24 bit unsigned integer from the bitstream.
+   *
+   * The data is assumed to be in big endian format and is returned as a 32 bit value.
+   */
+  uint32_t read24();
+
+  uint32_t read32();
+
+  int32_t read32s();
+
+  uint64_t read64();
+
+  uint64_t read_uint(int len);
+
+  /**
+   * Read 32 bit floating point value from the bitstream.
+   *
+   * The file data is assumed to be in big endian format.
+   */
+  float read_float32();
+
+  int64_t read64s();
+
+  std::string read_string();
+
+  // A string stored with a fixed number of bytes. The first byte contains the string length and the extra bytes
+  // are filled with a padding 0.
+  std::string read_fixed_string(int len);
+
+  std::string read_string_until_eof();
 
-    bool eof() const
-    {
-      return m_remaining == 0;
+  bool read(uint8_t* data, size_t n);
+
+  bool prepare_read(size_t nBytes);
+
+  StreamReader::grow_status wait_for_available_bytes(size_t nBytes);
+
+  void skip_to_end_of_file()
+  {
+    // we do not actually move the file position here (because the stream may still be incomplete),
+    // but we set all m_remaining to zero
+    m_remaining = 0;
+
+    if (m_parent_range) {
+      m_parent_range->skip_to_end_of_file();
     }
+  }
+
+  void skip(uint64_t n)
+  {
+    size_t actual_skip = std::min(static_cast<size_t>(n), m_remaining);
 
-    bool error() const
-    {
-      return m_error;
+    if (m_parent_range) {
+      // also advance position in parent range
+      m_parent_range->skip_without_advancing_file_pos(actual_skip);
     }
 
-    Error get_error() const
-    {
-      if (m_error) {
-        return Error(heif_error_Invalid_input,
-                     heif_suberror_End_of_data);
-      }
-      else {
-        return Error::Ok;
+    assert(actual_skip <= static_cast<uint64_t>(std::numeric_limits<int64_t>::max()));
+
+    m_istr->seek_cur(static_cast<int64_t>(actual_skip));
+    m_remaining -= actual_skip;
+  }
+
+  void skip_to_end_of_box()
+  {
+    if (m_remaining > 0) {
+      if (m_parent_range) {
+        // also advance position in parent range
+        m_parent_range->skip_without_advancing_file_pos(m_remaining);
       }
+
+      m_istr->seek_cur(m_remaining);
+      m_remaining = 0;
     }
+  }
 
-    std::shared_ptr<StreamReader> get_istream()
-    { return m_istr; }
+  void set_eof_while_reading()
+  {
+    m_remaining = 0;
 
-    int get_nesting_level() const
-    { return m_nesting_level; }
+    if (m_parent_range) {
+      m_parent_range->set_eof_while_reading();
+    }
 
-    int64_t get_remaining_bytes() const
-    { return m_remaining; }
+    m_error = true;
+  }
 
-  private:
-    std::shared_ptr<StreamReader> m_istr;
-    BitstreamRange* m_parent_range = nullptr;
-    int m_nesting_level = 0;
+  bool eof() const
+  {
+    return m_remaining == 0;
+  }
 
-    int64_t m_remaining;
-    bool m_error = false;
+  bool error() const
+  {
+    return m_error;
+  }
 
-    // Note: 'nBytes' may not be larger than the number of remaining bytes
-    void skip_without_advancing_file_pos(int64_t nBytes);
-  };
+  Error get_error() const
+  {
+    if (m_error) {
+      return Error(heif_error_Invalid_input,
+                   heif_suberror_End_of_data);
+    }
+    else {
+      return Error::Ok;
+    }
+  }
 
+  std::shared_ptr<StreamReader> get_istream() { return m_istr; }
 
-  class BitReader
-  {
-  public:
-    BitReader(const uint8_t* buffer, int len);
+  int get_nesting_level() const { return m_nesting_level; }
 
-    int get_bits(int n);
+  size_t get_remaining_bytes() const { return m_remaining; }
 
-    int get_bits_fast(int n);
+private:
+  std::shared_ptr<StreamReader> m_istr;
+  BitstreamRange* m_parent_range = nullptr;
+  int m_nesting_level = 0;
 
-    int peek_bits(int n);
+  size_t m_remaining;
+  bool m_error = false;
 
-    void skip_bytes(int nBytes);
+  // Note: 'nBytes' may not be larger than the number of remaining bytes
+  void skip_without_advancing_file_pos(size_t nBytes);
+};
 
-    void skip_bits(int n);
 
-    void skip_bits_fast(int n);
+class BitReader
+{
+public:
+  BitReader(const uint8_t* buffer, int len);
 
-    void skip_to_byte_boundary();
+  void reset();
 
-    bool get_uvlc(int* value);
+  uint32_t get_bits(int n);
 
-    bool get_svlc(int* value);
+  uint8_t get_bits8(int n);
 
-    int get_current_byte_index() const
-    {
-      return data_length - bytes_remaining - nextbits_cnt / 8;
-    }
+  uint16_t get_bits16(int n);
 
-    int64_t get_bits_remaining() const
-    {
-      return bytes_remaining*8 + nextbits_cnt;
-    }
+  uint32_t get_bits32(int n);
 
-  private:
-    const uint8_t* data;
-    int data_length;
-    int bytes_remaining;
+  int32_t get_bits32s();
 
-    uint64_t nextbits; // left-aligned bits
-    int nextbits_cnt;
+  /**
+   * Get a one-bit flag value.
+   *
+   * @returns true if the next bit value is 1, otherwise false
+   */
+  bool get_flag();
 
-    void refill(); // refill to at least 56+1 bits
-  };
+  std::vector<uint8_t> read_bytes(uint32_t n);
+
+  int get_bits_fast(int n);
+
+  int peek_bits(int n);
+
+  void skip_bytes(int nBytes);
 
+  void skip_bits(int n);
 
-  class StreamWriter
+  void skip_bits_fast(int n);
+
+  void skip_to_byte_boundary();
+
+  bool get_uvlc(int* value);
+
+  bool get_svlc(int* value);
+
+  int get_current_byte_index() const
   {
-  public:
-    void write8(uint8_t);
+    return data_length - bytes_remaining - nextbits_cnt / 8;
+  }
 
-    void write16(uint16_t);
+  int64_t get_bits_remaining() const
+  {
+    return ((int64_t) bytes_remaining) * 8 + nextbits_cnt;
+  }
 
-    void write32(uint32_t);
+private:
+  const uint8_t* const data_start;
+  const uint8_t* data;
+  const int data_length;
+  int bytes_remaining;
 
-    void write64(uint64_t);
+  uint64_t nextbits; // left-aligned bits
+  int nextbits_cnt;
 
-    void write(int size, uint64_t value);
+  void refill(); // refill to at least 56+1 bits
+};
 
-    void write(const std::string&);
 
-    void write(const std::vector<uint8_t>&);
+class StreamWriter
+{
+public:
+  void write8(uint8_t);
 
-    void write(const StreamWriter&);
+  void write16(uint16_t);
 
-    void skip(int n);
+  void write16s(int16_t);
 
-    void insert(int nBytes);
+  void write24(uint32_t);
 
-    size_t data_size() const
-    { return m_data.size(); }
+  void write32(uint32_t);
 
-    size_t get_position() const
-    { return m_position; }
+  void write32s(int32_t);
 
-    void set_position(size_t pos)
-    { m_position = pos; }
+  void write64(uint64_t);
 
-    void set_position_to_end()
-    { m_position = m_data.size(); }
+  void write_float32(float);
 
-    const std::vector<uint8_t> get_data() const
-    { return m_data; }
+  void write64s(int64_t);
 
-  private:
-    std::vector<uint8_t> m_data;
-    size_t m_position = 0;
-  };
-}
+  void write(int size, uint64_t value);
+
+  void write(const std::string&, bool end_with_null = true);
+
+  void write_fixed_string(std::string s, size_t len);
+
+  void write(const std::vector<uint8_t>&);
+
+  void write(const StreamWriter&);
+
+  void skip(int n);
+
+  void insert(int nBytes);
+
+  size_t data_size() const { return m_data.size(); }
+
+  size_t get_position() const { return m_position; }
+
+  void set_position(size_t pos) { m_position = pos; }
+
+  void set_position_to_end() { m_position = m_data.size(); }
+
+  const std::vector<uint8_t> get_data() const { return m_data; }
+
+private:
+  std::vector<uint8_t> m_data;
+  size_t m_position = 0;
+};
 
 #endif
diff --git a/libheif/box.cc b/libheif/box.cc
index ce5362a521..fd3c001dd5 100644
--- a/libheif/box.cc
+++ b/libheif/box.cc
@@ -1,6 +1,6 @@
 /*
  * HEIF codec.
- * Copyright (c) 2017 struktur AG, Dirk Farin <farin@struktur.de>
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
  *
  * This file is part of libheif.
  *
@@ -17,26 +17,47 @@
  * You should have received a copy of the GNU Lesser General Public License
  * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
  */
-#if defined(HAVE_CONFIG_H)
-#include "config.h"
-#endif
-
+#include "libheif/heif.h"
+#include <cstddef>
+#include <cstdint>
 #include "box.h"
-#include "heif_limits.h"
+#include "security_limits.h"
 #include "nclx.h"
+#include "codecs/jpeg_boxes.h"
+#include "codecs/jpeg2000_boxes.h"
+#include "codecs/hevc_boxes.h"
+#include "image-items/mask_image.h"
+#include "codecs/vvc_boxes.h"
+#include "codecs/avc_boxes.h"
+#include "codecs/avif_boxes.h"
+#include "image-items/tiled.h"
+#include "sequences/seq_boxes.h"
 
 #include <iomanip>
 #include <utility>
 #include <iostream>
 #include <algorithm>
 #include <cstring>
+#include <set>
 #include <cassert>
+#include <array>
+#include <mutex>
 
 
-using namespace heif;
+#if WITH_UNCOMPRESSED_CODEC
+#include "codecs/uncompressed/unc_boxes.h"
+#endif
 
+#ifndef M_PI
+#define M_PI 3.14159265358979323846
+#endif
 
-heif::Error heif::Error::Ok(heif_error_Ok);
+#if !defined(_WIN32)
+#include <unistd.h>
+#else
+#include <fcntl.h>
+#include <io.h>
+#endif
 
 
 Fraction::Fraction(int32_t num, int32_t den)
@@ -53,7 +74,7 @@ Fraction::Fraction(int32_t num, int32_t den)
     denominator /= 2;
   }
 
-  while (numerator > MAX_FRACTION_VALUE || numerator < -MAX_FRACTION_VALUE) {
+  while (denominator > 1 && (numerator > MAX_FRACTION_VALUE || numerator < -MAX_FRACTION_VALUE)) {
     numerator /= 2;
     denominator /= 2;
   }
@@ -61,62 +82,80 @@ Fraction::Fraction(int32_t num, int32_t den)
 
 Fraction::Fraction(uint32_t num, uint32_t den)
 {
-  assert(num <= std::numeric_limits<int32_t>::max());
-  assert(den <= std::numeric_limits<int32_t>::max());
+  assert(num <= (uint32_t) std::numeric_limits<int32_t>::max());
+  assert(den <= (uint32_t) std::numeric_limits<int32_t>::max());
 
   *this = Fraction(int32_t(num), int32_t(den));
 }
 
+Fraction::Fraction(int64_t num, int64_t den)
+{
+  while (num < std::numeric_limits<int32_t>::min() || num > std::numeric_limits<int32_t>::max() ||
+         den < std::numeric_limits<int32_t>::min() || den > std::numeric_limits<int32_t>::max()) {
+    num = (num + (num>=0 ? 1 : -1)) / 2;
+    den = (den + (den>=0 ? 1 : -1)) / 2;
+  }
+
+  numerator = static_cast<int32_t>(num);
+  denominator = static_cast<int32_t>(den);
+}
+
 Fraction Fraction::operator+(const Fraction& b) const
 {
   if (denominator == b.denominator) {
-    return Fraction{numerator + b.numerator, denominator};
+    int64_t n = int64_t{numerator} + b.numerator;
+    int64_t d = denominator;
+    return Fraction{n,d};
   }
   else {
-    return Fraction{numerator * b.denominator + b.numerator * denominator,
-                    denominator * b.denominator};
+    int64_t n = int64_t{numerator} * b.denominator + int64_t{b.numerator} * denominator;
+    int64_t d = int64_t{denominator} * b.denominator;
+    return Fraction{n,d};
   }
 }
 
 Fraction Fraction::operator-(const Fraction& b) const
 {
   if (denominator == b.denominator) {
-    return Fraction{numerator - b.numerator, denominator};
+    int64_t n = int64_t{numerator} - b.numerator;
+    int64_t d = denominator;
+    return Fraction{n,d};
   }
   else {
-    return Fraction{numerator * b.denominator - b.numerator * denominator,
-                    denominator * b.denominator};
+    int64_t n = int64_t{numerator} * b.denominator - int64_t{b.numerator} * denominator;
+    int64_t d = int64_t{denominator} * b.denominator;
+    return Fraction{n,d};
   }
 }
 
 Fraction Fraction::operator+(int v) const
 {
-  return Fraction{numerator + v * denominator, denominator};
+  return Fraction{numerator + v * int64_t(denominator), int64_t(denominator)};
 }
 
 Fraction Fraction::operator-(int v) const
 {
-  return Fraction{numerator - v * denominator, denominator};
+  return Fraction{numerator - v * int64_t(denominator), int64_t(denominator)};
 }
 
 Fraction Fraction::operator/(int v) const
 {
-  return Fraction{numerator, denominator * v};
+  return Fraction{int64_t(numerator), int64_t(denominator) * v};
 }
 
-int Fraction::round_down() const
+int32_t Fraction::round_down() const
 {
   return numerator / denominator;
 }
 
-int Fraction::round_up() const
+int32_t Fraction::round_up() const
 {
-  return (numerator + denominator - 1) / denominator;
+  return int32_t((numerator + int64_t(denominator) - 1) / denominator);
 }
 
-int Fraction::round() const
+int32_t Fraction::round() const
 {
-  return (numerator + denominator / 2) / denominator;
+  return int32_t((numerator + int64_t(denominator) / 2) / denominator);
 }
 
 bool Fraction::is_valid() const
@@ -124,32 +163,11 @@ bool Fraction::is_valid() const
   return denominator != 0;
 }
 
-uint32_t from_fourcc(const char* string)
-{
-  return ((string[0] << 24) |
-          (string[1] << 16) |
-          (string[2] << 8) |
-          (string[3]));
-}
-
-static std::string to_fourcc(uint32_t code)
-{
-  std::string str("    ");
-  str[0] = static_cast<char>((code >> 24) & 0xFF);
-  str[1] = static_cast<char>((code >> 16) & 0xFF);
-  str[2] = static_cast<char>((code >> 8) & 0xFF);
-  str[3] = static_cast<char>((code >> 0) & 0xFF);
-
-  return str;
-}
-
 
-heif::BoxHeader::BoxHeader()
-{
-}
+BoxHeader::BoxHeader() = default;
 
 
-std::vector<uint8_t> heif::BoxHeader::get_type() const
+std::vector<uint8_t> BoxHeader::get_type() const
 {
   if (m_type == fourcc("uuid")) {
     return m_uuid_type;
@@ -165,7 +183,7 @@ std::vector<uint8_t> heif::BoxHeader::get_type() const
 }
 
 
-std::string heif::BoxHeader::get_type_string() const
+std::string BoxHeader::get_type_string() const
 {
   if (m_type == fourcc("uuid")) {
     // 8-4-4-4-12
@@ -173,29 +191,46 @@ std::string heif::BoxHeader::get_type_string() const
     std::ostringstream sstr;
     sstr << std::hex;
     sstr << std::setfill('0');
-    sstr << std::setw(2);
 
     for (int i = 0; i < 16; i++) {
       if (i == 4 || i == 6 || i == 8 || i == 10) {
         sstr << '-';
       }
 
+      sstr << std::setw(2);
       sstr << ((int) m_uuid_type[i]);
     }
 
     return sstr.str();
   }
   else {
-    return to_fourcc(m_type);
+    return fourcc_to_string(m_type);
+  }
+}
+
+
+std::vector<uint8_t> BoxHeader::get_uuid_type() const
+{
+  if (m_type != fourcc("uuid")) {
+    return {};
   }
+
+  return m_uuid_type;
+}
+
+
+void BoxHeader::set_uuid_type(const std::vector<uint8_t>& type)
+{
+  m_type = fourcc("uuid");
+  m_uuid_type = type;
 }
 
 
-heif::Error heif::BoxHeader::parse(BitstreamRange& range)
+Error BoxHeader::parse_header(BitstreamRange& range)
 {
   StreamReader::grow_status status;
   status = range.wait_for_available_bytes(8);
-  if (status != StreamReader::size_reached) {
+  if (status != StreamReader::grow_status::size_reached) {
     // TODO: return recoverable error at timeout
     return Error(heif_error_Invalid_input,
                  heif_suberror_End_of_data);
@@ -208,7 +243,7 @@ heif::Error heif::BoxHeader::parse(BitstreamRange& range)
 
   if (m_size == 1) {
     status = range.wait_for_available_bytes(8);
-    if (status != StreamReader::size_reached) {
+    if (status != StreamReader::grow_status::size_reached) {
       // TODO: return recoverable error at timeout
       return Error(heif_error_Invalid_input,
                    heif_suberror_End_of_data);
@@ -232,7 +267,7 @@ heif::Error heif::BoxHeader::parse(BitstreamRange& range)
 
   if (m_type == fourcc("uuid")) {
     status = range.wait_for_available_bytes(16);
-    if (status != StreamReader::size_reached) {
+    if (status != StreamReader::grow_status::size_reached) {
       // TODO: return recoverable error at timeout
       return Error(heif_error_Invalid_input,
                    heif_suberror_End_of_data);
@@ -240,7 +275,9 @@ heif::Error heif::BoxHeader::parse(BitstreamRange& range)
 
     if (range.prepare_read(16)) {
       m_uuid_type.resize(16);
-      range.get_istream()->read((char*) m_uuid_type.data(), 16);
+      bool success = range.get_istream()->read((char*) m_uuid_type.data(), 16);
+      assert(success);
+      (void) success;
     }
 
     m_header_size += 16;
@@ -250,11 +287,27 @@ heif::Error heif::BoxHeader::parse(BitstreamRange& range)
 }
 
 
-size_t heif::BoxHeader::reserve_box_header_space(StreamWriter& writer) const
+int Box::calculate_header_size(bool data64bit) const
+{
+  int header_size = 8;  // does not include "FullBox" fields.
+
+  if (get_short_type() == fourcc("uuid")) {
+    header_size += 16;
+  }
+
+  if (data64bit) {
+    header_size += 8;
+  }
+
+  return header_size;
+}
+
+
+size_t Box::reserve_box_header_space(StreamWriter& writer, bool data64bit) const
 {
   size_t start_pos = writer.get_position();
 
-  int header_size = is_full_box_header() ? (8 + 4) : 8;
+  int header_size = calculate_header_size(data64bit);
 
   writer.skip(header_size);
 
@@ -262,70 +315,75 @@ size_t heif::BoxHeader::reserve_box_header_space(StreamWriter& writer) const
 }
 
 
-heif::Error heif::BoxHeader::prepend_header(StreamWriter& writer, size_t box_start) const
+size_t FullBox::reserve_box_header_space(StreamWriter& writer, bool data64bit) const
 {
-  const int reserved_header_size = is_full_box_header() ? (8 + 4) : 8;
+  size_t start_pos = Box::reserve_box_header_space(writer, data64bit);
 
+  writer.skip(4);
 
-  // determine header size
-
-  int header_size = 0;
+  return start_pos;
+}
 
-  header_size += 8; // normal header size
 
-  if (is_full_box_header()) {
-    header_size += 4;
+Error FullBox::write_header(StreamWriter& writer, size_t total_size, bool data64bit) const
+{
+  auto err = Box::write_header(writer, total_size, data64bit);
+  if (err) {
+    return err;
   }
 
-  if (m_type == fourcc("uuid")) {
-    header_size += 16;
-  }
+  assert((get_flags() & ~0x00FFFFFFU) == 0);
+
+  writer.write32((get_version() << 24) | get_flags());
 
-  bool large_size = false;
+  return Error::Ok;
+}
 
-  size_t data_size = writer.data_size() - box_start - reserved_header_size;
 
-  if (data_size + header_size > 0xFFFFFFFF) {
-    header_size += 8;
-    large_size = true;
-  }
+Error Box::prepend_header(StreamWriter& writer, size_t box_start, bool data64bit) const
+{
+  size_t total_size = writer.data_size() - box_start;
+
+  writer.set_position(box_start);
+
+  auto err = write_header(writer, total_size, data64bit);
+
+  writer.set_position_to_end();  // Note: should we move to the end of the box after writing the header?
+
+  return err;
+}
 
-  size_t box_size = data_size + header_size;
 
+Error Box::write_header(StreamWriter& writer, size_t total_size, bool data64bit) const
+{
+  bool large_size = (total_size > 0xFFFFFFFF);
 
   // --- write header
 
-  writer.set_position(box_start);
-  assert(header_size >= reserved_header_size);
-  writer.insert(header_size - reserved_header_size);
+  if (large_size && !data64bit) {
+    // Note: as an alternative, we could return an error here. If it fails, the user has to try again with 64 bit.
+    writer.insert(8);
+  }
 
   if (large_size) {
     writer.write32(1);
   }
   else {
-    assert(box_size <= 0xFFFFFFFF);
-    writer.write32((uint32_t) box_size);
+    assert(total_size <= 0xFFFFFFFF);
+    writer.write32((uint32_t) total_size);
   }
 
-  writer.write32(m_type);
+  writer.write32(get_short_type());
 
   if (large_size) {
-    writer.write64(box_size);
+    writer.write64(total_size);
   }
 
-  if (m_type == fourcc("uuid")) {
-    assert(m_uuid_type.size() == 16);
-    writer.write(m_uuid_type);
-  }
-
-  if (is_full_box_header()) {
-    assert((m_flags & ~0x00FFFFFF) == 0);
-
-    writer.write32((m_version << 24) | m_flags);
+  if (get_short_type() == fourcc("uuid")) {
+    assert(get_type().size() == 16);
+    writer.write(get_type());
   }
 
-  writer.set_position_to_end();  // Note: should we move to the end of the box after writing the header?
-
   return Error::Ok;
 }
 
@@ -333,19 +391,22 @@ heif::Error heif::BoxHeader::prepend_header(StreamWriter& writer, size_t box_sta
 std::string BoxHeader::dump(Indent& indent) const
 {
   std::ostringstream sstr;
-  sstr << indent << "Box: " << get_type_string() << " -----\n";
-  sstr << indent << "size: " << get_box_size() << "   (header size: " << get_header_size() << ")\n";
-
-  if (m_is_full_box) {
-    sstr << indent << "version: " << ((int) m_version) << "\n"
-         << indent << "flags: " << std::hex << m_flags << "\n";
+  sstr << indent << "Box: " << get_type_string();
+  const char* debug_name = debug_box_name();
+  if (debug_name) {
+    sstr << " ----- (" << debug_name << ")\n";
   }
+  else {
+    sstr << " -----\n";
+  }
+
+  sstr << indent << "size: " << get_box_size() << "   (header size: " << get_header_size() << ")\n";
 
   return sstr.str();
 }
 
 
-Error Box::parse(BitstreamRange& range)
+Error Box::parse(BitstreamRange& range, const heif_security_limits* limits)
 {
   // skip box
 
@@ -354,12 +415,15 @@ Error Box::parse(BitstreamRange& range)
   }
   else {
     uint64_t content_size = get_box_size() - get_header_size();
-    if (range.prepare_read(content_size)) {
-      if (content_size > MAX_BOX_SIZE) {
-        return Error(heif_error_Invalid_input,
-                     heif_suberror_Invalid_box_size);
-      }
 
+    assert(MAX_BOX_SIZE <= SIZE_MAX);
+
+    if (content_size > MAX_BOX_SIZE) {
+      return Error(heif_error_Invalid_input,
+                   heif_suberror_Invalid_box_size);
+    }
+
+    if (range.prepare_read(static_cast<size_t>(content_size))) {
       range.get_istream()->seek_cur(get_box_size() - get_header_size());
     }
   }
@@ -371,12 +435,12 @@ Error Box::parse(BitstreamRange& range)
 }
 
 
-Error BoxHeader::parse_full_box_header(BitstreamRange& range)
+Error FullBox::parse_full_box_header(BitstreamRange& range)
 {
   uint32_t data = range.read32();
   m_version = static_cast<uint8_t>(data >> 24);
   m_flags = data & 0x00FFFFFF;
-  m_is_full_box = true;
+  //m_is_full_box = true;
 
   m_header_size += 4;
 
@@ -384,10 +448,10 @@ Error BoxHeader::parse_full_box_header(BitstreamRange& range)
 }
 
 
-Error Box::read(BitstreamRange& range, std::shared_ptr<heif::Box>* result)
+Error Box::read(BitstreamRange& range, std::shared_ptr<Box>* result, const heif_security_limits* limits)
 {
   BoxHeader hdr;
-  Error err = hdr.parse(range);
+  Error err = hdr.parse_header(range);
   if (err) {
     return err;
   }
@@ -396,1148 +460,2889 @@ Error Box::read(BitstreamRange& range, std::shared_ptr<heif::Box>* result)
     return range.get_error();
   }
 
+  result->reset();
+
   std::shared_ptr<Box> box;
 
   switch (hdr.get_short_type()) {
     case fourcc("ftyp"):
-      box = std::make_shared<Box_ftyp>(hdr);
+      box = std::make_shared<Box_ftyp>();
+      break;
+
+    case fourcc("free"):
+    case fourcc("skip"):
+      box = std::make_shared<Box_free>();
       break;
 
     case fourcc("meta"):
-      box = std::make_shared<Box_meta>(hdr);
+      box = std::make_shared<Box_meta>();
       break;
 
     case fourcc("hdlr"):
-      box = std::make_shared<Box_hdlr>(hdr);
+      box = std::make_shared<Box_hdlr>();
       break;
 
     case fourcc("pitm"):
-      box = std::make_shared<Box_pitm>(hdr);
+      box = std::make_shared<Box_pitm>();
       break;
 
     case fourcc("iloc"):
-      box = std::make_shared<Box_iloc>(hdr);
+      box = std::make_shared<Box_iloc>();
       break;
 
     case fourcc("iinf"):
-      box = std::make_shared<Box_iinf>(hdr);
+      box = std::make_shared<Box_iinf>();
       break;
 
     case fourcc("infe"):
-      box = std::make_shared<Box_infe>(hdr);
+      box = std::make_shared<Box_infe>();
       break;
 
     case fourcc("iprp"):
-      box = std::make_shared<Box_iprp>(hdr);
+      box = std::make_shared<Box_iprp>();
       break;
 
     case fourcc("ipco"):
-      box = std::make_shared<Box_ipco>(hdr);
+      box = std::make_shared<Box_ipco>();
       break;
 
     case fourcc("ipma"):
-      box = std::make_shared<Box_ipma>(hdr);
+      box = std::make_shared<Box_ipma>();
       break;
 
     case fourcc("ispe"):
-      box = std::make_shared<Box_ispe>(hdr);
+      box = std::make_shared<Box_ispe>();
       break;
 
     case fourcc("auxC"):
-      box = std::make_shared<Box_auxC>(hdr);
+      box = std::make_shared<Box_auxC>();
       break;
 
     case fourcc("irot"):
-      box = std::make_shared<Box_irot>(hdr);
+      box = std::make_shared<Box_irot>();
       break;
 
     case fourcc("imir"):
-      box = std::make_shared<Box_imir>(hdr);
+      box = std::make_shared<Box_imir>();
       break;
 
     case fourcc("clap"):
-      box = std::make_shared<Box_clap>(hdr);
+      box = std::make_shared<Box_clap>();
       break;
 
     case fourcc("iref"):
-      box = std::make_shared<Box_iref>(hdr);
+      box = std::make_shared<Box_iref>();
       break;
 
     case fourcc("hvcC"):
-      box = std::make_shared<Box_hvcC>(hdr);
+      box = std::make_shared<Box_hvcC>();
+      break;
+
+    case fourcc("hvc1"):
+      box = std::make_shared<Box_hvc1>();
       break;
 
     case fourcc("av1C"):
-      box = std::make_shared<Box_av1C>(hdr);
+      box = std::make_shared<Box_av1C>();
+      break;
+
+    case fourcc("av01"):
+      box = std::make_shared<Box_av01>();
+      break;
+
+    case fourcc("vvcC"):
+      box = std::make_shared<Box_vvcC>();
+      break;
+
+    case fourcc("vvc1"):
+      box = std::make_shared<Box_vvc1>();
       break;
 
     case fourcc("idat"):
-      box = std::make_shared<Box_idat>(hdr);
+      box = std::make_shared<Box_idat>();
       break;
 
     case fourcc("grpl"):
-      box = std::make_shared<Box_grpl>(hdr);
+      box = std::make_shared<Box_grpl>();
+      break;
+
+    case fourcc("pymd"):
+      box = std::make_shared<Box_pymd>();
+      break;
+
+    case fourcc("altr"):
+      box = std::make_shared<Box_EntityToGroup>();
+      break;
+
+    case fourcc("ster"):
+      box = std::make_shared<Box_ster>();
       break;
 
     case fourcc("dinf"):
-      box = std::make_shared<Box_dinf>(hdr);
+      box = std::make_shared<Box_dinf>();
       break;
 
     case fourcc("dref"):
-      box = std::make_shared<Box_dref>(hdr);
+      box = std::make_shared<Box_dref>();
       break;
 
     case fourcc("url "):
-      box = std::make_shared<Box_url>(hdr);
+      box = std::make_shared<Box_url>();
       break;
 
     case fourcc("colr"):
-      box = std::make_shared<Box_colr>(hdr);
+      box = std::make_shared<Box_colr>();
       break;
 
     case fourcc("pixi"):
-      box = std::make_shared<Box_pixi>(hdr);
+      box = std::make_shared<Box_pixi>();
       break;
 
-    default:
-      box = std::make_shared<Box>(hdr);
+    case fourcc("pasp"):
+      box = std::make_shared<Box_pasp>();
       break;
-  }
 
-  if (hdr.get_box_size() < hdr.get_header_size()) {
-    std::stringstream sstr;
-    sstr << "Box size (" << hdr.get_box_size() << " bytes) smaller than header size ("
-         << hdr.get_header_size() << " bytes)";
+    case fourcc("lsel"):
+      box = std::make_shared<Box_lsel>();
+      break;
 
-    // Sanity check.
-    return Error(heif_error_Invalid_input,
-                 heif_suberror_Invalid_box_size,
-                 sstr.str());
-  }
+    case fourcc("a1op"):
+      box = std::make_shared<Box_a1op>();
+      break;
 
+    case fourcc("a1lx"):
+      box = std::make_shared<Box_a1lx>();
+      break;
 
-  if (range.get_nesting_level() > MAX_BOX_NESTING_LEVEL) {
-    return Error(heif_error_Memory_allocation_error,
-                 heif_suberror_Security_limit_exceeded,
-                 "Security limit for maximum nesting of boxes has been exceeded");
-  }
+    case fourcc("clli"):
+      box = std::make_shared<Box_clli>();
+      break;
 
+    case fourcc("mdcv"):
+      box = std::make_shared<Box_mdcv>();
+      break;
 
-  auto status = range.wait_for_available_bytes(hdr.get_box_size() - hdr.get_header_size());
-  if (status != StreamReader::size_reached) {
-    // TODO: return recoverable error at timeout
-    return Error(heif_error_Invalid_input,
-                 heif_suberror_End_of_data);
-  }
+    case fourcc("amve"):
+      box = std::make_shared<Box_amve>();
+      break;
 
+    case fourcc("cmin"):
+      box = std::make_shared<Box_cmin>();
+      break;
 
-  // Security check: make sure that box size does not exceed int64 size.
+    case fourcc("cmex"):
+      box = std::make_shared<Box_cmex>();
+      break;
 
-  if (hdr.get_box_size() > (uint64_t) std::numeric_limits<int64_t>::max()) {
-    return Error(heif_error_Invalid_input,
-                 heif_suberror_Invalid_box_size);
-  }
+    case fourcc("udes"):
+      box = std::make_shared<Box_udes>();
+      break;
 
-  int64_t box_size = static_cast<int64_t>(hdr.get_box_size());
-  int64_t box_size_without_header = box_size - hdr.get_header_size();
+    case fourcc("jpgC"):
+      box = std::make_shared<Box_jpgC>();
+      break;
 
-  // Box size may not be larger than remaining bytes in parent box.
+    case fourcc("mjpg"):
+      box = std::make_shared<Box_mjpg>();
+      break;
 
-  if (range.get_remaining_bytes() < box_size_without_header) {
-    return Error(heif_error_Invalid_input,
-                 heif_suberror_Invalid_box_size);
-  }
+    case fourcc("elng"):
+      box = std::make_shared<Box_elng>();
+      break;
 
 
-  // Create child bitstream range and read box from that range.
+#if WITH_UNCOMPRESSED_CODEC
+    case fourcc("cmpd"):
+      box = std::make_shared<Box_cmpd>();
+      break;
 
-  BitstreamRange boxrange(range.get_istream(),
-                          box_size_without_header,
-                          &range);
+    case fourcc("uncC"):
+      box = std::make_shared<Box_uncC>();
+      break;
 
-  err = box->parse(boxrange);
-  if (err == Error::Ok) {
-    *result = std::move(box);
-  }
+    case fourcc("cmpC"):
+      box = std::make_shared<Box_cmpC>();
+      break;
 
-  boxrange.skip_to_end_of_box();
+    case fourcc("icef"):
+      box = std::make_shared<Box_icef>();
+      break;
 
-  return err;
-}
+    case fourcc("cpat"):
+      box = std::make_shared<Box_cpat>();
+      break;
 
+    case fourcc("splz"):
+      box = std::make_shared<Box_splz>();
+      break;
 
-std::string Box::dump(Indent& indent) const
-{
-  std::ostringstream sstr;
+    case fourcc("sbpm"):
+      box = std::make_shared<Box_sbpm>();
+      break;
 
-  sstr << BoxHeader::dump(indent);
+    case fourcc("snuc"):
+      box = std::make_shared<Box_snuc>();
+      break;
 
-  return sstr.str();
-}
+    case fourcc("cloc"):
+      box = std::make_shared<Box_cloc>();
+      break;
 
+    case fourcc("uncv"):
+      box = std::make_shared<Box_uncv>();
+      break;
+#endif
 
-Error Box::write(StreamWriter& writer) const
-{
-  size_t box_start = reserve_box_header_space(writer);
+    // --- JPEG 2000
 
-  Error err = write_children(writer);
+    case fourcc("j2kH"):
+      box = std::make_shared<Box_j2kH>();
+      break;
 
-  prepend_header(writer, box_start);
+    case fourcc("cdef"):
+      box = std::make_shared<Box_cdef>();
+      break;
 
-  return err;
-}
+    case fourcc("cmap"):
+      box = std::make_shared<Box_cmap>();
+      break;
 
+    case fourcc("pclr"):
+      box = std::make_shared<Box_pclr>();
+      break;
 
-std::shared_ptr<Box> Box::get_child_box(uint32_t short_type) const
-{
-  for (auto& box : m_children) {
-    if (box->get_short_type() == short_type) {
-      return box;
-    }
-  }
+    case fourcc("j2kL"):
+      box = std::make_shared<Box_j2kL>();
+      break;
 
-  return nullptr;
-}
+    case fourcc("j2ki"):
+      box = std::make_shared<Box_j2ki>();
+      break;
 
 
-std::vector<std::shared_ptr<Box>> Box::get_child_boxes(uint32_t short_type) const
-{
-  std::vector<std::shared_ptr<Box>> result;
-  for (auto& box : m_children) {
-    if (box->get_short_type() == short_type) {
-      result.push_back(box);
-    }
-  }
+    // --- mski
 
-  return result;
-}
+    case fourcc("mskC"):
+      box = std::make_shared<Box_mskC>();
+      break;
 
+    // --- TAI timestamps
 
-Error Box::read_children(BitstreamRange& range, int max_number)
-{
-  int count = 0;
+    case fourcc("itai"):
+      box = std::make_shared<Box_itai>();
+      break;
 
-  while (!range.eof() && !range.error()) {
-    std::shared_ptr<Box> box;
-    Error error = Box::read(range, &box);
-    if (error != Error::Ok) {
-      return error;
-    }
+    case fourcc("taic"):
+      box = std::make_shared<Box_taic>();
+      break;
 
-    if (m_children.size() > MAX_CHILDREN_PER_BOX) {
-      std::stringstream sstr;
-      sstr << "Maximum number of child boxes " << MAX_CHILDREN_PER_BOX << " exceeded.";
+    // --- AVC (H.264)
 
-      // Sanity check.
-      return Error(heif_error_Memory_allocation_error,
-                   heif_suberror_Security_limit_exceeded,
-                   sstr.str());
-    }
+    case fourcc("avcC"):
+      box = std::make_shared<Box_avcC>();
+      break;
 
-    m_children.push_back(std::move(box));
+    case fourcc("avc1"):
+      box = std::make_shared<Box_avc1>();
+      break;
 
+#if HEIF_ENABLE_EXPERIMENTAL_FEATURES
+    case fourcc("tilC"):
+      box = std::make_shared<Box_tilC>();
+      break;
+#endif
 
-    // count the new child and end reading new children when we reached the expected number
+#if ENABLE_EXPERIMENTAL_MINI_FORMAT
+    case fourcc("mini"):
+      box = std::make_shared<Box_mini>();
+      break;
+#endif
 
-    count++;
+    case fourcc("mdat"):
+      // avoid generating a 'Box_other'
+      box = std::make_shared<Box>();
+      break;
 
-    if (max_number != READ_CHILDREN_ALL &&
-        count == max_number) {
+    case fourcc("uuid"):
+      if (hdr.get_uuid_type() == std::vector<uint8_t>{0x22, 0xcc, 0x04, 0xc7, 0xd6, 0xd9, 0x4e, 0x07, 0x9d, 0x90, 0x4e, 0xb6, 0xec, 0xba, 0xf3, 0xa3}) {
+        box = std::make_shared<Box_cmin>();
+      }
+      else if (hdr.get_uuid_type() == std::vector<uint8_t>{0x43, 0x63, 0xe9, 0x14, 0x5b, 0x7d, 0x4a, 0xab, 0x97, 0xae, 0xbe, 0xa6, 0x98, 0x03, 0xb4, 0x34}) {
+        box = std::make_shared<Box_cmex>();
+      }
+      else if (hdr.get_uuid_type() == std::vector<uint8_t>{0x26, 0x1e, 0xf3, 0x74, 0x1d, 0x97, 0x5b, 0xba, 0xac, 0xbd, 0x9d, 0x2c, 0x8e, 0xa7, 0x35, 0x22}) {
+        box = std::make_shared<Box_gimi_content_id>();
+      }
+#if WITH_UNCOMPRESSED_CODEC
+      else if (hdr.get_uuid_type() == std::vector<uint8_t>{0x9d, 0xb9, 0xdd, 0x6e, 0x37, 0x3c, 0x5a, 0x4e, 0x81, 0x10, 0x21, 0xfc, 0x83, 0xa9, 0x11, 0xfd}) {
+        box = std::make_shared<Box_gimi_component_content_ids>();
+      }
+#endif
+      else {
+        box = std::make_shared<Box_other>(hdr.get_short_type());
+      }
       break;
-    }
-  }
 
-  return range.get_error();
-}
+    // --- sequences
 
+    case fourcc("moov"):
+      box = std::make_shared<Box_moov>();
+      break;
 
-Error Box::write_children(StreamWriter& writer) const
-{
-  for (const auto& child : m_children) {
-    Error err = child->write(writer);
-    if (err) {
-      return err;
-    }
-  }
+    case fourcc("mvhd"):
+      box = std::make_shared<Box_mvhd>();
+      break;
 
-  return Error::Ok;
-}
+    case fourcc("trak"):
+      box = std::make_shared<Box_trak>();
+      break;
 
+    case fourcc("tkhd"):
+      box = std::make_shared<Box_tkhd>();
+      break;
 
-std::string Box::dump_children(Indent& indent) const
-{
-  std::ostringstream sstr;
+    case fourcc("mdia"):
+      box = std::make_shared<Box_mdia>();
+      break;
 
-  bool first = true;
+    case fourcc("mdhd"):
+      box = std::make_shared<Box_mdhd>();
+      break;
 
-  indent++;
-  for (const auto& childBox : m_children) {
-    if (first) {
-      first = false;
-    }
-    else {
-      sstr << indent << "\n";
-    }
+    case fourcc("minf"):
+      box = std::make_shared<Box_minf>();
+      break;
 
-    sstr << childBox->dump(indent);
-  }
-  indent--;
+    case fourcc("vmhd"):
+      box = std::make_shared<Box_vmhd>();
+      break;
 
-  return sstr.str();
-}
+    case fourcc("stbl"):
+      box = std::make_shared<Box_stbl>();
+      break;
 
+    case fourcc("stsd"):
+      box = std::make_shared<Box_stsd>();
+      break;
 
-void Box::derive_box_version_recursive()
-{
-  derive_box_version();
+    case fourcc("stts"):
+      box = std::make_shared<Box_stts>();
+      break;
 
-  for (auto& child : m_children) {
-    child->derive_box_version_recursive();
-  }
-}
+    case fourcc("ctts"):
+      box = std::make_shared<Box_ctts>();
+      break;
 
+    case fourcc("stsc"):
+      box = std::make_shared<Box_stsc>();
+      break;
 
-Error Box_ftyp::parse(BitstreamRange& range)
-{
-  m_major_brand = range.read32();
-  m_minor_version = range.read32();
+    case fourcc("stco"):
+      box = std::make_shared<Box_stco>();
+      break;
 
-  if (get_box_size() <= get_header_size() + 8) {
-    // Sanity check.
-    return Error(heif_error_Invalid_input,
-                 heif_suberror_Invalid_box_size,
-                 "ftyp box too small (less than 8 bytes)");
-  }
+    case fourcc("stsz"):
+      box = std::make_shared<Box_stsz>();
+      break;
 
-  uint64_t n_minor_brands = (get_box_size() - get_header_size() - 8) / 4;
+    case fourcc("stss"):
+      box = std::make_shared<Box_stss>();
+      break;
 
-  for (uint64_t i = 0; i < n_minor_brands && !range.error(); i++) {
-    m_compatible_brands.push_back(range.read32());
-  }
+    case fourcc("ccst"):
+      box = std::make_shared<Box_ccst>();
+      break;
 
-  return range.get_error();
-}
+    case fourcc("auxi"):
+      box = std::make_shared<Box_auxi>();
+      break;
 
+    case fourcc("edts"):
+      box = std::make_shared<Box_edts>();
+      break;
 
-bool Box_ftyp::has_compatible_brand(uint32_t brand) const
-{
-  for (uint32_t b : m_compatible_brands) {
-    if (b == brand) {
-      return true;
-    }
-  }
+    case fourcc("elst"):
+      box = std::make_shared<Box_elst>();
+      break;
 
-  return false;
-}
+    case fourcc("sbgp"):
+      box = std::make_shared<Box_sbgp>();
+      break;
 
+    case fourcc("sgpd"):
+      box = std::make_shared<Box_sgpd>();
+      break;
 
-std::string Box_ftyp::dump(Indent& indent) const
-{
-  std::ostringstream sstr;
+    case fourcc("btrt"):
+      box = std::make_shared<Box_btrt>();
+      break;
 
-  sstr << BoxHeader::dump(indent);
+    case fourcc("saiz"):
+      box = std::make_shared<Box_saiz>();
+      break;
 
-  sstr << indent << "major brand: " << to_fourcc(m_major_brand) << "\n"
-       << indent << "minor version: " << m_minor_version << "\n"
-       << indent << "compatible brands: ";
+    case fourcc("saio"):
+      box = std::make_shared<Box_saio>();
+      break;
 
-  bool first = true;
-  for (uint32_t brand : m_compatible_brands) {
-    if (first) { first = false; }
-    else { sstr << ','; }
+    case fourcc("urim"):
+      box = std::make_shared<Box_URIMetaSampleEntry>();
+      break;
 
-    sstr << to_fourcc(brand);
-  }
-  sstr << "\n";
+    case fourcc("uri "):
+      box = std::make_shared<Box_uri>();
+      break;
 
-  return sstr.str();
-}
+    case fourcc("nmhd"):
+      box = std::make_shared<Box_nmhd>();
+      break;
 
+    case fourcc("tref"):
+      box = std::make_shared<Box_tref>();
+      break;
 
-void Box_ftyp::add_compatible_brand(uint32_t brand)
-{
-  // TODO: check whether brand already exists in the list
+    case fourcc("sdtp"):
+      box = std::make_shared<Box_sdtp>();
+      break;
 
-  m_compatible_brands.push_back(brand);
-}
+#if HEIF_WITH_OMAF
+    // OMAF
+    case fourcc("prfr"):
+      box = std::make_shared<Box_prfr>();
+      break;
+#endif
 
+    default:
+      box = std::make_shared<Box_other>(hdr.get_short_type());
+      break;
+  }
 
-Error Box_ftyp::write(StreamWriter& writer) const
-{
-  size_t box_start = reserve_box_header_space(writer);
+  box->set_short_header(hdr);
 
-  writer.write32(m_major_brand);
-  writer.write32(m_minor_version);
+  box->m_debug_box_type = hdr.get_type_string(); // only for debugging
 
-  for (uint32_t b : m_compatible_brands) {
-    writer.write32(b);
+
+  if (range.get_nesting_level() > MAX_BOX_NESTING_LEVEL) {
+    return Error(heif_error_Memory_allocation_error,
+                 heif_suberror_Security_limit_exceeded,
+                 "Security limit for maximum nesting of boxes has been exceeded");
   }
 
-  prepend_header(writer, box_start);
+  if (hdr.has_fixed_box_size()) {
+    // Sanity checks
+    if (hdr.get_box_size() < hdr.get_header_size()) {
+      std::stringstream sstr;
+      sstr << "Box size (" << hdr.get_box_size() << " bytes) smaller than header size ("
+           << hdr.get_header_size() << " bytes)";
 
-  return Error::Ok;
-}
+      return {heif_error_Invalid_input,
+              heif_suberror_Invalid_box_size,
+              sstr.str()};
+    }
 
+    // this is >= 0 because of above condition
+    auto nBytes = static_cast<uint64_t>(hdr.get_box_size() - hdr.get_header_size());
+    if (nBytes > SIZE_MAX) {
+      return {heif_error_Memory_allocation_error,
+              heif_suberror_Invalid_box_size,
+              "Box size too large"};
+    }
 
-Error Box_meta::parse(BitstreamRange& range)
-{
-  parse_full_box_header(range);
+    // Security check: make sure that box size does not exceed int64 size.
 
-  /*
-  uint64_t boxSizeLimit;
-  if (get_box_size() == BoxHeader::size_until_end_of_file) {
-    boxSizeLimit = sizeLimit;
-  }
-  else {
-    boxSizeLimit = get_box_size() - get_header_size();
+    if (hdr.get_box_size() > (uint64_t) std::numeric_limits<int64_t>::max()) {
+      return {heif_error_Invalid_input,
+              heif_suberror_Invalid_box_size};
+    }
+
+    // --- wait for data to arrive
+
+    auto status = range.wait_for_available_bytes(static_cast<size_t>(nBytes));
+    if (status != StreamReader::grow_status::size_reached) {
+      // TODO: return recoverable error at timeout
+      return {heif_error_Invalid_input,
+              heif_suberror_End_of_data};
+    }
   }
-  */
 
-  return read_children(range);
-}
+  auto box_size = static_cast<int64_t>(hdr.get_box_size());
+  int64_t box_size_without_header = hdr.has_fixed_box_size() ? (box_size - hdr.get_header_size()) : (int64_t)range.get_remaining_bytes();
 
+  // Box size may not be larger than remaining bytes in parent box.
 
-std::string Box_meta::dump(Indent& indent) const
-{
-  std::ostringstream sstr;
-  sstr << Box::dump(indent);
-  sstr << dump_children(indent);
+  if ((int64_t)range.get_remaining_bytes() < box_size_without_header) {
+    return {heif_error_Invalid_input,
+            heif_suberror_Invalid_box_size};
+  }
 
-  return sstr.str();
-}
 
+  // Create child bitstream range and read box from that range.
 
-Error Box_hdlr::parse(BitstreamRange& range)
-{
-  parse_full_box_header(range);
+  BitstreamRange boxrange(range.get_istream(),
+                          box_size_without_header,
+                          &range);
 
-  m_pre_defined = range.read32();
-  m_handler_type = range.read32();
+  err = box->parse(boxrange, limits);
+  boxrange.skip_to_end_of_box();
 
-  for (int i = 0; i < 3; i++) {
-    m_reserved[i] = range.read32();
+  if (err == Error::Ok) {
+    *result = std::move(box);
+  }
+  else {
+    parse_error_fatality fatality = box->get_parse_error_fatality();
+
+    box = std::make_shared<Box_Error>(box->get_short_type(), err, fatality);
+
+    // We return a Box_Error that represents the parse error.
+    *result = std::move(box);
   }
 
-  m_name = range.read_string();
+  return err;
+}
 
-  return range.get_error();
+
+std::string Box::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+
+  sstr << BoxHeader::dump(indent);
+
+  return sstr.str();
 }
 
 
-std::string Box_hdlr::dump(Indent& indent) const
+std::string FullBox::dump(Indent& indent) const
 {
   std::ostringstream sstr;
+
   sstr << Box::dump(indent);
-  sstr << indent << "pre_defined: " << m_pre_defined << "\n"
-       << indent << "handler_type: " << to_fourcc(m_handler_type) << "\n"
-       << indent << "name: " << m_name << "\n";
+
+  sstr << indent << "version: " << ((int) m_version) << "\n"
+       << indent << "flags: " << std::hex << m_flags << "\n";
 
   return sstr.str();
 }
 
 
-Error Box_hdlr::write(StreamWriter& writer) const
+Error Box::write(StreamWriter& writer) const
 {
   size_t box_start = reserve_box_header_space(writer);
 
-  writer.write32(m_pre_defined);
-  writer.write32(m_handler_type);
-
-  for (int i = 0; i < 3; i++) {
-    writer.write32(m_reserved[i]);
-  }
-
-  writer.write(m_name);
+  Error err = write_children(writer);
 
   prepend_header(writer, box_start);
 
-  return Error::Ok;
+  return err;
 }
 
 
-Error Box_pitm::parse(BitstreamRange& range)
+bool Box::operator==(const Box& other) const
 {
-  parse_full_box_header(range);
-
-  if (get_version() == 0) {
-    m_item_ID = range.read16();
-  }
-  else {
-    m_item_ID = range.read32();
+  if (this->get_short_type() != other.get_short_type()) {
+    return false;
   }
 
-  return range.get_error();
-}
-
+  StreamWriter writer1;
+  StreamWriter writer2;
 
-std::string Box_pitm::dump(Indent& indent) const
-{
-  std::ostringstream sstr;
-  sstr << Box::dump(indent);
-  sstr << indent << "item_ID: " << m_item_ID << "\n";
+  this->write(writer1);
+  other.write(writer2);
 
-  return sstr.str();
+  return writer1.get_data() == writer2.get_data();
 }
 
 
-void Box_pitm::derive_box_version()
+bool Box::remove_child_box(const std::shared_ptr<const Box>& box)
 {
-  if (m_item_ID <= 0xFFFF) {
-    set_version(0);
-  }
-  else {
-    set_version(1);
+  for (int i=0; i<(int)m_children.size(); i++) {
+    if (m_children[i].get() == box.get()) {
+      m_children.erase(m_children.begin() + i);
+      return true;
+    }
   }
+
+  return false;
 }
 
 
-Error Box_pitm::write(StreamWriter& writer) const
+bool Box::equal(const std::shared_ptr<Box>& box1, const std::shared_ptr<Box>& box2)
 {
-  size_t box_start = reserve_box_header_space(writer);
-
-  if (get_version() == 0) {
-    assert(m_item_ID <= 0xFFFF);
-    writer.write16((uint16_t) m_item_ID);
-  }
-  else {
-    writer.write32(m_item_ID);
-  }
+    if (!box1 || !box2) {
+        return false;
+    }
 
-  prepend_header(writer, box_start);
+    // This was introduced because of j2kH having child boxes.
+    // TODO: we might also deduplicate them by comparing all child boxes.
+    if (box1->has_child_boxes() || box2->has_child_boxes()) {
+      return false;
+    }
 
-  return Error::Ok;
+    return *box1 == *box2;
 }
 
 
-Error Box_iloc::parse(BitstreamRange& range)
+Error Box::read_children(BitstreamRange& range, uint32_t max_number, const heif_security_limits* limits)
 {
-  /*
-  printf("box size: %d\n",get_box_size());
-  printf("header size: %d\n",get_header_size());
-  printf("start limit: %d\n",sizeLimit);
-  */
+  uint32_t count = 0;
 
-  parse_full_box_header(range);
-
-  uint16_t values4 = range.read16();
+  while (!range.eof() && !range.error()) {
+    std::shared_ptr<Box> box;
+    Error error = Box::read(range, &box, limits);
+    if (error != Error::Ok && (!box || box->get_parse_error_fatality() == parse_error_fatality::fatal)) {
+      return error;
+    }
 
-  int offset_size = (values4 >> 12) & 0xF;
-  int length_size = (values4 >> 8) & 0xF;
-  int base_offset_size = (values4 >> 4) & 0xF;
-  int index_size = 0;
+    if (max_number == READ_CHILDREN_ALL) {
+      uint32_t max_children;
+      if (get_short_type() == fourcc("iinf")) {
+        max_children = limits->max_items;
+      }
+      else {
+        max_children = limits->max_children_per_box;
+      }
 
-  if (get_version() > 1) {
-    index_size = (values4 & 0xF);
-  }
+      if (max_children && m_children.size() > max_children) {
+        std::stringstream sstr;
+        sstr << "Maximum number of child boxes (" << max_children << ") in '" << get_type_string() << "' box exceeded.";
 
-  int item_count;
-  if (get_version() < 2) {
-    item_count = range.read16();
-  }
-  else {
-    item_count = range.read32();
-  }
+        // Sanity check.
+        return Error(heif_error_Memory_allocation_error,
+                     heif_suberror_Security_limit_exceeded,
+                     sstr.str());
+      }
+    }
 
-  // Sanity check.
-  if (item_count > MAX_ILOC_ITEMS) {
-    std::stringstream sstr;
-    sstr << "iloc box contains " << item_count << " items, which exceeds the security limit of "
-         << MAX_ILOC_ITEMS << " items.";
+    m_children.push_back(std::move(box));
 
-    return Error(heif_error_Memory_allocation_error,
-                 heif_suberror_Security_limit_exceeded,
-                 sstr.str());
-  }
 
-  for (int i = 0; i < item_count; i++) {
-    Item item;
+    // count the new child and end reading new children when we reached the expected number
 
-    if (get_version() < 2) {
-      item.item_ID = range.read16();
-    }
-    else {
-      item.item_ID = range.read32();
-    }
+    count++;
 
-    if (get_version() >= 1) {
-      values4 = range.read16();
-      item.construction_method = (values4 & 0xF);
+    if (max_number != READ_CHILDREN_ALL &&
+        count == max_number) {
+      break;
+    }
+  }
+
+  return range.get_error();
+}
+
+
+Error Box::write_children(StreamWriter& writer) const
+{
+  for (const auto& child : m_children) {
+    Error err = child->write(writer);
+    if (err) {
+      return err;
+    }
+  }
+
+  return Error::Ok;
+}
+
+
+std::string Box::dump_children(Indent& indent, bool with_index) const
+{
+  std::ostringstream sstr;
+
+  bool first = true;
+  int idx=1;
+
+  indent++;
+  for (const auto& childBox : m_children) {
+    if (first) {
+      first = false;
+    }
+    else {
+      sstr << indent << "\n";
+    }
+
+    if (with_index) {
+      sstr << indent << "index: " << idx << "\n";
+      idx++;
+    }
+
+    sstr << childBox->dump(indent);
+  }
+  indent--;
+
+  return sstr.str();
+}
+
+
+void Box::derive_box_version_recursive()
+{
+  derive_box_version();
+
+  for (auto& child : m_children) {
+    child->derive_box_version_recursive();
+  }
+}
+
+
+void Box::patch_file_pointers_recursively(StreamWriter& writer, size_t offset)
+{
+  patch_file_pointers(writer, offset);
+
+  for (auto& child : m_children) {
+    child->patch_file_pointers_recursively(writer, offset);
+  }
+}
+
+
+Error Box_other::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  if (has_fixed_box_size()) {
+    size_t len;
+    if (get_box_size() >= get_header_size()) {
+      auto len64 = get_box_size() - get_header_size();
+      if (len64 > MAX_BOX_SIZE) {
+        return {heif_error_Invalid_input,
+                heif_suberror_Security_limit_exceeded,
+                "Box size too large"};
+      }
+
+      len = static_cast<size_t>(len64);
+
+      m_data.resize(len);
+      range.read(m_data.data(), len);
+    }
+    else {
+      return {heif_error_Invalid_input,
+              heif_suberror_Invalid_box_size};
+    }
+  }
+  else {
+    // TODO: boxes until end of file (we will probably never need this)
+  }
+
+  return range.get_error();
+}
+
+
+Error Box_other::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  if (get_box_size() >= get_header_size()) {
+    writer.write(m_data);
+    prepend_header(writer, box_start);
+    return Error::Ok;
+  }
+  else {
+    return Error(heif_error_Invalid_input,
+                 heif_suberror_Invalid_box_size);
+  }
+}
+
+
+std::string Box_other::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+
+  sstr << BoxHeader::dump(indent);
+
+  // --- show raw box content
+
+  size_t len = 0;
+  if (get_box_size() >= get_header_size()) {
+    // We can cast because if it does not fit, it would fail during parsing.
+    len = static_cast<size_t>(get_box_size() - get_header_size());
+  }
+  else {
+    sstr << indent << "invalid box size " << get_box_size() << " (smaller than header)\n";
+    return sstr.str();
+  }
+
+  sstr << write_raw_data_as_hex(m_data.data(), len,
+                                indent.get_string() + "data: ",
+                                indent.get_string() + "      ");
+
+  return sstr.str();
+}
+
+
+std::string Box_Error::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << indent << '\'' << fourcc_to_string(m_box_type_with_parse_error) << "' parse error: " << m_error.message << "\n";
+  sstr << indent << "fatality: ";
+  switch (m_fatality) {
+    case parse_error_fatality::fatal: sstr << "fatal\n"; break;
+    case parse_error_fatality::ignorable: sstr << "ignorable\n"; break;
+    case parse_error_fatality::optional: sstr << "optional\n"; break;
+  }
+
+  return sstr.str();
+}
+
+parse_error_fatality Box_Error::get_parse_error_fatality() const
+{
+  return m_fatality;
+}
+
+
+Error Box_ftyp::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  m_major_brand = range.read32();
+  m_minor_version = range.read32();
+
+  uint64_t box_size = get_box_size();
+  if (box_size < 8 || box_size - 8 < get_header_size()) {
+    // Sanity check.
+    return Error(heif_error_Invalid_input,
+                 heif_suberror_Invalid_box_size,
+                 "ftyp box too small (less than 8 bytes)");
+  }
+
+  uint64_t n_minor_brands = (get_box_size() - get_header_size() - 8) / 4;
+
+  if (limits->max_number_of_file_brands && n_minor_brands > limits->max_number_of_file_brands) {
+    return {
+      heif_error_Memory_allocation_error,
+      heif_suberror_Security_limit_exceeded,
+      "Number of minor brands in file exceeds security limit"
+    };
+  }
+
+  for (uint64_t i = 0; i < n_minor_brands && !range.error(); i++) {
+    m_compatible_brands.push_back(range.read32());
+  }
+
+  return range.get_error();
+}
+
+
+bool Box_ftyp::has_compatible_brand(heif_brand2 brand) const
+{
+  return std::find(m_compatible_brands.begin(),
+                   m_compatible_brands.end(),
+                   brand) !=
+         m_compatible_brands.end();
+}
+
+
+std::string Box_ftyp::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+
+  sstr << BoxHeader::dump(indent);
+
+  sstr << indent << "major brand: " << fourcc_to_string(m_major_brand) << "\n"
+       << indent << "minor version: ";
+  if (m_minor_version < ('A' << 24)) {
+    // This is probably a version number
+    sstr << m_minor_version;
+  } else {
+    // probably a 4CC, as used for mif3
+    sstr << fourcc_to_string(m_minor_version);
+  }
+  sstr << "\n" << indent << "compatible brands: ";
+
+  bool first = true;
+  for (uint32_t brand : m_compatible_brands) {
+    if (first) { first = false; }
+    else { sstr << ','; }
+
+    sstr << fourcc_to_string(brand);
+  }
+  sstr << "\n";
+
+  return sstr.str();
+}
+
+
+void Box_ftyp::add_compatible_brand(heif_brand2 brand)
+{
+  if (!has_compatible_brand(brand)) {
+    m_compatible_brands.push_back(brand);
+  }
+}
+
+
+Error Box_ftyp::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  writer.write32(m_major_brand);
+  writer.write32(m_minor_version);
+
+  for (uint32_t b : m_compatible_brands) {
+    writer.write32(b);
+  }
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+
+Error Box_free::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  range.skip_to_end_of_box();
+  return range.get_error();
+}
+
+
+std::string Box_free::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << BoxHeader::dump(indent);
+  return sstr.str();
+}
+
+
+Error Box_free::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+  prepend_header(writer, box_start);
+  return Error::Ok;
+}
+
+
+Error Box_meta::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  parse_full_box_header(range);
+
+  if (get_version() != 0) {
+    return unsupported_version_error("meta");
+  }
+
+  /*
+  uint64_t boxSizeLimit;
+  if (get_box_size() == BoxHeader::size_until_end_of_file) {
+    boxSizeLimit = sizeLimit;
+  }
+  else {
+    boxSizeLimit = get_box_size() - get_header_size();
+  }
+  */
+
+  return read_children(range, READ_CHILDREN_ALL, limits);
+}
+
+
+std::string Box_meta::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
+  sstr << dump_children(indent);
+
+  return sstr.str();
+}
+
+
+Error FullBox::unsupported_version_error(const char* box) const
+{
+  std::stringstream sstr;
+  sstr << box << " box data version " << ((int) m_version) << " is not implemented yet";
+
+  return {heif_error_Unsupported_feature,
+          heif_suberror_Unsupported_data_version,
+          sstr.str()};
+}
+
+
+Error Box_hdlr::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  parse_full_box_header(range);
+
+  if (get_version() != 0) {
+    return unsupported_version_error("hdlr");
+  }
+
+  m_pre_defined = range.read32();
+  m_handler_type = range.read32();
+
+  for (int i = 0; i < 3; i++) {
+    m_reserved[i] = range.read32();
+  }
+
+  m_name = range.read_string();
+
+  return range.get_error();
+}
+
+
+std::string Box_hdlr::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
+  sstr << indent << "pre_defined: " << m_pre_defined << "\n"
+       << indent << "handler_type: " << fourcc_to_string(m_handler_type) << "\n"
+       << indent << "name: " << m_name << "\n";
+
+  return sstr.str();
+}
+
+
+Error Box_hdlr::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  writer.write32(m_pre_defined);
+  writer.write32(m_handler_type);
+
+  for (int i = 0; i < 3; i++) {
+    writer.write32(m_reserved[i]);
+  }
+
+  writer.write(m_name);
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+
+Error Box_pitm::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  parse_full_box_header(range);
+
+  if (get_version() > 1) {
+    return unsupported_version_error("pitm");
+  }
+
+
+  if (get_version() == 0) {
+    m_item_ID = range.read16();
+  }
+  else {
+    m_item_ID = range.read32();
+  }
+
+  return range.get_error();
+}
+
+
+std::string Box_pitm::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
+  sstr << indent << "item_ID: " << m_item_ID << "\n";
+
+  return sstr.str();
+}
+
+
+void Box_pitm::derive_box_version()
+{
+  if (m_item_ID <= 0xFFFF) {
+    set_version(0);
+  }
+  else {
+    set_version(1);
+  }
+}
+
+
+Error Box_pitm::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  if (get_version() == 0) {
+    assert(m_item_ID <= 0xFFFF);
+    writer.write16((uint16_t) m_item_ID);
+  }
+  else {
+    writer.write32(m_item_ID);
+  }
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+
+Error Box_iloc::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  parse_full_box_header(range);
+
+  if (get_version() > 2) {
+    return unsupported_version_error("iloc");
+  }
+
+  const int version = get_version();
+
+  uint16_t values4 = range.read16();
+
+  int offset_size = (values4 >> 12) & 0xF;
+  int length_size = (values4 >> 8) & 0xF;
+  int base_offset_size = (values4 >> 4) & 0xF;
+  int index_size = 0;
+
+  if (version == 1 || version == 2) {
+    index_size = (values4 & 0xF);
+  }
+
+  uint32_t item_count = 0;
+  if (version < 2) {
+    item_count = range.read16();
+  }
+  else if (version == 2) {
+    item_count = range.read32();
+  }
+
+  // Sanity check. (This might be obsolete now as we check for range.error() below).
+  if (limits->max_items && item_count > limits->max_items) {
+    std::stringstream sstr;
+    sstr << "iloc box contains " << item_count << " items, which exceeds the security limit of "
+         << limits->max_items << " items.";
+
+    return Error(heif_error_Memory_allocation_error,
+                 heif_suberror_Security_limit_exceeded,
+                 sstr.str());
+  }
+
+  for (uint32_t i = 0; i < item_count; i++) {
+    Item item;
+
+    if (range.eof()) {
+      std::stringstream sstr;
+      sstr << "iloc box should contain " << item_count << " items, but we can only read " << i << " items.";
+
+      return {heif_error_Invalid_input,
+              heif_suberror_End_of_data,
+              sstr.str()};
+    }
+
+    if (version < 2) {
+      item.item_ID = range.read16();
+    }
+    else if (version == 2) {
+      item.item_ID = range.read32();
+    }
+
+    if (version >= 1) {
+      values4 = range.read16();
+      item.construction_method = (values4 & 0xF);
     }
 
     item.data_reference_index = range.read16();
 
-    item.base_offset = 0;
-    if (base_offset_size == 4) {
-      item.base_offset = range.read32();
+    item.base_offset = 0;
+    if (base_offset_size == 4) {
+      item.base_offset = range.read32();
+    }
+    else if (base_offset_size == 8) {
+      item.base_offset = ((uint64_t) range.read32()) << 32;
+      item.base_offset |= range.read32();
+    }
+
+    uint16_t extent_count = range.read16();
+
+    // Sanity check.
+    auto max_iloc_extents = limits->max_iloc_extents_per_item;
+    if (max_iloc_extents && extent_count > max_iloc_extents) {
+      std::stringstream sstr;
+      sstr << "Number of extents in iloc box (" << extent_count << ") exceeds security limit ("
+           << max_iloc_extents << ")\n";
+
+      return Error(heif_error_Memory_allocation_error,
+                   heif_suberror_Security_limit_exceeded,
+                   sstr.str());
+    }
+
+    for (int e = 0; e < extent_count; e++) {
+      Extent extent;
+
+      if (range.eof()) {
+        std::stringstream sstr;
+        sstr << "iloc item should contain " << extent_count << " extents, but we can only read " << e << " extents.";
+
+        return {heif_error_Invalid_input,
+                heif_suberror_End_of_data,
+                sstr.str()};
+      }
+
+      if ((version == 1 || version == 2) && index_size > 0) {
+        if (index_size == 4) {
+          extent.index = range.read32();
+        }
+        else if (index_size == 8) {
+          extent.index = ((uint64_t) range.read32()) << 32;
+          extent.index |= range.read32();
+        }
+      }
+
+      extent.offset = 0;
+      if (offset_size == 4) {
+        extent.offset = range.read32();
+      }
+      else if (offset_size == 8) {
+        extent.offset = ((uint64_t) range.read32()) << 32;
+        extent.offset |= range.read32();
+      }
+
+
+      extent.length = 0;
+      if (length_size == 4) {
+        extent.length = range.read32();
+      }
+      else if (length_size == 8) {
+        extent.length = ((uint64_t) range.read32()) << 32;
+        extent.length |= range.read32();
+      }
+
+      item.extents.push_back(extent);
+    }
+
+    if (!range.error()) {
+      m_items.push_back(item);
+    }
+  }
+
+  return range.get_error();
+}
+
+
+Box_iloc::Box_iloc()
+{
+  set_short_type(fourcc("iloc"));
+
+  set_use_tmp_file(false);
+}
+
+
+Box_iloc::~Box_iloc()
+{
+  if (m_use_tmpfile) {
+    unlink(m_tmp_filename);
+  }
+}
+
+
+void Box_iloc::set_use_tmp_file(bool flag)
+{
+  m_use_tmpfile = flag;
+  if (flag) {
+#if !defined(_WIN32)
+    strcpy(m_tmp_filename, "/tmp/libheif-XXXXXX");
+    m_tmpfile_fd = mkstemp(m_tmp_filename);
+#else
+    // TODO Currently unused code. Implement when needed.
+    assert(false);
+#  if 0
+    char tmpname[L_tmpnam_s];
+    // TODO: check return value (errno_t)
+    tmpnam_s(tmpname, L_tmpnam_s);
+    _sopen_s(&m_tmpfile_fd, tmpname, _O_CREAT | _O_TEMPORARY | _O_TRUNC | _O_RDWR, _SH_DENYRW, _S_IREAD | _S_IWRITE);
+#  endif
+#endif
+  }
+}
+
+
+std::string Box_iloc::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
+
+  for (const Item& item : m_items) {
+    sstr << indent << "item ID: " << item.item_ID << "\n"
+         << indent << "  construction method: " << ((int) item.construction_method) << "\n"
+         << indent << "  data_reference_index: " << std::hex
+         << item.data_reference_index << std::dec << "\n"
+         << indent << "  base_offset: " << item.base_offset << "\n";
+
+    sstr << indent << "  extents: ";
+    for (const Extent& extent : item.extents) {
+      sstr << extent.offset << "," << extent.length;
+      if (extent.index != 0) {
+        sstr << ";index=" << extent.index;
+      }
+      sstr << " ";
+    }
+    sstr << "\n";
+  }
+
+  return sstr.str();
+}
+
+
+Error Box_iloc::read_data(heif_item_id item,
+                          const std::shared_ptr<StreamReader>& istr,
+                          const std::shared_ptr<Box_idat>& idat,
+                          std::vector<uint8_t>* dest,
+                          const heif_security_limits* limits) const
+{
+  return read_data(item, istr, idat, dest, 0, std::numeric_limits<uint64_t>::max(), limits);
+}
+
+
+Error Box_iloc::read_data(heif_item_id item_id,
+                          const std::shared_ptr<StreamReader>& istr,
+                          const std::shared_ptr<Box_idat>& idat,
+                          std::vector<uint8_t>* dest,
+                          uint64_t offset, uint64_t size,
+                          const heif_security_limits* limits) const
+{
+  const Item* item = nullptr;
+  for (auto& i : m_items) {
+    if (i.item_ID == item_id) {
+      item = &i;
+      break;
+    }
+  }
+
+  if (!item) {
+    std::stringstream sstr;
+    sstr << "Item with ID " << item_id << " has no compressed data";
+
+    return Error(heif_error_Invalid_input,
+                 heif_suberror_No_item_data,
+                 sstr.str());
+  }
+
+#if ENABLE_MULTITHREADING_SUPPORT
+  static std::mutex read_mutex;
+
+  std::lock_guard<std::mutex> lock(read_mutex);
+#endif
+
+  bool limited_size = (size != std::numeric_limits<uint64_t>::max());
+
+
+  // TODO: this function should always append the data to the output vector as this is used when
+  //       the image data is concatenated with data in a configuration box. However, it seems that
+  //       this function clears the array in some cases. This should be corrected.
+
+  for (const auto& extent : item->extents) {
+    if (item->construction_method == 0) {
+
+      // --- make sure that all data is available
+
+      if (extent.offset > MAX_FILE_POS ||
+          item->base_offset > MAX_FILE_POS ||
+          extent.length > MAX_FILE_POS) {
+        return {heif_error_Invalid_input,
+                heif_suberror_Security_limit_exceeded,
+                "iloc data pointers out of allowed range"};
+      }
+
+      StreamReader::grow_status status = istr->wait_for_file_size(extent.offset + item->base_offset + extent.length);
+      if (status == StreamReader::grow_status::size_beyond_eof) {
+        // Out-of-bounds
+        // TODO: I think we should not clear this. Maybe we want to try reading again later and
+        // hence should not lose the data already read.
+        dest->clear();
+
+        std::stringstream sstr;
+        sstr << "Extent in iloc box references data outside of file bounds "
+             << "(points to file position " << extent.offset + item->base_offset << ")\n";
+
+        return {heif_error_Invalid_input,
+                heif_suberror_End_of_data,
+                sstr.str()};
+      }
+      else if (status == StreamReader::grow_status::timeout) {
+        // TODO: maybe we should introduce some 'Recoverable error' instead of 'Invalid input'
+        return {heif_error_Invalid_input,
+                heif_suberror_End_of_data};
+      }
+
+
+      // skip to reading offset
+
+      uint64_t skip_len = std::min(offset, extent.length);
+      offset -= skip_len;
+
+      uint64_t read_len = std::min(extent.length - skip_len, size);
+
+      if (offset > 0) {
+        continue;
+      }
+
+      if (read_len == 0) {
+        continue;
+      }
+
+      size_t old_size = dest->size();
+
+      // --- security check that we do not allocate too much memory
+
+      auto max_memory_block_size = limits->max_memory_block_size;
+      if (max_memory_block_size && max_memory_block_size - old_size < read_len) {
+        std::stringstream sstr;
+        sstr << "iloc box contained " << extent.length << " bytes, total memory size would be "
+             << (old_size + extent.length) << " bytes, exceeding the security limit of "
+             << max_memory_block_size << " bytes";
+
+        return {heif_error_Memory_allocation_error,
+                heif_suberror_Security_limit_exceeded,
+                sstr.str()};
+      }
+
+
+      // --- request file range
+
+      uint64_t data_start_pos = extent.offset + item->base_offset + skip_len;
+      uint64_t rangeRequestEndPos = istr->request_range(data_start_pos, data_start_pos + read_len);
+      if (rangeRequestEndPos == 0) {
+        return istr->get_error();
+      }
+
+      // --- move file pointer to start of data
+
+      bool success = istr->seek(data_start_pos);
+      if (!success) {
+        return {heif_error_Invalid_input,
+                heif_suberror_Unspecified,
+                "Error setting input file position"};
+      }
+
+
+      // --- read data
+
+      dest->resize(static_cast<size_t>(old_size + read_len));
+      success = istr->read((char*) dest->data() + old_size, static_cast<size_t>(read_len));
+      if (!success) {
+        return {heif_error_Invalid_input,
+                heif_suberror_Unspecified,
+                "Error reading input file"};
+      }
+
+      size -= read_len;
+    }
+    else if (item->construction_method == 1) {
+      if (!idat) {
+        return {heif_error_Invalid_input,
+                heif_suberror_No_idat_box,
+                "idat box referenced in iref box is not present in file"};
+      }
+
+      idat->read_data(istr,
+                      extent.offset + item->base_offset,
+                      extent.length,
+                      *dest, limits);
+
+      size -= extent.length;
+    }
+    else {
+      std::stringstream sstr;
+      sstr << "Item construction method " << (int) item->construction_method << " not implemented";
+      return {heif_error_Unsupported_feature,
+              heif_suberror_Unsupported_item_construction_method,
+              sstr.str()};
+    }
+  }
+
+  // --- we could not read all data
+
+  if (limited_size && size > 0) {
+    return {heif_error_Invalid_input,
+            heif_suberror_End_of_data,
+            "Not enough data present in 'iloc' to satisfy request."};
+  }
+
+  return Error::Ok;
+}
+
+
+Error Box_iloc::append_data(heif_item_id item_ID,
+                            const std::vector<uint8_t>& data,
+                            uint8_t construction_method)
+{
+  // check whether this item ID already exists
+
+  size_t idx;
+  for (idx = 0; idx < m_items.size(); idx++) {
+    if (m_items[idx].item_ID == item_ID) {
+      break;
+    }
+  }
+
+  // item does not exist -> add a new one to the end
+
+  if (idx == m_items.size()) {
+    Item item;
+    item.item_ID = item_ID;
+    item.construction_method = construction_method;
+
+    m_items.push_back(item);
+  }
+
+  if (m_items[idx].construction_method != construction_method) {
+    // TODO: return error: construction methods do not match
+  }
+
+  Extent extent;
+  extent.length = data.size();
+
+  if (m_use_tmpfile && construction_method==0) {
+#if !defined(_WIN32)
+    ssize_t cnt = ::write(m_tmpfile_fd, data.data(), data.size());
+#else
+    // TODO Currently unused code. Implement when needed.
+    assert(false);
+#  if 0
+    int cnt = _write(m_tmpfile_fd, data.data(), data.size());
+#  else
+    int cnt = -1;
+#  endif
+#endif
+    if (cnt < 0) {
+      std::stringstream sstr;
+      sstr << "Could not write to tmp file: error " << errno;
+      return {heif_error_Encoding_error,
+              heif_suberror_Unspecified,
+              sstr.str()};
+    }
+    else if ((size_t)cnt != data.size()) {
+      return {heif_error_Encoding_error,
+              heif_suberror_Unspecified,
+              "Could not write to tmp file (storage full?)"};
+    }
+  }
+  else {
+    if (!m_items[idx].extents.empty()) {
+      Extent& e = m_items[idx].extents.back();
+      e.data.insert(e.data.end(), data.begin(), data.end());
+      e.length = e.data.size();
+      return Error::Ok;
+    }
+
+    extent.data = data;
+  }
+
+  if (construction_method == 1) {
+    extent.offset = m_idat_offset;
+    extent.length = data.size();
+
+    m_idat_offset += (int) data.size();
+  }
+
+  m_items[idx].extents.push_back(std::move(extent));
+
+  return Error::Ok;
+}
+
+
+Error Box_iloc::replace_data(heif_item_id item_ID,
+                             uint64_t output_offset,
+                             const std::vector<uint8_t>& data,
+                             uint8_t construction_method)
+{
+  assert(construction_method == 0); // TODO
+
+  // check whether this item ID already exists
+
+  size_t idx;
+  for (idx = 0; idx < m_items.size(); idx++) {
+    if (m_items[idx].item_ID == item_ID) {
+      break;
+    }
+  }
+
+  assert(idx != m_items.size());
+
+  uint64_t data_start = 0;
+  for (auto& extent : m_items[idx].extents) {
+    if (output_offset >= extent.data.size()) {
+      output_offset -= extent.data.size();
+    }
+    else {
+      uint64_t write_n = std::min(extent.data.size() - output_offset,
+                                  data.size() - data_start);
+      assert(write_n > 0);
+
+      memcpy(extent.data.data() + output_offset, data.data() + data_start, write_n);
+
+      data_start += write_n;
+      output_offset = 0;
+    }
+
+    if (data_start == data.size()) {
+      break;
+    }
+  }
+
+  return Error::Ok;
+}
+
+
+void Box_iloc::derive_box_version()
+{
+  int min_version = m_user_defined_min_version;
+
+  if (m_items.size() > 0xFFFF) {
+    min_version = std::max(min_version, 2);
+  }
+
+  m_offset_size = 0;
+  m_length_size = 0;
+  m_base_offset_size = 0;
+  m_index_size = 0;
+
+  uint64_t total_data_size = 0;
+
+  for (const auto& item : m_items) {
+    // check item_ID size
+    if (item.item_ID > 0xFFFF) {
+      min_version = std::max(min_version, 2);
+    }
+
+    // check construction method
+    if (item.construction_method != 0) {
+      min_version = std::max(min_version, 1);
+    }
+
+    total_data_size += item.extents[0].length;
+
+    /* cannot compute this here because values are not set yet
+    // base offset size
+    if (item.base_offset > 0xFFFFFFFF) {
+      m_base_offset_size = std::max(m_base_offset_size, (uint8_t)8);
+    }
+    else if (item.base_offset > 0) {
+      m_base_offset_size = std::max(m_base_offset_size, (uint8_t)4);
+    }
+*/
+
+    /*
+    for (const auto& extent : item.extents) {
+      // extent index size
+
+      if (extent.index != 0) {
+        min_version = std::max(min_version, 1);
+        m_index_size = 4;
+      }
+
+      if (extent.index > 0xFFFFFFFF) {
+        m_index_size = 8;
+      }
+
+      // extent offset size
+      if (extent.offset > 0xFFFFFFFF) {
+        m_offset_size = 8;
+      }
+      else {
+        m_offset_size = 4;
+      }
+
+      // extent length size
+      if (extent.length > 0xFFFFFFFF) {
+        m_length_size = 8;
+      }
+      else {
+        m_length_size = 4;
+      }
+    }
+      */
+  }
+
+  uint64_t maximum_meta_box_size_guess = 0x10000000; // 256 MB
+  if (total_data_size + maximum_meta_box_size_guess > 0xFFFFFFFF) {
+    m_base_offset_size = 8;
+  }
+  else {
+    m_base_offset_size = 4;
+  }
+
+  m_offset_size = 4;
+  m_length_size = 4;
+  //m_base_offset_size = 4; // set above
+  m_index_size = 0;
+
+  set_version((uint8_t) min_version);
+}
+
+
+Error Box_iloc::write(StreamWriter& writer) const
+{
+  // --- write idat
+
+  size_t sum_idat_size = 0;
+
+  for (const auto& item : m_items) {
+    if (item.construction_method == 1) {
+      for (const auto& extent : item.extents) {
+        sum_idat_size += extent.data.size();
+      }
+    }
+  }
+
+  if (sum_idat_size > 0) {
+    writer.write32((uint32_t) (sum_idat_size + 8));
+    writer.write32(fourcc("idat"));
+
+    for (auto& item : m_items) {
+      if (item.construction_method == 1) {
+        for (auto& extent : item.extents) {
+          writer.write(extent.data);
+        }
+      }
+    }
+  }
+
+
+  // --- write iloc box
+
+  size_t box_start = reserve_box_header_space(writer);
+
+  m_iloc_box_start = writer.get_position();
+
+  int nSkip = 0;
+
+  nSkip += 2;
+  nSkip += (get_version() < 2) ? 2 : 4; // item_count
+
+  for (const auto& item : m_items) {
+    nSkip += (get_version() < 2) ? 2 : 4; // item_ID
+    nSkip += (get_version() >= 1) ? 2 : 0; // construction method
+    nSkip += 4 + m_base_offset_size;
+
+    for (const auto& extent : item.extents) {
+      (void) extent;
+
+      if (get_version() >= 1) {
+        nSkip += m_index_size;
+      }
+
+      nSkip += m_offset_size + m_length_size;
+    }
+  }
+
+  writer.skip(nSkip);
+  prepend_header(writer, box_start);
+
+  patch_iloc_header(writer); // Write iloc box. If there is an mdat, it will later be overwritten.
+
+  return Error::Ok;
+}
+
+
+Error Box_iloc::write_mdat_after_iloc(StreamWriter& writer)
+{
+  // --- compute sum of all mdat data
+
+  size_t sum_mdat_size = 0;
+
+  for (const auto& item : m_items) {
+    if (item.construction_method == 0) {
+      for (const auto& extent : item.extents) {
+        sum_mdat_size += extent.length;
+      }
+    }
+  }
+
+  // --- write mdat box
+
+  if (sum_mdat_size <= 0xFFFFFFFF) {
+    writer.write32((uint32_t) (sum_mdat_size + 8));
+    writer.write32(fourcc("mdat"));
+  }
+  else {
+    // box size > 4 GB
+
+    writer.write32(1);
+    writer.write32(fourcc("mdat"));
+    writer.write64(sum_mdat_size+8+8);
+  }
+
+  if (m_use_tmpfile) {
+    ::lseek(m_tmpfile_fd, 0, SEEK_SET);
+  }
+
+  for (auto& item : m_items) {
+    if (item.construction_method == 0) {
+      item.base_offset = writer.get_position();
+
+      for (auto& extent : item.extents) {
+        extent.offset = writer.get_position() - item.base_offset;
+        //extent.length = extent.data.size();
+
+        if (m_use_tmpfile) {
+          std::vector<uint8_t> data(extent.length);
+#if !defined(_WIN32)
+          ssize_t cnt = ::read(m_tmpfile_fd, data.data(), extent.length);
+#else
+          // TODO Currently unused code. Implement when needed.
+          assert(false);
+# if 0
+          int cnt = _read(m_tmpfile_fd, data.data(), extent.length);
+# else
+          int cnt = -1;
+# endif
+#endif
+          if (cnt<0) {
+            std::stringstream sstr;
+            sstr << "Cannot read tmp data file, error " << errno;
+            return {heif_error_Encoding_error,
+                    heif_suberror_Unspecified,
+                    sstr.str()};
+          }
+          else if ((uint64_t)cnt != extent.length) {
+            return {heif_error_Encoding_error,
+                    heif_suberror_Unspecified,
+                    "Tmp data could not be read completely"};
+          }
+          writer.write(data);
+        }
+        else {
+          writer.write(extent.data);
+        }
+      }
+    }
+  }
+
+
+  // --- patch iloc box
+
+  patch_iloc_header(writer);
+
+  return Error::Ok;
+}
+
+
+void Box_iloc::patch_iloc_header(StreamWriter& writer) const
+{
+  size_t old_pos = writer.get_position();
+  writer.set_position(m_iloc_box_start);
+
+  writer.write8((uint8_t) ((m_offset_size << 4) | (m_length_size)));
+  writer.write8((uint8_t) ((m_base_offset_size << 4) | (m_index_size)));
+
+  if (get_version() < 2) {
+    writer.write16((uint16_t) m_items.size());
+  }
+  else {
+    writer.write32((uint32_t) m_items.size());
+  }
+
+  for (const auto& item : m_items) {
+    if (get_version() < 2) {
+      writer.write16((uint16_t) item.item_ID);
+    }
+    else {
+      writer.write32((uint32_t) item.item_ID);
+    }
+
+    if (get_version() >= 1) {
+      writer.write16(item.construction_method);
+    }
+
+    writer.write16(item.data_reference_index);
+    if (m_base_offset_size > 0) {
+      writer.write(m_base_offset_size, item.base_offset);
+    }
+    else {
+      assert(item.base_offset == 0);
+    }
+    writer.write16((uint16_t) item.extents.size());
+
+    for (const auto& extent : item.extents) {
+      if (get_version() >= 1 && m_index_size > 0) {
+        writer.write(m_index_size, extent.index);
+      }
+
+      writer.write(m_offset_size, extent.offset);
+      writer.write(m_length_size, extent.length);
+    }
+  }
+
+  writer.set_position(old_pos);
+}
+
+
+/*
+ *                     version <= 1    version 2   version > 2    mime     uri
+ * -----------------------------------------------------------------------------------------------
+ * item id               16               16           32          16/32   16/32
+ * protection index      16               16           16          16      16
+ * item type             -                yes          yes         yes     yes
+ * item name             yes              yes          yes         yes     yes
+ * content type          yes              -            -           yes     -
+ * content encoding      yes              -            -           yes     -
+ * hidden item           -                yes          yes         yes     yes
+ * item uri type         -                -            -           -       yes
+ *
+ * Note: HEIF does not allow version 0 and version 1 boxes ! (see 23008-12, 10.2.1)
+ */
+
+Error Box_infe::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  parse_full_box_header(range);
+
+  // only versions 2,3 are required by HEIF
+  if (get_version() > 3) {
+    return unsupported_version_error("infe");
+  }
+
+  if (get_version() <= 1) {
+    m_item_ID = range.read16();
+    m_item_protection_index = range.read16();
+
+    m_item_name = range.read_string();
+    m_content_type = range.read_string();
+    m_content_encoding = range.read_string();
+  }
+
+  m_item_type_4cc = 0;
+
+  if (get_version() >= 2) {
+    m_hidden_item = (get_flags() & 1);
+
+    if (get_version() == 2) {
+      m_item_ID = range.read16();
+    }
+    else {
+      m_item_ID = range.read32();
+    }
+
+    m_item_protection_index = range.read16();
+    m_item_type_4cc = range.read32();
+
+    m_item_name = range.read_string();
+    if (m_item_type_4cc == fourcc("mime")) {
+      m_content_type = range.read_string();
+      m_content_encoding = range.read_string();
+    }
+    else if (m_item_type_4cc == fourcc("uri ")) {
+      m_item_uri_type = range.read_string();
+    }
+  }
+
+  return range.get_error();
+}
+
+
+void Box_infe::derive_box_version()
+{
+  int min_version = 0;
+
+  if (m_hidden_item) {
+    min_version = std::max(min_version, 2);
+  }
+
+  if (m_item_ID > 0xFFFF) {
+    min_version = std::max(min_version, 3);
+  }
+
+
+  if (m_item_type_4cc != 0) {
+    min_version = std::max(min_version, 2);
+  }
+
+  set_version((uint8_t) min_version);
+}
+
+
+void Box_infe::set_hidden_item(bool hidden)
+{
+  m_hidden_item = hidden;
+
+  if (m_hidden_item) {
+    set_flags(get_flags() | 1U);
+  }
+  else {
+    set_flags(get_flags() & ~1U);
+  }
+}
+
+Error Box_infe::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  if (get_version() <= 1) {
+    writer.write16((uint16_t) m_item_ID);
+    writer.write16(m_item_protection_index);
+
+    writer.write(m_item_name);
+    writer.write(m_content_type);
+    writer.write(m_content_encoding);
+  }
+
+  if (get_version() >= 2) {
+    if (get_version() == 2) {
+      writer.write16((uint16_t) m_item_ID);
     }
-    else if (base_offset_size == 8) {
-      item.base_offset = ((uint64_t) range.read32()) << 32;
-      item.base_offset |= range.read32();
+    else if (get_version() == 3) {
+      writer.write32(m_item_ID);
     }
 
-    int extent_count = range.read16();
-    // Sanity check.
-    if (extent_count > MAX_ILOC_EXTENTS_PER_ITEM) {
-      std::stringstream sstr;
-      sstr << "Number of extents in iloc box (" << extent_count << ") exceeds security limit ("
-           << MAX_ILOC_EXTENTS_PER_ITEM << ")\n";
+    writer.write16(m_item_protection_index);
 
-      return Error(heif_error_Memory_allocation_error,
-                   heif_suberror_Security_limit_exceeded,
-                   sstr.str());
+    writer.write32(m_item_type_4cc);
+
+    writer.write(m_item_name);
+    if (m_item_type_4cc == fourcc("mime")) {
+      writer.write(m_content_type);
+      writer.write(m_content_encoding);
+    }
+    else if (m_item_type_4cc == fourcc("uri ")) {
+      writer.write(m_item_uri_type);
     }
+  }
 
-    for (int e = 0; e < extent_count; e++) {
-      Extent extent;
+  prepend_header(writer, box_start);
 
-      if (get_version() > 1 && index_size > 0) {
-        if (index_size == 4) {
-          extent.index = range.read32();
-        }
-        else if (index_size == 8) {
-          extent.index = ((uint64_t) range.read32()) << 32;
-          extent.index |= range.read32();
-        }
-      }
+  return Error::Ok;
+}
 
-      extent.offset = 0;
-      if (offset_size == 4) {
-        extent.offset = range.read32();
-      }
-      else if (offset_size == 8) {
-        extent.offset = ((uint64_t) range.read32()) << 32;
-        extent.offset |= range.read32();
-      }
+
+std::string Box_infe::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
+
+  sstr << indent << "item_ID: " << m_item_ID << "\n"
+       << indent << "item_protection_index: " << m_item_protection_index << "\n"
+       << indent << "item_type: " << fourcc_to_string(m_item_type_4cc) << "\n"
+       << indent << "item_name: " << m_item_name << "\n";
+
+  if (m_item_type_4cc == fourcc("mime")) {
+    sstr << indent << "content_type: " << m_content_type << "\n"
+         << indent << "content_encoding: " << m_content_encoding << "\n";
+  }
+
+  if (m_item_type_4cc == fourcc("uri ")) {
+    sstr << indent << "item uri type: " << m_item_uri_type << "\n";
+  }
+
+  sstr << indent << "hidden item: " << std::boolalpha << m_hidden_item << "\n";
+
+  return sstr.str();
+}
+
+
+Error Box_iinf::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  parse_full_box_header(range);
+
+  // TODO: there are several images in circulation that have an iinf version=2. We should not enforce this with a hard error.
+  if (false && get_version() > 1) {
+    return unsupported_version_error("iinf");
+  }
+
+  int nEntries_size = (get_version() > 0) ? 4 : 2;
+
+  uint32_t item_count;
+  if (nEntries_size == 2) {
+    item_count = range.read16();
+  }
+  else {
+    item_count = range.read32();
+  }
+
+  if (item_count == 0) {
+    return Error::Ok;
+  }
+
+  return read_children(range, item_count, limits);
+}
+
+
+std::string Box_iinf::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
+
+  sstr << dump_children(indent);
+
+  return sstr.str();
+}
+
+
+Error Box_iprp::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  //parse_full_box_header(range);
+
+  return read_children(range, READ_CHILDREN_ALL, limits);
+}
+
+
+void Box_iinf::derive_box_version()
+{
+  if (m_children.size() > 0xFFFF) {
+    set_version(1);
+  }
+  else {
+    set_version(0);
+  }
+}
+
+
+Error Box_iinf::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  int nEntries_size = (get_version() > 0) ? 4 : 2;
+
+  writer.write(nEntries_size, m_children.size());
+
+
+  Error err = write_children(writer);
+
+  prepend_header(writer, box_start);
+
+  return err;
+}
+
+
+std::string Box_iprp::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
+
+  sstr << dump_children(indent);
+
+  return sstr.str();
+}
+
+
+uint32_t Box_ipco::find_or_append_child_box(const std::shared_ptr<Box>& box)
+{
+  for (uint32_t i = 0; i < (uint32_t) m_children.size(); i++) {
+    if (Box::equal(m_children[i], box)) {
+      return i;
+    }
+  }
+  return append_child_box(box);
+}
+
+
+Error Box_ipco::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  //parse_full_box_header(range);
+
+  return read_children(range, READ_CHILDREN_ALL, limits);
+}
+
+
+std::string Box_ipco::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
+
+  sstr << dump_children(indent, true);
+
+  return sstr.str();
+}
+
+
+Error Box_pixi::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  parse_full_box_header(range);
+
+  if (get_version() != 0) {
+    return unsupported_version_error("pixi");
+  }
+
+  StreamReader::grow_status status;
+  uint8_t num_channels = range.read8();
+  status = range.wait_for_available_bytes(num_channels);
+  if (status != StreamReader::grow_status::size_reached) {
+    // TODO: return recoverable error at timeout
+    return Error(heif_error_Invalid_input,
+                 heif_suberror_End_of_data);
+  }
+
+  m_bits_per_channel.resize(num_channels);
+  for (int i = 0; i < num_channels; i++) {
+    m_bits_per_channel[i] = range.read8();
+  }
+
+  return range.get_error();
+}
+
+
+std::string Box_pixi::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
+
+  sstr << indent << "bits_per_channel: ";
+
+  for (size_t i = 0; i < m_bits_per_channel.size(); i++) {
+    if (i > 0) sstr << ",";
+    sstr << ((int) m_bits_per_channel[i]);
+  }
+
+  sstr << "\n";
+
+  return sstr.str();
+}
+
+
+Error Box_pixi::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  if (m_bits_per_channel.size() > 255 ||
+      m_bits_per_channel.empty()) {
+    // TODO: error
+    assert(false);
+  }
+
+  writer.write8((uint8_t) (m_bits_per_channel.size()));
+  for (size_t i = 0; i < m_bits_per_channel.size(); i++) {
+    writer.write8(m_bits_per_channel[i]);
+  }
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+
+Error Box_pasp::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  //parse_full_box_header(range);
+
+  hSpacing = range.read32();
+  vSpacing = range.read32();
+
+  return range.get_error();
+}
+
+
+std::string Box_pasp::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
+
+  sstr << indent << "hSpacing: " << hSpacing << "\n";
+  sstr << indent << "vSpacing: " << vSpacing << "\n";
+
+  return sstr.str();
+}
 
 
-      extent.length = 0;
-      if (length_size == 4) {
-        extent.length = range.read32();
-      }
-      else if (length_size == 8) {
-        extent.length = ((uint64_t) range.read32()) << 32;
-        extent.length |= range.read32();
-      }
+Error Box_pasp::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
 
-      item.extents.push_back(extent);
-    }
+  writer.write32(hSpacing);
+  writer.write32(vSpacing);
 
-    if (!range.error()) {
-      m_items.push_back(item);
-    }
-  }
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
 
-  //printf("end limit: %d\n",sizeLimit);
+
+Error Box_lsel::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  layer_id = range.read16();
 
   return range.get_error();
 }
 
 
-std::string Box_iloc::dump(Indent& indent) const
+std::string Box_lsel::dump(Indent& indent) const
 {
   std::ostringstream sstr;
   sstr << Box::dump(indent);
 
-  for (const Item& item : m_items) {
-    sstr << indent << "item ID: " << item.item_ID << "\n"
-         << indent << "  construction method: " << ((int) item.construction_method) << "\n"
-         << indent << "  data_reference_index: " << std::hex
-         << item.data_reference_index << std::dec << "\n"
-         << indent << "  base_offset: " << item.base_offset << "\n";
-
-    sstr << indent << "  extents: ";
-    for (const Extent& extent : item.extents) {
-      sstr << extent.offset << "," << extent.length;
-      if (extent.index != 0) {
-        sstr << ";index=" << extent.index;
-      }
-      sstr << " ";
-    }
-    sstr << "\n";
-  }
+  sstr << indent << "layer_id: " << layer_id << "\n";
 
   return sstr.str();
 }
 
 
-Error Box_iloc::read_data(const Item& item,
-                          std::shared_ptr<StreamReader> istr,
-                          const std::shared_ptr<Box_idat>& idat,
-                          std::vector<uint8_t>* dest) const
+Error Box_lsel::write(StreamWriter& writer) const
 {
-  //istr.clear();
-
-  for (const auto& extent : item.extents) {
-    if (item.construction_method == 0) {
+  size_t box_start = reserve_box_header_space(writer);
 
-      // --- security check that we do not allocate too much memory
+  writer.write16(layer_id);
 
-      size_t old_size = dest->size();
-      if (MAX_MEMORY_BLOCK_SIZE - old_size < extent.length) {
-        std::stringstream sstr;
-        sstr << "iloc box contained " << extent.length << " bytes, total memory size would be "
-             << (old_size + extent.length) << " bytes, exceeding the security limit of "
-             << MAX_MEMORY_BLOCK_SIZE << " bytes";
+  prepend_header(writer, box_start);
 
-        return Error(heif_error_Memory_allocation_error,
-                     heif_suberror_Security_limit_exceeded,
-                     sstr.str());
-      }
+  return Error::Ok;
+}
 
 
-      // --- make sure that all data is available
+Error Box_clli::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  //parse_full_box_header(range);
 
-      if (extent.offset > MAX_FILE_POS ||
-          item.base_offset > MAX_FILE_POS ||
-          extent.length > MAX_FILE_POS) {
-        return Error(heif_error_Invalid_input,
-                     heif_suberror_Security_limit_exceeded,
-                     "iloc data pointers out of allowed range");
-      }
+  clli.max_content_light_level = range.read16();
+  clli.max_pic_average_light_level = range.read16();
 
-      StreamReader::grow_status status = istr->wait_for_file_size(extent.offset + item.base_offset + extent.length);
-      if (status == StreamReader::size_beyond_eof) {
-        // Out-of-bounds
-        // TODO: I think we should not clear this. Maybe we want to try reading again later and
-        // hence should not lose the data already read.
-        dest->clear();
+  return range.get_error();
+}
 
-        std::stringstream sstr;
-        sstr << "Extent in iloc box references data outside of file bounds "
-             << "(points to file position " << extent.offset + item.base_offset << ")\n";
 
-        return Error(heif_error_Invalid_input,
-                     heif_suberror_End_of_data,
-                     sstr.str());
-      }
-      else if (status == StreamReader::timeout) {
-        // TODO: maybe we should introduce some 'Recoverable error' instead of 'Invalid input'
-        return Error(heif_error_Invalid_input,
-                     heif_suberror_End_of_data);
-      }
+std::string Box_clli::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
 
-      // --- move file pointer to start of data
+  sstr << indent << "max_content_light_level: " << clli.max_content_light_level << "\n";
+  sstr << indent << "max_pic_average_light_level: " << clli.max_pic_average_light_level << "\n";
 
-      bool success = istr->seek(extent.offset + item.base_offset);
-      assert(success);
-      (void) success;
+  return sstr.str();
+}
 
 
-      // --- read data
+Error Box_clli::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
 
-      dest->resize(static_cast<size_t>(old_size + extent.length));
-      success = istr->read((char*) dest->data() + old_size, static_cast<size_t>(extent.length));
-      assert(success);
-    }
-    else if (item.construction_method == 1) {
-      if (!idat) {
-        return Error(heif_error_Invalid_input,
-                     heif_suberror_No_idat_box,
-                     "idat box referenced in iref box is not present in file");
-      }
+  writer.write16(clli.max_content_light_level);
+  writer.write16(clli.max_pic_average_light_level);
 
-      idat->read_data(istr,
-                      extent.offset + item.base_offset,
-                      extent.length,
-                      *dest);
-    }
-    else {
-      std::stringstream sstr;
-      sstr << "Item construction method " << item.construction_method << " not implemented";
-      return Error(heif_error_Unsupported_feature,
-                   heif_suberror_No_idat_box,
-                   sstr.str());
-    }
-  }
+  prepend_header(writer, box_start);
 
   return Error::Ok;
 }
 
 
-Error Box_iloc::append_data(heif_item_id item_ID,
-                            const std::vector<uint8_t>& data,
-                            uint8_t construction_method)
+Box_mdcv::Box_mdcv()
 {
-  // check whether this item ID already exists
+  set_short_type(fourcc("mdcv"));
 
-  size_t idx;
-  for (idx = 0; idx < m_items.size(); idx++) {
-    if (m_items[idx].item_ID == item_ID) {
-      break;
-    }
-  }
+  memset(&mdcv, 0, sizeof(heif_mastering_display_colour_volume));
+}
 
-  // item does not exist -> add a new one to the end
 
-  if (idx == m_items.size()) {
-    Item item;
-    item.item_ID = item_ID;
-    item.construction_method = construction_method;
+Error Box_mdcv::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  //parse_full_box_header(range);
 
-    m_items.push_back(item);
+  for (int c = 0; c < 3; c++) {
+    mdcv.display_primaries_x[c] = range.read16();
+    mdcv.display_primaries_y[c] = range.read16();
   }
 
-  if (m_items[idx].construction_method != construction_method) {
-    // TODO: return error: construction methods do not match
-  }
+  mdcv.white_point_x = range.read16();
+  mdcv.white_point_y = range.read16();
+  mdcv.max_display_mastering_luminance = range.read32();
+  mdcv.min_display_mastering_luminance = range.read32();
 
-  Extent extent;
-  extent.data = data;
+  return range.get_error();
+}
 
-  if (construction_method==1) {
-    extent.offset = m_idat_offset;
-    extent.length = data.size();
 
-    m_idat_offset += (int)data.size();
+std::string Box_mdcv::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
+
+  sstr << indent << "display_primaries (x,y): ";
+  sstr << "(" << mdcv.display_primaries_x[0] << ";" << mdcv.display_primaries_y[0] << "), ";
+  sstr << "(" << mdcv.display_primaries_x[1] << ";" << mdcv.display_primaries_y[1] << "), ";
+  sstr << "(" << mdcv.display_primaries_x[2] << ";" << mdcv.display_primaries_y[2] << ")\n";
+
+  sstr << indent << "white point (x,y): (" << mdcv.white_point_x << ";" << mdcv.white_point_y << ")\n";
+  sstr << indent << "max display mastering luminance: " << mdcv.max_display_mastering_luminance << "\n";
+  sstr << indent << "min display mastering luminance: " << mdcv.min_display_mastering_luminance << "\n";
+
+  return sstr.str();
+}
+
+
+Error Box_mdcv::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  for (int c = 0; c < 3; c++) {
+    writer.write16(mdcv.display_primaries_x[c]);
+    writer.write16(mdcv.display_primaries_y[c]);
   }
 
-  m_items[idx].extents.push_back(std::move(extent));
+  writer.write16(mdcv.white_point_x);
+  writer.write16(mdcv.white_point_y);
+
+  writer.write32(mdcv.max_display_mastering_luminance);
+  writer.write32(mdcv.min_display_mastering_luminance);
+
+  prepend_header(writer, box_start);
 
   return Error::Ok;
 }
 
+Box_amve::Box_amve()
+{
+  set_short_type(fourcc("amve"));
+
+  // These values are not valid.
+  amve.ambient_illumination = 0;
+  amve.ambient_light_x = 0;
+  amve.ambient_light_y = 0;
+}
 
-void Box_iloc::derive_box_version()
+Error Box_amve::parse(BitstreamRange& range, const heif_security_limits* limits)
 {
-  int min_version = m_user_defined_min_version;
+  amve.ambient_illumination = range.read32();
+  amve.ambient_light_x = range.read16();
+  amve.ambient_light_y = range.read16();
 
-  if (m_items.size() > 0xFFFF) {
-    min_version = std::max(min_version, 2);
-  }
+  return range.get_error();
+}
 
-  m_offset_size = 0;
-  m_length_size = 0;
-  m_base_offset_size = 0;
-  m_index_size = 0;
 
-  for (const auto& item : m_items) {
-    // check item_ID size
-    if (item.item_ID > 0xFFFF) {
-      min_version = std::max(min_version, 2);
-    }
+std::string Box_amve::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
 
-    // check construction method
-    if (item.construction_method != 0) {
-      min_version = std::max(min_version, 1);
-    }
+  sstr << indent << "ambient_illumination: " << amve.ambient_illumination << "\n";
+  sstr << indent << "ambient_light_x: " << amve.ambient_light_x << "\n";
+  sstr << indent << "ambient_light_y: " << amve.ambient_light_y << "\n";
 
-    // base offset size
-    /*
-    if (item.base_offset > 0xFFFFFFFF) {
-      m_base_offset_size = 8;
-    }
-    else if (item.base_offset > 0) {
-      m_base_offset_size = 4;
-    }
-    */
+  return sstr.str();
+}
 
-    /*
-    for (const auto& extent : item.extents) {
-      // extent index size
 
-      if (extent.index != 0) {
-        min_version = std::max(min_version, 1);
-        m_index_size = 4;
-      }
+Error Box_amve::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
 
-      if (extent.index > 0xFFFFFFFF) {
-        m_index_size = 8;
-      }
+  writer.write32(amve.ambient_illumination);
+  writer.write16(amve.ambient_light_x);
+  writer.write16(amve.ambient_light_y);
 
-      // extent offset size
-      if (extent.offset > 0xFFFFFFFF) {
-        m_offset_size = 8;
-      }
-      else {
-        m_offset_size = 4;
-      }
+  prepend_header(writer, box_start);
 
-      // extent length size
-      if (extent.length > 0xFFFFFFFF) {
-        m_length_size = 8;
-      }
-      else {
-        m_length_size = 4;
-      }
-    }
-      */
-  }
+  return Error::Ok;
+}
 
-  m_offset_size = 4;
-  m_length_size = 4;
-  m_base_offset_size = 4; // TODO: or could be 8 if we write >4GB files
-  m_index_size = 0;
 
-  set_version((uint8_t) min_version);
+Box_cclv::Box_cclv()
+{
+  set_short_type(fourcc("cclv"));
+
+  m_ccv_primaries_valid = false;
 }
 
 
-Error Box_iloc::write(StreamWriter& writer) const
+void Box_cclv::set_primaries(int32_t x0, int32_t y0, int32_t x1, int32_t y1, int32_t x2, int32_t y2)
 {
-  // --- write idat
+  m_ccv_primaries_valid = true;
+  m_ccv_primaries_x[0] = x0;
+  m_ccv_primaries_y[0] = y0;
+  m_ccv_primaries_x[1] = x1;
+  m_ccv_primaries_y[1] = y1;
+  m_ccv_primaries_x[2] = x2;
+  m_ccv_primaries_y[2] = y2;
+}
 
-  size_t sum_idat_size = 0;
 
-  for (const auto& item : m_items) {
-    if (item.construction_method == 1) {
-      for (const auto& extent : item.extents) {
-        sum_idat_size += extent.data.size();
-      }
+Error Box_cclv::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  uint8_t flags = range.read8();
+
+  m_ccv_primaries_valid = (flags & 0b00100000);
+  bool ccv_min_luminance_valid = (flags & 0b00010000);
+  bool ccv_max_luminance_valid = (flags & 0b00001000);
+  bool ccv_avg_luminance_valid = (flags & 0b00000100);
+
+  if (m_ccv_primaries_valid) {
+    for (int c = 0; c < 3; c++) {
+      m_ccv_primaries_x[c] = range.read32s();
+      m_ccv_primaries_y[c] = range.read32s();
     }
   }
 
-  if (sum_idat_size > 0) {
-    writer.write32((uint32_t) (sum_idat_size + 8));
-    writer.write32(fourcc("idat"));
+  if (ccv_min_luminance_valid) {
+    m_ccv_min_luminance_value = range.read32();
+  }
 
-    for (auto& item : m_items) {
-      if (item.construction_method == 1) {
-        for (auto& extent : item.extents) {
-          writer.write(extent.data);
-        }
-      }
-    }
+  if (ccv_max_luminance_valid) {
+    m_ccv_max_luminance_value = range.read32();
+  }
+
+  if (ccv_avg_luminance_valid) {
+    m_ccv_avg_luminance_value = range.read32();
+  }
+
+  return range.get_error();
+}
+
+
+template <typename T> std::ostream& operator<<(std::ostream& ostr, const std::optional<T>& value)
+{
+  if (value) {
+    ostr << *value;
+  }
+  else {
+    ostr << "-";
   }
 
+  return ostr;
+}
+
+
+std::string Box_cclv::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
 
-  // --- write iloc box
+  sstr << indent << "ccv_primaries_present_flag: " << m_ccv_primaries_valid << "\n";
+  if (m_ccv_primaries_valid) {
+    sstr << indent << "ccv_primaries (x,y): ";
+    sstr << "(" << m_ccv_primaries_x[0] << ";" << m_ccv_primaries_y[0] << "), ";
+    sstr << "(" << m_ccv_primaries_x[1] << ";" << m_ccv_primaries_y[1] << "), ";
+    sstr << "(" << m_ccv_primaries_x[2] << ";" << m_ccv_primaries_y[2] << ")\n";
+  }
 
-  size_t box_start = reserve_box_header_space(writer);
+  sstr << indent << "ccv_min_luminance_value: " << m_ccv_min_luminance_value << "\n";
+  sstr << indent << "ccv_max_luminance_value: " << m_ccv_max_luminance_value << "\n";
+  sstr << indent << "ccv_avg_luminance_value: " << m_ccv_avg_luminance_value << "\n";
 
-  m_iloc_box_start = writer.get_position();
+  return sstr.str();
+}
 
-  int nSkip = 0;
 
-  nSkip += 2;
-  nSkip += (get_version() < 2) ? 2 : 4; // item_count
+Error Box_cclv::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
 
-  for (const auto& item : m_items) {
-    nSkip += (get_version() < 2) ? 2 : 4; // item_ID
-    nSkip += (get_version() >= 1) ? 2 : 0; // construction method
-    nSkip += 4 + m_base_offset_size;
+  uint8_t flags = 0;
+  flags |= m_ccv_primaries_valid     ? uint8_t{0b00100000} : uint8_t{0};
+  flags |= m_ccv_min_luminance_value ? uint8_t{0b00010000} : uint8_t{0};
+  flags |= m_ccv_max_luminance_value ? uint8_t{0b00001000} : uint8_t{0};
+  flags |= m_ccv_avg_luminance_value ? uint8_t{0b00000100} : uint8_t{0};
+  writer.write8(flags);
+
+  if (m_ccv_primaries_valid) {
+    for (int c = 0; c < 3; c++) {
+      writer.write32s(m_ccv_primaries_x[c]);
+      writer.write32s(m_ccv_primaries_y[c]);
+    }
+  }
 
-    for (const auto& extent : item.extents) {
-      (void) extent;
+  if (m_ccv_min_luminance_value) {
+    writer.write32(*m_ccv_min_luminance_value);
+  }
 
-      if (get_version() >= 1) {
-        nSkip += m_index_size;
-      }
+  if (m_ccv_max_luminance_value) {
+    writer.write32(*m_ccv_max_luminance_value);
+  }
 
-      nSkip += m_offset_size + m_length_size;
-    }
+  if (m_ccv_avg_luminance_value) {
+    writer.write32(*m_ccv_avg_luminance_value);
   }
 
-  writer.skip(nSkip);
   prepend_header(writer, box_start);
 
   return Error::Ok;
 }
 
 
-Error Box_iloc::write_mdat_after_iloc(StreamWriter& writer)
+Error Box_ipco::get_properties_for_item_ID(uint32_t itemID,
+                                           const std::shared_ptr<class Box_ipma>& ipma,
+                                           std::vector<std::shared_ptr<Box>>& out_properties) const
 {
-  // --- compute sum of all mdat data
+  const std::vector<Box_ipma::PropertyAssociation>* property_assoc = ipma->get_properties_for_item_ID(itemID);
+  if (property_assoc == nullptr) {
+    std::stringstream sstr;
+    sstr << "Item (ID=" << itemID << ") has no properties assigned to it in ipma box";
 
-  size_t sum_mdat_size = 0;
+    return Error(heif_error_Invalid_input,
+                 heif_suberror_No_properties_assigned_to_item,
+                 sstr.str());
+  }
 
-  for (const auto& item : m_items) {
-    if (item.construction_method == 0) {
-      for (const auto& extent : item.extents) {
-        sum_mdat_size += extent.data.size();
-      }
+  const auto& allProperties = get_all_child_boxes();
+  for (const Box_ipma::PropertyAssociation& assoc : *property_assoc) {
+    if (assoc.property_index > allProperties.size()) {
+      std::stringstream sstr;
+      sstr << "Nonexisting property (index=" << assoc.property_index << ") for item "
+           << " ID=" << itemID << " referenced in ipma box";
+
+      return Error(heif_error_Invalid_input,
+                   heif_suberror_Ipma_box_references_nonexisting_property,
+                   sstr.str());
+    }
+
+    if (assoc.property_index > 0) {
+      out_properties.push_back(allProperties[assoc.property_index - 1]);
     }
   }
 
-  if (sum_mdat_size > 0xFFFFFFFF) {
-    // TODO: box size > 4 GB
+  return Error::Ok;
+}
+
+
+std::shared_ptr<Box> Box_ipco::get_property_for_item_ID(heif_item_id itemID,
+                                                        const std::shared_ptr<class Box_ipma>& ipma,
+                                                        uint32_t box_type) const
+{
+  const std::vector<Box_ipma::PropertyAssociation>* property_assoc = ipma->get_properties_for_item_ID(itemID);
+  if (property_assoc == nullptr) {
+    return nullptr;
   }
 
+  const auto& allProperties = get_all_child_boxes();
+  for (const Box_ipma::PropertyAssociation& assoc : *property_assoc) {
+    if (assoc.property_index > allProperties.size() ||
+        assoc.property_index == 0) {
+      return nullptr;
+    }
 
-  // --- write mdat box
+    const auto& property = allProperties[assoc.property_index - 1];
+    if (property->get_short_type() == box_type) {
+      return property;
+    }
+  }
 
-  writer.write32((uint32_t) (sum_mdat_size + 8));
-  writer.write32(fourcc("mdat"));
+  return nullptr;
+}
 
-  for (auto& item : m_items) {
-    if (item.construction_method == 0) {
-      item.base_offset = writer.get_position();
 
-      for (auto& extent : item.extents) {
-        extent.offset = writer.get_position() - item.base_offset;
-        extent.length = extent.data.size();
+bool Box_ipco::is_property_essential_for_item(heif_item_id itemId,
+                                              const std::shared_ptr<const class Box>& property,
+                                              const std::shared_ptr<class Box_ipma>& ipma) const
+{
+  // find property index
 
-        writer.write(extent.data);
-      }
+  for (int i = 0; i < (int) m_children.size(); i++) {
+    if (m_children[i] == property) {
+      return ipma->is_property_essential_for_item(itemId, i + 1);
     }
   }
 
+  assert(false); // non-existing property
+  return false;
+}
 
-  // --- patch iloc box
 
-  patch_iloc_header(writer);
+Error Box_ispe::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  parse_full_box_header(range);
 
-  return Error::Ok;
+  if (get_version() != 0) {
+    return unsupported_version_error("ispe");
+  }
+
+  m_image_width = range.read32();
+  m_image_height = range.read32();
+
+  return range.get_error();
 }
 
 
-void Box_iloc::patch_iloc_header(StreamWriter& writer) const
+std::string Box_ispe::dump(Indent& indent) const
 {
-  size_t old_pos = writer.get_position();
-  writer.set_position(m_iloc_box_start);
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
 
-  writer.write8((uint8_t) ((m_offset_size << 4) | (m_length_size)));
-  writer.write8((uint8_t) ((m_base_offset_size << 4) | (m_index_size)));
+  sstr << indent << "image width: " << m_image_width << "\n"
+       << indent << "image height: " << m_image_height << "\n";
 
-  if (get_version() < 2) {
-    writer.write16((uint16_t) m_items.size());
-  }
-  else {
-    writer.write32((uint32_t) m_items.size());
-  }
+  return sstr.str();
+}
 
-  for (const auto& item : m_items) {
-    if (get_version() < 2) {
-      writer.write16((uint16_t) item.item_ID);
-    }
-    else {
-      writer.write32((uint32_t) item.item_ID);
-    }
 
-    if (get_version() >= 1) {
-      writer.write16(item.construction_method);
-    }
+Error Box_ispe::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
 
-    writer.write16(item.data_reference_index);
-    writer.write(m_base_offset_size, item.base_offset);
-    writer.write16((uint16_t) item.extents.size());
+  writer.write32(m_image_width);
+  writer.write32(m_image_height);
 
-    for (const auto& extent : item.extents) {
-      if (get_version() >= 1 && m_index_size > 0) {
-        writer.write(m_index_size, extent.index);
-      }
+  prepend_header(writer, box_start);
 
-      writer.write(m_offset_size, extent.offset);
-      writer.write(m_length_size, extent.length);
-    }
+  return Error::Ok;
+}
+
+
+bool Box_ispe::operator==(const Box& other) const
+{
+  const auto* other_ispe = dynamic_cast<const Box_ispe*>(&other);
+  if (other_ispe == nullptr) {
+    return false;
   }
 
-  writer.set_position(old_pos);
+  return (m_image_width == other_ispe->m_image_width &&
+          m_image_height == other_ispe->m_image_height);
 }
 
 
-Error Box_infe::parse(BitstreamRange& range)
+Error Box_ipma::parse(BitstreamRange& range, const heif_security_limits* limits)
 {
   parse_full_box_header(range);
 
-  if (get_version() <= 1) {
-    m_item_ID = range.read16();
-    m_item_protection_index = range.read16();
+  // TODO: is there any specification of allowed values for the ipma version in the HEIF standards?
 
-    m_item_name = range.read_string();
-    m_content_type = range.read_string();
-    m_content_encoding = range.read_string();
+  if (get_version() > 1) {
+    return unsupported_version_error("ipma");
   }
 
-  if (get_version() >= 2) {
-    m_hidden_item = (get_flags() & 1);
+  uint32_t entry_cnt = range.read32();
 
-    if (get_version() == 2) {
-      m_item_ID = range.read16();
+  if (limits->max_items && entry_cnt > limits->max_items) {
+    std::stringstream sstr;
+    sstr << "ipma box wants to define properties for " << entry_cnt
+         << " items, but the security limit has been set to " << limits->max_items << " items";
+    return {heif_error_Invalid_input,
+            heif_suberror_Security_limit_exceeded,
+            sstr.str()};
+  }
+
+  for (uint32_t i = 0; i < entry_cnt && !range.error() && !range.eof(); i++) {
+    Entry entry;
+    if (get_version() < 1) {
+      entry.item_ID = range.read16();
     }
     else {
-      m_item_ID = range.read32();
+      entry.item_ID = range.read32();
     }
 
-    m_item_protection_index = range.read16();
-    uint32_t item_type = range.read32();
-    if (item_type != 0) {
-      m_item_type = to_fourcc(item_type);
+    int assoc_cnt = range.read8();
+    for (int k = 0; k < assoc_cnt; k++) {
+      PropertyAssociation association{};
+
+      uint16_t index;
+      if (get_flags() & 1) {
+        index = range.read16();
+        association.essential = !!(index & 0x8000);
+        association.property_index = (index & 0x7fff);
+      }
+      else {
+        index = range.read8();
+        association.essential = !!(index & 0x80);
+        association.property_index = (index & 0x7f);
+      }
+
+      entry.associations.push_back(association);
     }
 
-    m_item_name = range.read_string();
-    if (item_type == fourcc("mime")) {
-      m_content_type = range.read_string();
-      m_content_encoding = range.read_string();
+    m_entries.push_back(entry);
+  }
+
+  return range.get_error();
+}
+
+
+const std::vector<Box_ipma::PropertyAssociation>* Box_ipma::get_properties_for_item_ID(uint32_t itemID) const
+{
+  for (const auto& entry : m_entries) {
+    if (entry.item_ID == itemID) {
+      return &entry.associations;
     }
-    else if (item_type == fourcc("uri ")) {
-      m_item_uri_type = range.read_string();
+  }
+
+  return nullptr;
+}
+
+
+bool Box_ipma::is_property_essential_for_item(heif_item_id itemId, int propertyIndex) const
+{
+  for (const auto& entry : m_entries) {
+    if (entry.item_ID == itemId) {
+      for (const auto& assoc : entry.associations) {
+        if (assoc.property_index == propertyIndex) {
+          return assoc.essential;
+        }
+      }
     }
   }
 
-  return range.get_error();
+  assert(false);
+  return false;
 }
 
 
-void Box_infe::derive_box_version()
+void Box_ipma::add_property_for_item_ID(heif_item_id itemID,
+                                        PropertyAssociation assoc)
 {
-  int min_version = 0;
+  size_t idx;
+  for (idx = 0; idx < m_entries.size(); idx++) {
+    if (m_entries[idx].item_ID == itemID) {
+      break;
+    }
+  }
 
-  if (m_hidden_item) {
-    min_version = std::max(min_version, 2);
+  // if itemID does not exist, add a new entry
+  if (idx == m_entries.size()) {
+    Entry entry;
+    entry.item_ID = itemID;
+    m_entries.push_back(entry);
   }
 
-  if (m_item_ID > 0xFFFF) {
-    min_version = std::max(min_version, 3);
+  // If the property is already associated with the item, skip.
+  for (auto const& a : m_entries[idx].associations) {
+    if (a.property_index == assoc.property_index) {
+      return;
+    }
+
+    // TODO: should we check that the essential flag matches and return an internal error if not?
   }
 
+  // add the property association
+  m_entries[idx].associations.push_back(assoc);
+}
+
 
-  if (m_item_type != "") {
-    min_version = std::max(min_version, 2);
+std::string Box_ipma::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
+
+  for (const Entry& entry : m_entries) {
+    sstr << indent << "associations for item ID: " << entry.item_ID << "\n";
+    indent++;
+    for (const auto& assoc : entry.associations) {
+      sstr << indent << "property index: " << assoc.property_index
+           << " (essential: " << std::boolalpha << assoc.essential << ")\n";
+    }
+    indent--;
   }
 
-  set_version((uint8_t) min_version);
+  return sstr.str();
 }
 
 
-void Box_infe::set_hidden_item(bool hidden)
+void Box_ipma::derive_box_version()
 {
-  m_hidden_item = hidden;
+  int version = 0;
+  bool large_property_indices = false;
 
-  if (m_hidden_item) {
-    set_flags(get_flags() | 1);
-  }
-  else {
-    set_flags(get_flags() & ~1);
+  for (const Entry& entry : m_entries) {
+    if (entry.item_ID > 0xFFFF) {
+      version = 1;
+    }
+
+    for (const auto& assoc : entry.associations) {
+      if (assoc.property_index > 0x7F) {
+        large_property_indices = true;
+      }
+    }
   }
+
+  set_version((uint8_t) version);
+  set_flags(large_property_indices ? 1 : 0);
 }
 
-Error Box_infe::write(StreamWriter& writer) const
+
+Error Box_ipma::write(StreamWriter& writer) const
 {
   size_t box_start = reserve_box_header_space(writer);
 
-  if (get_version() <= 1) {
-    writer.write16((uint16_t) m_item_ID);
-    writer.write16(m_item_protection_index);
-
-    writer.write(m_item_name);
-    writer.write(m_content_type);
-    writer.write(m_content_encoding);
-  }
-
-  if (get_version() >= 2) {
-    if (get_version() == 2) {
-      writer.write16((uint16_t) m_item_ID);
-    }
-    else if (get_version() == 3) {
-      writer.write32(m_item_ID);
-    }
+  size_t entry_cnt = m_entries.size();
+  writer.write32((uint32_t) entry_cnt);
 
-    writer.write16(m_item_protection_index);
+  for (const Entry& entry : m_entries) {
 
-    if (m_item_type.empty()) {
-      writer.write32(0);
+    if (get_version() < 1) {
+      writer.write16((uint16_t) entry.item_ID);
     }
     else {
-      writer.write32(from_fourcc(m_item_type.c_str()));
+      writer.write32(entry.item_ID);
     }
 
-    writer.write(m_item_name);
-    if (m_item_type == "mime") {
-      writer.write(m_content_type);
-      writer.write(m_content_encoding);
+    size_t assoc_cnt = entry.associations.size();
+    if (assoc_cnt > 0xFF) {
+      // TODO: error, too many associations
     }
-    else if (m_item_type == "uri ") {
-      writer.write(m_item_uri_type);
+
+    writer.write8((uint8_t) assoc_cnt);
+
+    for (const PropertyAssociation& association : entry.associations) {
+
+      if (get_flags() & 1) {
+        writer.write16((uint16_t) ((association.essential ? 0x8000 : 0) |
+                                   (association.property_index & 0x7FFF)));
+      }
+      else {
+        writer.write8((uint8_t) ((association.essential ? 0x80 : 0) |
+                                 (association.property_index & 0x7F)));
+      }
     }
   }
 
@@ -1547,678 +3352,654 @@ Error Box_infe::write(StreamWriter& writer) const
 }
 
 
-std::string Box_infe::dump(Indent& indent) const
+void Box_ipma::insert_entries_from_other_ipma_box(const Box_ipma& b)
 {
-  std::ostringstream sstr;
-  sstr << Box::dump(indent);
+  m_entries.insert(m_entries.end(),
+                   b.m_entries.begin(),
+                   b.m_entries.end());
+}
 
-  sstr << indent << "item_ID: " << m_item_ID << "\n"
-       << indent << "item_protection_index: " << m_item_protection_index << "\n"
-       << indent << "item_type: " << m_item_type << "\n"
-       << indent << "item_name: " << m_item_name << "\n"
-       << indent << "content_type: " << m_content_type << "\n"
-       << indent << "content_encoding: " << m_content_encoding << "\n"
-       << indent << "item uri type: " << m_item_uri_type << "\n"
-       << indent << "hidden item: " << std::boolalpha << m_hidden_item << "\n";
 
-  return sstr.str();
+void Box_ipma::sort_properties(const std::shared_ptr<Box_ipco>& ipco)
+{
+  auto properties = ipco->get_all_child_boxes();
+
+  for (auto& item : m_entries) {
+    size_t nAssoc = item.associations.size();
+
+    // simple Bubble sort as a stable sorting algorithm
+
+    for (size_t n = 0; n < nAssoc - 1; n++)
+      for (size_t i = 0; i < nAssoc - 1 - n; i++) {
+        // If transformative property precedes descriptive property, swap them.
+        if (properties[item.associations[i].property_index - 1]->is_transformative_property() &&
+            !properties[item.associations[i + 1].property_index - 1]->is_transformative_property()) {
+          std::swap(item.associations[i], item.associations[i+1]);
+        }
+      }
+  }
 }
 
 
-Error Box_iinf::parse(BitstreamRange& range)
+Error Box_auxC::parse(BitstreamRange& range, const heif_security_limits* limits)
 {
   parse_full_box_header(range);
 
-  int nEntries_size = (get_version() > 0) ? 4 : 2;
-
-  int item_count;
-  if (nEntries_size == 2) {
-    item_count = range.read16();
+  if (get_version() != 0) {
+    return unsupported_version_error("auxC");
   }
-  else {
-    item_count = range.read32();
+
+  m_aux_type = range.read_string();
+
+  while (!range.eof()) {
+    m_aux_subtypes.push_back(range.read8());
   }
 
-  if (item_count == 0) {
-    return Error::Ok;
+  return range.get_error();
+}
+
+
+Error Box_auxC::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  writer.write(m_aux_type);
+
+  for (uint8_t subtype : m_aux_subtypes) {
+    writer.write8(subtype);
   }
 
-  // TODO: Only try to read "item_count" children.
-  return read_children(range);
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
 }
 
 
-std::string Box_iinf::dump(Indent& indent) const
+std::string Box_auxC::dump(Indent& indent) const
 {
   std::ostringstream sstr;
   sstr << Box::dump(indent);
 
-  sstr << dump_children(indent);
+  sstr << indent << "aux type: " << m_aux_type << "\n"
+       << indent << "aux subtypes: ";
+  for (uint8_t subtype : m_aux_subtypes) {
+    sstr << std::hex << std::setw(2) << std::setfill('0') << ((int) subtype) << " ";
+  }
+
+  sstr << "\n";
 
   return sstr.str();
 }
 
 
-Error Box_iprp::parse(BitstreamRange& range)
+Error Box_irot::parse(BitstreamRange& range, const heif_security_limits* limits)
 {
   //parse_full_box_header(range);
 
-  return read_children(range);
-}
+  uint16_t rotation = range.read8();
+  rotation &= 0x03;
 
+  m_rotation = rotation * 90;
 
-void Box_iinf::derive_box_version()
-{
-  if (m_children.size() > 0xFFFF) {
-    set_version(1);
-  }
-  else {
-    set_version(0);
-  }
+  return range.get_error();
 }
 
 
-Error Box_iinf::write(StreamWriter& writer) const
+Error Box_irot::write(StreamWriter& writer) const
 {
   size_t box_start = reserve_box_header_space(writer);
 
-  int nEntries_size = (get_version() > 0) ? 4 : 2;
-
-  writer.write(nEntries_size, m_children.size());
-
-
-  Error err = write_children(writer);
+  writer.write8((uint8_t) (m_rotation / 90));
 
   prepend_header(writer, box_start);
 
-  return err;
+  return Error::Ok;
 }
 
 
-std::string Box_iprp::dump(Indent& indent) const
+std::string Box_irot::dump(Indent& indent) const
 {
   std::ostringstream sstr;
   sstr << Box::dump(indent);
 
-  sstr << dump_children(indent);
+  sstr << indent << "rotation: " << m_rotation << " degrees (CCW)\n";
 
   return sstr.str();
 }
 
 
-Error Box_ipco::parse(BitstreamRange& range)
+Error Box_imir::parse(BitstreamRange& range, const heif_security_limits* limits)
 {
   //parse_full_box_header(range);
 
-  return read_children(range);
+  uint8_t axis = range.read8();
+  if (axis & 1) {
+    m_axis = heif_transform_mirror_direction_horizontal;
+  }
+  else {
+    m_axis = heif_transform_mirror_direction_vertical;
+  }
+
+  return range.get_error();
 }
 
 
-std::string Box_ipco::dump(Indent& indent) const
+Error Box_imir::write(StreamWriter& writer) const
 {
-  std::ostringstream sstr;
-  sstr << Box::dump(indent);
-
-  sstr << dump_children(indent);
-
-  return sstr.str();
-}
+  size_t box_start = reserve_box_header_space(writer);
 
-Error color_profile_nclx::parse(BitstreamRange& range)
-{
-  StreamReader::grow_status status;
-  status = range.wait_for_available_bytes(7);
-  if (status != StreamReader::size_reached) {
-    // TODO: return recoverable error at timeout
-    return Error(heif_error_Invalid_input,
-                 heif_suberror_End_of_data);
-  }
+  writer.write8(m_axis);
 
-  m_colour_primaries = range.read16();
-  m_transfer_characteristics = range.read16();
-  m_matrix_coefficients = range.read16();
-  m_full_range_flag = (range.read8() & 0x80 ? true : false);
+  prepend_header(writer, box_start);
 
   return Error::Ok;
 }
 
-Error color_profile_nclx::get_nclx_color_profile(struct heif_color_profile_nclx** out_data) const
+
+std::string Box_imir::dump(Indent& indent) const
 {
-  *out_data = alloc_nclx_color_profile();
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
 
-  if (*out_data == nullptr) {
-    return Error(heif_error_Memory_allocation_error,
-                 heif_suberror_Unspecified);
+  sstr << indent << "mirror direction: ";
+  switch (m_axis) {
+    case heif_transform_mirror_direction_vertical:
+      sstr << "vertical\n";
+      break;
+    case heif_transform_mirror_direction_horizontal:
+      sstr << "horizontal\n";
+      break;
+    case heif_transform_mirror_direction_invalid:
+      sstr << "invalid\n";
+      break;
   }
 
-  struct heif_color_profile_nclx* nclx = *out_data;
-
-  nclx->version = 1;
-  nclx->color_primaries = (enum heif_color_primaries) get_colour_primaries();
-  nclx->transfer_characteristics = (enum heif_transfer_characteristics) get_transfer_characteristics();
-  nclx->matrix_coefficients = (enum heif_matrix_coefficients) get_matrix_coefficients();
-  nclx->full_range_flag = get_full_range_flag();
-
-  // fill color primaries
-
-  auto primaries = ::get_colour_primaries(nclx->color_primaries);
-
-  nclx->color_primary_red_x = primaries.redX;
-  nclx->color_primary_red_y = primaries.redY;
-  nclx->color_primary_green_x = primaries.greenX;
-  nclx->color_primary_green_y = primaries.greenY;
-  nclx->color_primary_blue_x = primaries.blueX;
-  nclx->color_primary_blue_y = primaries.blueY;
-  nclx->color_primary_white_x = primaries.whiteX;
-  nclx->color_primary_white_y = primaries.whiteY;
-
-  return Error::Ok;
+  return sstr.str();
 }
 
 
-struct heif_color_profile_nclx* color_profile_nclx::alloc_nclx_color_profile()
+Error Box_clap::parse(BitstreamRange& range, const heif_security_limits* limits)
 {
-  auto profile = (heif_color_profile_nclx*) malloc(sizeof(struct heif_color_profile_nclx));
+  //parse_full_box_header(range);
+
+  uint32_t clean_aperture_width_num = range.read32();
+  uint32_t clean_aperture_width_den = range.read32();
+  uint32_t clean_aperture_height_num = range.read32();
+  uint32_t clean_aperture_height_den = range.read32();
+
+  // Note: in the standard document 14496-12(2015), it says that the offset values should also be unsigned integers,
+  // but this is obviously an error. Even the accompanying standard text says that offsets may be negative.
+  int32_t horizontal_offset_num = (int32_t) range.read32();
+  uint32_t horizontal_offset_den = (uint32_t) range.read32();
+  int32_t vertical_offset_num = (int32_t) range.read32();
+  uint32_t vertical_offset_den = (uint32_t) range.read32();
+
+  if (clean_aperture_width_num > (uint32_t) std::numeric_limits<int32_t>::max() ||
+      clean_aperture_width_den > (uint32_t) std::numeric_limits<int32_t>::max() ||
+      clean_aperture_height_num > (uint32_t) std::numeric_limits<int32_t>::max() ||
+      clean_aperture_height_den > (uint32_t) std::numeric_limits<int32_t>::max() ||
+      horizontal_offset_den > (uint32_t) std::numeric_limits<int32_t>::max() ||
+      vertical_offset_den > (uint32_t) std::numeric_limits<int32_t>::max()) {
+    return Error(heif_error_Invalid_input,
+                 heif_suberror_Invalid_fractional_number,
+                 "Exceeded supported value range.");
+  }
 
-  if (profile) {
-    profile->version = 1;
-    profile->color_primaries = heif_color_primaries_unspecified;
-    profile->transfer_characteristics = heif_transfer_characteristic_unspecified;
-    profile->matrix_coefficients = heif_matrix_coefficients_ITU_R_BT_601_6;
-    profile->full_range_flag = true;
+  m_clean_aperture_width = Fraction(clean_aperture_width_num,
+                                    clean_aperture_width_den);
+  m_clean_aperture_height = Fraction(clean_aperture_height_num,
+                                     clean_aperture_height_den);
+  m_horizontal_offset = Fraction(horizontal_offset_num, (int32_t) horizontal_offset_den);
+  m_vertical_offset = Fraction(vertical_offset_num, (int32_t) vertical_offset_den);
+  if (!m_clean_aperture_width.is_valid() || !m_clean_aperture_height.is_valid() ||
+      !m_horizontal_offset.is_valid() || !m_vertical_offset.is_valid()) {
+    return Error(heif_error_Invalid_input,
+                 heif_suberror_Invalid_fractional_number);
   }
 
-  return profile;
+  return range.get_error();
 }
 
 
-void color_profile_nclx::free_nclx_color_profile(struct heif_color_profile_nclx* profile)
+Error Box_clap::write(StreamWriter& writer) const
 {
-  free(profile);
-}
+  size_t box_start = reserve_box_header_space(writer);
+
+  writer.write32(m_clean_aperture_width.numerator);
+  writer.write32(m_clean_aperture_width.denominator);
+  writer.write32(m_clean_aperture_height.numerator);
+  writer.write32(m_clean_aperture_height.denominator);
+  writer.write32(m_horizontal_offset.numerator);
+  writer.write32(m_horizontal_offset.denominator);
+  writer.write32(m_vertical_offset.numerator);
+  writer.write32(m_vertical_offset.denominator);
 
+  prepend_header(writer, box_start);
 
-void color_profile_nclx::set_default()
-{
-  m_colour_primaries = 2;
-  m_transfer_characteristics = 2;
-  m_matrix_coefficients = 6;
-  m_full_range_flag = true;
+  return Error::Ok;
 }
 
 
-void color_profile_nclx::set_undefined()
+std::string Box_clap::dump(Indent& indent) const
 {
-  m_colour_primaries = 2;
-  m_transfer_characteristics = 2;
-  m_matrix_coefficients = 2;
-  m_full_range_flag = true;
-}
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
 
+  sstr << indent << "clean_aperture: " << m_clean_aperture_width.numerator
+       << "/" << m_clean_aperture_width.denominator << " x "
+       << m_clean_aperture_height.numerator << "/"
+       << m_clean_aperture_height.denominator << "\n";
+  sstr << indent << "offset: " << m_horizontal_offset.numerator << "/"
+       << m_horizontal_offset.denominator << " ; "
+       << m_vertical_offset.numerator << "/"
+       << m_vertical_offset.denominator << "\n";
 
-void color_profile_nclx::set_from_heif_color_profile_nclx(const struct heif_color_profile_nclx* nclx)
-{
-  m_colour_primaries = nclx->color_primaries;
-  m_transfer_characteristics = nclx->transfer_characteristics;
-  m_matrix_coefficients = nclx->matrix_coefficients;
-  m_full_range_flag = nclx->full_range_flag;
+  return sstr.str();
 }
 
 
-Error Box_colr::parse(BitstreamRange& range)
+double Box_clap::left(int image_width) const
 {
-  StreamReader::grow_status status;
-  uint32_t colour_type = range.read32();
-
-  if (colour_type == fourcc("nclx")) {
-    auto color_profile = std::make_shared<color_profile_nclx>();
-    m_color_profile = color_profile;
-    Error err = color_profile->parse(range);
-    if (err) {
-      return err;
-    }
-  }
-  else if (colour_type == fourcc("prof") ||
-           colour_type == fourcc("rICC")) {
-    auto profile_size = get_box_size() - get_header_size() - 4;
-    status = range.wait_for_available_bytes(profile_size);
-    if (status != StreamReader::size_reached) {
-      // TODO: return recoverable error at timeout
-      return Error(heif_error_Invalid_input,
-                   heif_suberror_End_of_data);
-    }
-
-    std::vector<uint8_t> rawData(profile_size);
-    for (size_t i = 0; i < profile_size; i++) {
-      rawData[i] = range.read8();
-    }
-
-    m_color_profile = std::make_shared<color_profile_raw>(colour_type, rawData);
-  }
-  else {
-    return Error(heif_error_Invalid_input,
-                 heif_suberror_Unknown_color_profile_type);
-  }
+  Fraction pcX = m_horizontal_offset + Fraction(image_width - 1, 2);
+  Fraction left = pcX - (m_clean_aperture_width - 1) / 2;
+  return left.to_double();
+}
 
-  return range.get_error();
+double Box_clap::top(int image_height) const
+{
+  Fraction pcY = m_vertical_offset + Fraction(image_height - 1, 2);
+  Fraction top = pcY - (m_clean_aperture_height - 1) / 2;
+  return top.to_double();
 }
 
 
-std::string Box_colr::dump(Indent& indent) const
+int Box_clap::left_rounded(uint32_t image_width) const
 {
-  std::ostringstream sstr;
-  sstr << Box::dump(indent);
+  // pcX = horizOff + (width  - 1)/2
+  // pcX ± (cleanApertureWidth - 1)/2
 
-  sstr << indent << "colour_type: " << to_fourcc(get_color_profile_type()) << "\n";
+  // left = horizOff + (width-1)/2 - (clapWidth-1)/2
 
-  if (m_color_profile) {
-    sstr << m_color_profile->dump(indent);
-  }
-  else {
-    sstr << "no color profile\n";
-  }
+  Fraction pcX = m_horizontal_offset + Fraction(image_width - 1U, 2U);
+  Fraction left = pcX - (m_clean_aperture_width - 1) / 2;
 
-  return sstr.str();
+  return left.round_down();
 }
 
-
-std::string color_profile_raw::dump(Indent& indent) const
+int Box_clap::right_rounded(uint32_t image_width) const
 {
-  std::ostringstream sstr;
-  sstr << indent << "profile size: " << m_data.size() << "\n";
-  return sstr.str();
-}
-
+  Fraction right = m_clean_aperture_width - 1 + left_rounded(image_width);
 
-std::string color_profile_nclx::dump(Indent& indent) const
-{
-  std::ostringstream sstr;
-  sstr << indent << "colour_primaries: " << m_colour_primaries << "\n"
-       << indent << "transfer_characteristics: " << m_transfer_characteristics << "\n"
-       << indent << "matrix_coefficients: " << m_matrix_coefficients << "\n"
-       << indent << "full_range_flag: " << m_full_range_flag << "\n";
-  return sstr.str();
+  return right.round();
 }
 
-
-Error color_profile_nclx::write(StreamWriter& writer) const
+int Box_clap::top_rounded(uint32_t image_height) const
 {
-  writer.write16(m_colour_primaries);
-  writer.write16(m_transfer_characteristics);
-  writer.write16(m_matrix_coefficients);
-  writer.write8(m_full_range_flag ? 0x80 : 0x00);
+  Fraction pcY = m_vertical_offset + Fraction(image_height - 1U, 2U);
+  Fraction top = pcY - (m_clean_aperture_height - 1) / 2;
 
-  return Error::Ok;
+  return top.round();
 }
 
-Error color_profile_raw::write(StreamWriter& writer) const
+int Box_clap::bottom_rounded(uint32_t image_height) const
 {
-  writer.write(m_data);
+  Fraction bottom = m_clean_aperture_height - 1 + top_rounded(image_height);
 
-  return Error::Ok;
+  return bottom.round();
 }
 
-Error Box_colr::write(StreamWriter& writer) const
+int Box_clap::get_width_rounded() const
 {
-  size_t box_start = reserve_box_header_space(writer);
-
-  assert(m_color_profile);
+  return m_clean_aperture_width.round();
+}
 
-  writer.write32(m_color_profile->get_type());
+int Box_clap::get_height_rounded() const
+{
+  return m_clean_aperture_height.round();
+}
 
-  Error err = m_color_profile->write(writer);
-  if (err) {
-    return err;
-  }
+void Box_clap::set(uint32_t clap_width, uint32_t clap_height,
+                   uint32_t image_width, uint32_t image_height)
+{
+  assert(image_width >= clap_width);
+  assert(image_height >= clap_height);
 
-  prepend_header(writer, box_start);
+  m_clean_aperture_width = Fraction(clap_width, 1U);
+  m_clean_aperture_height = Fraction(clap_height, 1U);
 
-  return Error::Ok;
+  m_horizontal_offset = Fraction(-(int32_t) (image_width - clap_width), 2);
+  m_vertical_offset = Fraction(-(int32_t) (image_height - clap_height), 2);
 }
 
 
-Error Box_pixi::parse(BitstreamRange& range)
+Error Box_iref::parse(BitstreamRange& range, const heif_security_limits* limits)
 {
   parse_full_box_header(range);
 
-  StreamReader::grow_status status;
-  uint8_t num_channels = range.read8();
-  status = range.wait_for_available_bytes(num_channels);
-  if (status != StreamReader::size_reached) {
-    // TODO: return recoverable error at timeout
-    return Error(heif_error_Invalid_input,
-                 heif_suberror_End_of_data);
-  }
-
-  m_bits_per_channel.resize(num_channels);
-  for (int i = 0; i < num_channels; i++) {
-    m_bits_per_channel[i] = range.read8();
+  if (get_version() > 1) {
+    return unsupported_version_error("iref");
   }
 
-  return range.get_error();
-}
+  while (!range.eof()) {
+    Reference ref;
 
+    Error err = ref.header.parse_header(range);
+    if (err != Error::Ok) {
+      return err;
+    }
 
-std::string Box_pixi::dump(Indent& indent) const
-{
-  std::ostringstream sstr;
-  sstr << Box::dump(indent);
+    int read_len = (get_version() == 0) ? 16 : 32;
 
-  sstr << indent << "bits_per_channel: ";
+    ref.from_item_ID = static_cast<uint32_t>(range.read_uint(read_len));
+    uint16_t nRefs = range.read16();
 
-  for (size_t i = 0; i < m_bits_per_channel.size(); i++) {
-    if (i > 0) sstr << ",";
-    sstr << ((int) m_bits_per_channel[i]);
-  }
+    if (nRefs==0) {
+      return {heif_error_Invalid_input,
+              heif_suberror_Unspecified,
+              "Input file has an 'iref' box with no references."};
+    }
 
-  sstr << "\n";
+    if (limits->max_items && nRefs > limits->max_items) {
+      std::stringstream sstr;
+      sstr << "Number of references in iref box (" << nRefs << ") exceeds the security limits of " << limits->max_items << " references.";
 
-  return sstr.str();
-}
+      return {heif_error_Invalid_input,
+              heif_suberror_Security_limit_exceeded,
+              sstr.str()};
+    }
 
+    for (int i = 0; i < nRefs; i++) {
+      if (range.eof()) {
+        std::stringstream sstr;
+        sstr << "iref box should contain " << nRefs << " references, but we can only read " << i << " references.";
 
-Error Box_pixi::write(StreamWriter& writer) const
-{
-  size_t box_start = reserve_box_header_space(writer);
+        return {heif_error_Invalid_input,
+                heif_suberror_End_of_data,
+                sstr.str()};
+      }
 
-  if (m_bits_per_channel.size() > 255 ||
-      m_bits_per_channel.empty()) {
-    // TODO: error
-    assert(false);
-  }
+      ref.to_item_ID.push_back(static_cast<uint32_t>(range.read_uint(read_len)));
+    }
 
-  writer.write8((uint8_t) (m_bits_per_channel.size()));
-  for (size_t i = 0; i < m_bits_per_channel.size(); i++) {
-    writer.write8(m_bits_per_channel[i]);
+    m_references.push_back(ref);
   }
 
-  prepend_header(writer, box_start);
-
-  return Error::Ok;
-}
-
 
-Error Box_ipco::get_properties_for_item_ID(uint32_t itemID,
-                                           const std::shared_ptr<class Box_ipma>& ipma,
-                                           std::vector<Property>& out_properties) const
-{
-  const std::vector<Box_ipma::PropertyAssociation>* property_assoc = ipma->get_properties_for_item_ID(itemID);
-  if (property_assoc == nullptr) {
-    std::stringstream sstr;
-    sstr << "Item (ID=" << itemID << ") has no properties assigned to it in ipma box";
+  // --- check for duplicate references
 
-    return Error(heif_error_Invalid_input,
-                 heif_suberror_No_properties_assigned_to_item,
-                 sstr.str());
+  if (auto error = check_for_double_references()) {
+    return error;
   }
 
-  const auto& allProperties = get_all_child_boxes();
-  for (const Box_ipma::PropertyAssociation& assoc : *property_assoc) {
-    if (assoc.property_index > allProperties.size()) {
-      std::stringstream sstr;
-      sstr << "Nonexisting property (index=" << assoc.property_index << ") for item "
-           << " ID=" << itemID << " referenced in ipma box";
 
-      return Error(heif_error_Invalid_input,
-                   heif_suberror_Ipma_box_references_nonexisting_property,
-                   sstr.str());
-    }
+#if 0
+  // Note: This input sanity check first did not work as expected.
+  // Its idea was to prevent infinite recursions while decoding when the input file
+  // contains cyclic references. However, apparently there are cases where cyclic
+  // references are actually allowed, like with images that have premultiplied alpha channels:
+  // | Box: iref -----
+  // | size: 40   (header size: 12)
+  // | reference with type 'auxl' from ID: 2 to IDs: 1
+  // | reference with type 'prem' from ID: 1 to IDs: 2
+  //
+  // We now test for cyclic references during the image decoding.
+  // We pass down the item IDs that have already been seen during the decoding process.
+  // If we try to decode an image IDs that has already been seen previously, we throw an error.
+  // The advantage is that the error only occurs when we are trying to decode the faulty image.
 
-    Property prop;
-    prop.essential = assoc.essential;
+  // --- check for cyclic references
 
-    if (assoc.property_index > 0) {
-      prop.property = allProperties[assoc.property_index - 1];
-      out_properties.push_back(prop);
+  for (const auto& ref : m_references) {
+    if (ref.header.get_short_type() != fourcc("dimg") &&
+        ref.header.get_short_type() != fourcc("auxl")) {
+      continue;
     }
-  }
-
-  return Error::Ok;
-}
 
+    std::set<heif_item_id> reached_ids; // IDs that we have already reached in the DAG
+    std::set<heif_item_id> todo;    // IDs that still need to be followed
 
-std::shared_ptr<Box> Box_ipco::get_property_for_item_ID(heif_item_id itemID,
-                                                        const std::shared_ptr<class Box_ipma>& ipma,
-                                                        uint32_t box_type) const
-{
-  const std::vector<Box_ipma::PropertyAssociation>* property_assoc = ipma->get_properties_for_item_ID(itemID);
-  if (property_assoc == nullptr) {
-    return nullptr;
-  }
+    bool reverse = (ref.header.get_short_type() != fourcc("auxl"));
 
-  const auto& allProperties = get_all_child_boxes();
-  for (const Box_ipma::PropertyAssociation& assoc : *property_assoc) {
-    if (assoc.property_index > allProperties.size() ||
-        assoc.property_index == 0) {
-      return nullptr;
+    if (!reverse) {
+      todo.insert(ref.from_item_ID);  // start at base item
     }
+    else {
+      if (ref.to_item_ID.empty()) {
+        continue;
+      }
 
-    const auto& property = allProperties[assoc.property_index - 1];
-    if (property->get_short_type() == box_type) {
-      return property;
+      // TODO: what if aux image is assigned to multiple images?
+      todo.insert(ref.to_item_ID[0]);  // start at base item
     }
-  }
 
-  return nullptr;
-}
+    while (!todo.empty()) {
+      // transfer ID into set of reached IDs
+      auto id = *todo.begin();
+      todo.erase(id);
+      reached_ids.insert(id);
 
+      // if this ID refers to another 'iref', follow it
 
-Error Box_ispe::parse(BitstreamRange& range)
-{
-  parse_full_box_header(range);
+      for (const auto& succ_ref : m_references) {
+        if (succ_ref.header.get_short_type() != fourcc("dimg") &&
+            succ_ref.header.get_short_type() != fourcc("auxl")) {
+          continue;
+        }
 
-  m_image_width = range.read32();
-  m_image_height = range.read32();
+        heif_item_id from;
+        std::vector<heif_item_id> to;
 
-  return range.get_error();
-}
+        if (succ_ref.header.get_short_type() == fourcc("auxl")) {
+          if (succ_ref.to_item_ID.empty()) {
+            continue;
+          }
 
+          from = succ_ref.to_item_ID[0];
+          to = {succ_ref.from_item_ID};
+        }
+        else {
+          from = succ_ref.from_item_ID;
+          to = succ_ref.to_item_ID;
+        }
 
-std::string Box_ispe::dump(Indent& indent) const
-{
-  std::ostringstream sstr;
-  sstr << Box::dump(indent);
+        if (from == id) {
 
-  sstr << indent << "image width: " << m_image_width << "\n"
-       << indent << "image height: " << m_image_height << "\n";
+          // Check whether any successor IDs has been visited yet, which would be an error.
+          // Otherwise, put that ID into the 'todo' set.
 
-  return sstr.str();
-}
+          for (const auto& succ_ref_id : to) {
+            if (reached_ids.find(succ_ref_id) != reached_ids.end()) {
+              return Error(heif_error_Invalid_input,
+                           heif_suberror_Unspecified,
+                           "'iref' has cyclic references");
+            }
 
+            todo.insert(succ_ref_id);
+          }
+        }
+      }
+    }
+  }
+#endif
 
-Error Box_ispe::write(StreamWriter& writer) const
-{
-  size_t box_start = reserve_box_header_space(writer);
+  return range.get_error();
+}
 
-  writer.write32(m_image_width);
-  writer.write32(m_image_height);
 
-  prepend_header(writer, box_start);
+Error Box_iref::check_for_double_references() const
+{
+  for (const auto& ref : m_references) {
+    std::set<heif_item_id> to_ids;
+    for (const auto to_id : ref.to_item_ID) {
+      if (to_ids.find(to_id) == to_ids.end()) {
+        to_ids.insert(to_id);
+      }
+      else {
+        return {heif_error_Invalid_input,
+                heif_suberror_Unspecified,
+                "'iref' has double references"};
+      }
+    }
+  }
 
   return Error::Ok;
 }
 
 
-Error Box_ipma::parse(BitstreamRange& range)
+void Box_iref::derive_box_version()
 {
-  parse_full_box_header(range);
+  uint8_t version = 0;
 
-  int entry_cnt = range.read32();
-  for (int i = 0; i < entry_cnt && !range.error() && !range.eof(); i++) {
-    Entry entry;
-    if (get_version() < 1) {
-      entry.item_ID = range.read16();
-    }
-    else {
-      entry.item_ID = range.read32();
+  for (const auto& ref : m_references) {
+    if (ref.from_item_ID > 0xFFFF) {
+      version = 1;
+      break;
     }
 
-    int assoc_cnt = range.read8();
-    for (int k = 0; k < assoc_cnt; k++) {
-      PropertyAssociation association;
-
-      uint16_t index;
-      if (get_flags() & 1) {
-        index = range.read16();
-        association.essential = !!(index & 0x8000);
-        association.property_index = (index & 0x7fff);
-      }
-      else {
-        index = range.read8();
-        association.essential = !!(index & 0x80);
-        association.property_index = (index & 0x7f);
+    for (uint32_t r : ref.to_item_ID) {
+      if (r > 0xFFFF) {
+        version = 1;
+        break;
       }
-
-      entry.associations.push_back(association);
     }
-
-    m_entries.push_back(entry);
   }
 
-  return range.get_error();
+  set_version(version);
 }
 
 
-const std::vector<Box_ipma::PropertyAssociation>* Box_ipma::get_properties_for_item_ID(uint32_t itemID) const
+Error Box_iref::write(StreamWriter& writer) const
 {
-  for (const auto& entry : m_entries) {
-    if (entry.item_ID == itemID) {
-      return &entry.associations;
-    }
+  if (auto error = check_for_double_references()) {
+    return error;
   }
 
-  return nullptr;
-}
+  size_t box_start = reserve_box_header_space(writer);
 
+  int id_size = ((get_version() == 0) ? 2 : 4);
 
-void Box_ipma::add_property_for_item_ID(heif_item_id itemID,
-                                        PropertyAssociation assoc)
-{
-  size_t idx;
-  for (idx = 0; idx < m_entries.size(); idx++) {
-    if (m_entries[idx].item_ID == itemID) {
-      break;
+  for (const auto& ref : m_references) {
+    uint32_t box_size = uint32_t(4 + 4 + 2 + id_size * (1 + ref.to_item_ID.size()));
+
+    // we write the BoxHeader ourselves since it is very simple
+    writer.write32(box_size);
+    writer.write32(ref.header.get_short_type());
+
+    writer.write(id_size, ref.from_item_ID);
+    writer.write16((uint16_t) ref.to_item_ID.size());
+
+    for (uint32_t r : ref.to_item_ID) {
+      writer.write(id_size, r);
     }
   }
 
-  // if itemID does not exist, add a new entry
-  if (idx == m_entries.size()) {
-    Entry entry;
-    entry.item_ID = itemID;
-    m_entries.push_back(entry);
-  }
+  prepend_header(writer, box_start);
 
-  // add the property association
-  m_entries[idx].associations.push_back(assoc);
+  return Error::Ok;
 }
 
 
-std::string Box_ipma::dump(Indent& indent) const
+std::string Box_iref::dump(Indent& indent) const
 {
   std::ostringstream sstr;
   sstr << Box::dump(indent);
 
-  for (const Entry& entry : m_entries) {
-    sstr << indent << "associations for item ID: " << entry.item_ID << "\n";
-    indent++;
-    for (const auto& assoc : entry.associations) {
-      sstr << indent << "property index: " << assoc.property_index
-           << " (essential: " << std::boolalpha << assoc.essential << ")\n";
+  for (const auto& ref : m_references) {
+    sstr << indent << "reference with type '" << ref.header.get_type_string() << "'"
+         << " from ID: " << ref.from_item_ID
+         << " to IDs: ";
+    for (uint32_t id : ref.to_item_ID) {
+      sstr << id << " ";
     }
-    indent--;
+    sstr << "\n";
   }
 
   return sstr.str();
 }
 
 
-void Box_ipma::derive_box_version()
+bool Box_iref::has_references(uint32_t itemID) const
 {
-  int version = 0;
-  bool large_property_indices = false;
-
-  for (const Entry& entry : m_entries) {
-    if (entry.item_ID > 0xFFFF) {
-      version = 1;
+  for (const Reference& ref : m_references) {
+    if (ref.from_item_ID == itemID) {
+      return true;
     }
+  }
 
-    for (const auto& assoc : entry.associations) {
-      if (assoc.property_index > 0x7F) {
-        large_property_indices = true;
-      }
+  return false;
+}
+
+
+std::vector<Box_iref::Reference> Box_iref::get_references_from(heif_item_id itemID) const
+{
+  std::vector<Reference> references;
+
+  for (const Reference& ref : m_references) {
+    if (ref.from_item_ID == itemID) {
+      references.push_back(ref);
     }
   }
 
-  set_version((uint8_t) version);
-  set_flags(large_property_indices ? 1 : 0);
+  return references;
 }
 
 
-Error Box_ipma::write(StreamWriter& writer) const
+std::vector<uint32_t> Box_iref::get_references(uint32_t itemID, uint32_t ref_type) const
 {
-  size_t box_start = reserve_box_header_space(writer);
+  for (const Reference& ref : m_references) {
+    if (ref.from_item_ID == itemID &&
+        ref.header.get_short_type() == ref_type) {
+      return ref.to_item_ID;
+    }
+  }
 
-  size_t entry_cnt = m_entries.size();
-  writer.write32((uint32_t) entry_cnt);
+  return std::vector<uint32_t>();
+}
 
-  for (const Entry& entry : m_entries) {
 
-    if (get_version() < 1) {
-      writer.write16((uint16_t) entry.item_ID);
-    }
-    else {
-      writer.write32(entry.item_ID);
-    }
+void Box_iref::add_references(heif_item_id from_id, uint32_t type, const std::vector<heif_item_id>& to_ids)
+{
+  Reference ref;
+  ref.header.set_short_type(type);
+  ref.from_item_ID = from_id;
+  ref.to_item_ID = to_ids;
 
-    size_t assoc_cnt = entry.associations.size();
-    if (assoc_cnt > 0xFF) {
-      // TODO: error, too many associations
-    }
+  assert(to_ids.size() <= 0xFFFF);
 
-    writer.write8((uint8_t) assoc_cnt);
+  m_references.push_back(ref);
+}
 
-    for (const PropertyAssociation& association : entry.associations) {
 
-      if (get_flags() & 1) {
-        writer.write16((uint16_t) ((association.essential ? 0x8000 : 0) |
-                                   (association.property_index & 0x7FFF)));
-      }
-      else {
-        writer.write8((uint8_t) ((association.essential ? 0x80 : 0) |
-                                 (association.property_index & 0x7F)));
-      }
+void Box_iref::overwrite_reference(heif_item_id from_id, uint32_t type, uint32_t reference_idx, heif_item_id to_item)
+{
+  for (auto& ref : m_references) {
+    if (ref.from_item_ID == from_id && ref.header.get_short_type() == type) {
+      assert(reference_idx < ref.to_item_ID.size());
+
+      ref.to_item_ID[reference_idx] = to_item;
+      return;
     }
   }
 
-  prepend_header(writer, box_start);
-
-  return Error::Ok;
+  assert(false); // reference was not found
 }
 
 
-Error Box_auxC::parse(BitstreamRange& range)
+Error Box_idat::parse(BitstreamRange& range, const heif_security_limits* limits)
 {
-  parse_full_box_header(range);
-
-  m_aux_type = range.read_string();
+  //parse_full_box_header(range);
 
-  while (!range.eof()) {
-    m_aux_subtypes.push_back(range.read8());
-  }
+  m_data_start_pos = range.get_istream()->get_position();
 
   return range.get_error();
 }
 
 
-Error Box_auxC::write(StreamWriter& writer) const
+Error Box_idat::write(StreamWriter& writer) const
 {
   size_t box_start = reserve_box_header_space(writer);
 
-  writer.write(m_aux_type);
-
-  for (uint8_t subtype : m_aux_subtypes) {
-    writer.write8(subtype);
-  }
+  writer.write(m_data_for_writing);
 
   prepend_header(writer, box_start);
 
@@ -2226,715 +4007,923 @@ Error Box_auxC::write(StreamWriter& writer) const
 }
 
 
-std::string Box_auxC::dump(Indent& indent) const
+std::string Box_idat::dump(Indent& indent) const
 {
   std::ostringstream sstr;
   sstr << Box::dump(indent);
 
-  sstr << indent << "aux type: " << m_aux_type << "\n"
-       << indent << "aux subtypes: ";
-  for (uint8_t subtype : m_aux_subtypes) {
-    sstr << std::hex << std::setw(2) << std::setfill('0') << ((int) subtype) << " ";
+  if (get_box_size() >= get_header_size()) {
+    sstr << indent << "number of data bytes: " << get_box_size() - get_header_size() << "\n";
+  } else {
+     sstr << indent << "number of data bytes is invalid\n";
   }
 
-  sstr << "\n";
-
   return sstr.str();
 }
 
 
-Error Box_irot::parse(BitstreamRange& range)
+Error Box_idat::read_data(const std::shared_ptr<StreamReader>& istr,
+                          uint64_t start, uint64_t length,
+                          std::vector<uint8_t>& out_data,
+                          const heif_security_limits* limits) const
 {
-  //parse_full_box_header(range);
+  // --- security check that we do not allocate too much data
 
-  uint16_t rotation = range.read8();
-  rotation &= 0x03;
+  auto curr_size = out_data.size();
 
-  m_rotation = rotation * 90;
+  auto max_memory_block_size = limits->max_memory_block_size;
+  if (max_memory_block_size && max_memory_block_size - curr_size < length) {
+    std::stringstream sstr;
+    sstr << "idat box contained " << length << " bytes, total memory size would be "
+         << (curr_size + length) << " bytes, exceeding the security limit of "
+         << max_memory_block_size << " bytes";
 
-  return range.get_error();
+    return Error(heif_error_Memory_allocation_error,
+                 heif_suberror_Security_limit_exceeded,
+                 sstr.str());
+  }
+
+
+  // move to start of data
+  if (start > (uint64_t) m_data_start_pos + get_box_size()) {
+    return Error(heif_error_Invalid_input,
+                 heif_suberror_End_of_data);
+  }
+  else if (length > get_box_size() || start + length > get_box_size()) {
+    return Error(heif_error_Invalid_input,
+                 heif_suberror_End_of_data);
+  }
+
+  StreamReader::grow_status status = istr->wait_for_file_size((int64_t) m_data_start_pos + start + length);
+  if (status == StreamReader::grow_status::size_beyond_eof ||
+      status == StreamReader::grow_status::timeout) {
+    // TODO: maybe we should introduce some 'Recoverable error' instead of 'Invalid input'
+    return Error(heif_error_Invalid_input,
+                 heif_suberror_End_of_data);
+  }
+
+  bool success;
+  success = istr->seek(m_data_start_pos + (std::streampos) start);
+  assert(success);
+  (void) success;
+
+  if (length > 0) {
+    // reserve space for the data in the output array
+    out_data.resize(static_cast<size_t>(curr_size + length));
+    uint8_t* data = &out_data[curr_size];
+
+    success = istr->read((char*) data, static_cast<size_t>(length));
+    assert(success);
+    (void) success;
+  }
+
+  return Error::Ok;
 }
 
 
-std::string Box_irot::dump(Indent& indent) const
+Error Box_grpl::parse(BitstreamRange& range, const heif_security_limits* limits)
 {
-  std::ostringstream sstr;
-  sstr << Box::dump(indent);
+  //parse_full_box_header(range);
 
-  sstr << indent << "rotation: " << m_rotation << " degrees (CCW)\n";
+  return read_children(range, READ_CHILDREN_ALL, limits); // should we pass the parsing context 'grpl' or are the box types unique?
+}
 
+
+std::string Box_grpl::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
+  sstr << dump_children(indent);
   return sstr.str();
 }
 
 
-Error Box_imir::parse(BitstreamRange& range)
+Error Box_EntityToGroup::parse(BitstreamRange& range, const heif_security_limits* limits)
 {
-  //parse_full_box_header(range);
+  Error err = parse_full_box_header(range);
+  if (err != Error::Ok) {
+    return err;
+  }
 
-  uint16_t axis = range.read8();
-  if (axis & 1) {
-    m_axis = MirrorDirection::Horizontal;
+  group_id = range.read32();
+  uint32_t nEntities = range.read32();
+
+  if (nEntities > range.get_remaining_bytes() / 4) {
+    std::stringstream sstr;
+    size_t maxEntries = range.get_remaining_bytes() / 4;
+    sstr << "entity group box should contain " << nEntities << " entities, but we can only read " << maxEntries << " entities.";
+
+    return {heif_error_Invalid_input,
+            heif_suberror_End_of_data,
+            sstr.str()};
   }
-  else {
-    m_axis = MirrorDirection::Vertical;
+
+  if (limits->max_size_entity_group && nEntities > limits->max_size_entity_group) {
+    std::stringstream sstr;
+    sstr << "entity group box contains " << nEntities << " entities, but the security limit is set to " << limits->max_size_entity_group << " entities.";
+
+    return {heif_error_Invalid_input,
+            heif_suberror_Security_limit_exceeded,
+            sstr.str()};
   }
 
-  return range.get_error();
+  entity_ids.resize(nEntities);
+  for (uint32_t i = 0; i < nEntities; i++) {
+    entity_ids[i] = range.read32();
+  }
+
+  return Error::Ok;
 }
 
 
-std::string Box_imir::dump(Indent& indent) const
+Error Box_EntityToGroup::write(StreamWriter& writer) const
 {
-  std::ostringstream sstr;
-  sstr << Box::dump(indent);
+  size_t box_start = reserve_box_header_space(writer);
 
-  sstr << indent << "mirror direction: ";
-  switch (m_axis) {
-    case MirrorDirection::Vertical:
-      sstr << "vertical\n";
-      break;
-    case MirrorDirection::Horizontal:
-      sstr << "horizontal\n";
-      break;
-  }
+  write_entity_group_ids(writer);
 
-  return sstr.str();
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
 }
 
 
-Error Box_clap::parse(BitstreamRange& range)
+void Box_EntityToGroup::write_entity_group_ids(StreamWriter& writer) const
 {
-  //parse_full_box_header(range);
+  assert(entity_ids.size() <= 0xFFFFFFFF);
 
-  uint32_t clean_aperture_width_num = range.read32();
-  uint32_t clean_aperture_width_den = range.read32();
-  uint32_t clean_aperture_height_num = range.read32();
-  uint32_t clean_aperture_height_den = range.read32();
-  uint32_t horizontal_offset_num = range.read32();
-  uint32_t horizontal_offset_den = range.read32();
-  uint32_t vertical_offset_num = range.read32();
-  uint32_t vertical_offset_den = range.read32();
-
-  if (clean_aperture_width_num > std::numeric_limits<int32_t>::max() ||
-      clean_aperture_width_den > std::numeric_limits<int32_t>::max() ||
-      clean_aperture_height_num > std::numeric_limits<int32_t>::max() ||
-      clean_aperture_height_den > std::numeric_limits<int32_t>::max() ||
-      horizontal_offset_num > std::numeric_limits<int32_t>::max() ||
-      horizontal_offset_den > std::numeric_limits<int32_t>::max() ||
-      vertical_offset_num > std::numeric_limits<int32_t>::max() ||
-      vertical_offset_den > std::numeric_limits<int32_t>::max()) {
-    return Error(heif_error_Invalid_input,
-                 heif_suberror_Invalid_fractional_number,
-                 "Exceeded supported value range.");
+  writer.write32(group_id);
+  writer.write32(static_cast<uint32_t>(entity_ids.size()));
+
+  for (uint32_t id : entity_ids) {
+    writer.write32(id);
   }
+}
 
-  m_clean_aperture_width = Fraction(clean_aperture_width_num,
-                                    clean_aperture_width_den);
-  m_clean_aperture_height = Fraction(clean_aperture_height_num,
-                                     clean_aperture_height_den);
-  m_horizontal_offset = Fraction(horizontal_offset_num, horizontal_offset_den);
-  m_vertical_offset = Fraction(vertical_offset_num, vertical_offset_den);
-  if (!m_clean_aperture_width.is_valid() || !m_clean_aperture_height.is_valid() ||
-      !m_horizontal_offset.is_valid() || !m_vertical_offset.is_valid()) {
-    return Error(heif_error_Invalid_input,
-                 heif_suberror_Invalid_fractional_number);
+
+std::string Box_EntityToGroup::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
+
+  sstr << indent << "group id: " << group_id << "\n"
+       << indent << "entity IDs: ";
+
+  bool first = true;
+  for (uint32_t id : entity_ids) {
+    if (first) {
+      first = false;
+    }
+    else {
+      sstr << ' ';
+    }
+
+    sstr << id;
   }
 
-  return range.get_error();
+  sstr << "\n";
+
+  return sstr.str();
 }
 
 
-Error Box_clap::write(StreamWriter& writer) const
+Error Box_ster::parse(BitstreamRange& range, const heif_security_limits* limits)
 {
-  size_t box_start = reserve_box_header_space(writer);
-
-  writer.write32(m_clean_aperture_width.numerator);
-  writer.write32(m_clean_aperture_width.denominator);
-  writer.write32(m_clean_aperture_height.numerator);
-  writer.write32(m_clean_aperture_height.denominator);
-  writer.write32(m_horizontal_offset.numerator);
-  writer.write32(m_horizontal_offset.denominator);
-  writer.write32(m_vertical_offset.numerator);
-  writer.write32(m_vertical_offset.denominator);
+  Error err = Box_EntityToGroup::parse(range, limits);
+  if (err) {
+    return err;
+  }
 
-  prepend_header(writer, box_start);
+  if (entity_ids.size() != 2) {
+    return {heif_error_Invalid_input,
+            heif_suberror_Invalid_box_size,
+            "'ster' entity group does not exists of exactly two images"};
+  }
 
   return Error::Ok;
 }
 
 
-std::string Box_clap::dump(Indent& indent) const
+std::string Box_ster::dump(Indent& indent) const
 {
   std::ostringstream sstr;
   sstr << Box::dump(indent);
 
-  sstr << indent << "clean_aperture: " << m_clean_aperture_width.numerator
-       << "/" << m_clean_aperture_width.denominator << " x "
-       << m_clean_aperture_height.numerator << "/"
-       << m_clean_aperture_height.denominator << "\n";
-  sstr << indent << "offset: " << m_horizontal_offset.numerator << "/"
-       << m_horizontal_offset.denominator << " ; "
-       << m_vertical_offset.numerator << "/"
-       << m_vertical_offset.denominator << "\n";
+  sstr << indent << "group id: " << group_id << "\n"
+       << indent << "left image ID: " << entity_ids[0] << "\n"
+       << indent << "right image ID: " << entity_ids[1] << "\n";
 
   return sstr.str();
 }
 
 
-int Box_clap::left_rounded(int image_width) const
+
+Error Box_pymd::parse(BitstreamRange& range, const heif_security_limits* limits)
 {
-  // pcX = horizOff + (width  - 1)/2
-  // pcX ± (cleanApertureWidth - 1)/2
+  Error err = Box_EntityToGroup::parse(range, limits);
+  if (err) {
+    return err;
+  }
 
-  // left = horizOff + (width-1)/2 - (clapWidth-1)/2
+  tile_size_x = range.read16();
+  tile_size_y = range.read16();
 
-  Fraction pcX = m_horizontal_offset + Fraction(image_width - 1, 2);
-  Fraction left = pcX - (m_clean_aperture_width - 1) / 2;
+  for (size_t i = 0; i < entity_ids.size(); i++) {
+    LayerInfo layer{};
+    layer.layer_binning = range.read16();
+    layer.tiles_in_layer_row_minus1 = range.read16();
+    layer.tiles_in_layer_column_minus1 = range.read16();
 
-  return left.round_down();
+    m_layer_infos.push_back(layer);
+  }
+
+  return Error::Ok;
 }
 
-int Box_clap::right_rounded(int image_width) const
+
+Error Box_pymd::write(StreamWriter& writer) const
 {
-  Fraction right = m_clean_aperture_width - 1 + left_rounded(image_width);
+  size_t box_start = reserve_box_header_space(writer);
 
-  return right.round();
-}
+  Box_EntityToGroup::write_entity_group_ids(writer);
 
-int Box_clap::top_rounded(int image_height) const
-{
-  Fraction pcY = m_vertical_offset + Fraction(image_height - 1, 2);
-  Fraction top = pcY - (m_clean_aperture_height - 1) / 2;
+  writer.write16(tile_size_x);
+  writer.write16(tile_size_y);
 
-  return top.round();
-}
+  for (size_t i = 0; i < entity_ids.size(); i++) {
+    const LayerInfo& layer = m_layer_infos[i];
 
-int Box_clap::bottom_rounded(int image_height) const
-{
-  Fraction bottom = m_clean_aperture_height - 1 + top_rounded(image_height);
+    writer.write16(layer.layer_binning);
+    writer.write16(layer.tiles_in_layer_row_minus1);
+    writer.write16(layer.tiles_in_layer_column_minus1);
+  }
 
-  return bottom.round();
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
 }
 
-int Box_clap::get_width_rounded() const
+
+std::string Box_pymd::dump(Indent& indent) const
 {
-  int left = (Fraction(0, 1) - (m_clean_aperture_width - 1) / 2).round();
-  int right = ((m_clean_aperture_width - 1) / 2).round();
+  std::ostringstream sstr;
+  sstr << Box_EntityToGroup::dump(indent);
+
+  sstr << indent << "tile size: " << tile_size_x << "x" << tile_size_y << "\n";
+
+  int layerNr = 0;
+  for (const auto& layer : m_layer_infos) {
+    sstr << indent << "layer " << layerNr << ":\n"
+         << indent << "| binning: " << layer.layer_binning << "\n"
+         << indent << "| tiles: " << (layer.tiles_in_layer_row_minus1 + 1) << "x" << (layer.tiles_in_layer_column_minus1 + 1) << "\n";
 
-  return right + 1 - left;
+    layerNr++;
+  }
+
+  return sstr.str();
 }
 
-int Box_clap::get_height_rounded() const
+
+Error Box_dinf::parse(BitstreamRange& range, const heif_security_limits* limits)
 {
-  int top = (Fraction(0, 1) - (m_clean_aperture_height - 1) / 2).round();
-  int bottom = ((m_clean_aperture_height - 1) / 2).round();
+  //parse_full_box_header(range);
 
-  return bottom + 1 - top;
+  return read_children(range, READ_CHILDREN_ALL, limits);
 }
 
-void Box_clap::set(uint32_t clap_width, uint32_t clap_height,
-                   uint32_t image_width, uint32_t image_height)
-{
-  assert(image_width >= clap_width);
-  assert(image_height >= clap_height);
 
-  m_clean_aperture_width = Fraction(clap_width, 1U);
-  m_clean_aperture_height = Fraction(clap_height, 1U);
+std::string Box_dinf::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
+  sstr << dump_children(indent);
 
-  m_horizontal_offset = Fraction(-(int32_t) (image_width - clap_width), 2);
-  m_vertical_offset = Fraction(-(int32_t) (image_height - clap_height), 2);
+  return sstr.str();
 }
 
 
-Error Box_iref::parse(BitstreamRange& range)
+Error Box_dref::parse(BitstreamRange& range, const heif_security_limits* limits)
 {
   parse_full_box_header(range);
 
-  while (!range.eof()) {
-    Reference ref;
+  if (get_version() != 0) {
+    return unsupported_version_error("dref");
+  }
 
-    Error err = ref.header.parse(range);
-    if (err != Error::Ok) {
-      return err;
-    }
+  uint32_t nEntities = range.read32();
 
-    if (get_version() == 0) {
-      ref.from_item_ID = range.read16();
-      int nRefs = range.read16();
-      for (int i = 0; i < nRefs; i++) {
-        ref.to_item_ID.push_back(range.read16());
-        if (range.eof()) {
-          break;
-        }
-      }
-    }
-    else {
-      ref.from_item_ID = range.read32();
-      int nRefs = range.read16();
-      for (int i = 0; i < nRefs; i++) {
-        ref.to_item_ID.push_back(range.read32());
-        if (range.eof()) {
-          break;
-        }
-      }
+  /*
+  for (int i=0;i<nEntities;i++) {
+    if (range.eof()) {
+      break;
     }
+  }
+  */
 
-    m_references.push_back(ref);
+  if (nEntities > (uint32_t)std::numeric_limits<int>::max()) {
+    return Error(heif_error_Memory_allocation_error,
+                 heif_suberror_Security_limit_exceeded,
+                 "Too many entities in dref box.");
   }
 
-  return range.get_error();
+  Error err = read_children(range, (int)nEntities, limits);
+  if (err) {
+    return err;
+  }
+
+  if (m_children.size() != nEntities) {
+    // TODO return Error(
+  }
+
+  return err;
 }
 
 
-void Box_iref::derive_box_version()
+Error Box_dref::write(StreamWriter& writer) const
 {
-  uint8_t version = 0;
-
-  for (const auto& ref : m_references) {
-    if (ref.from_item_ID > 0xFFFF) {
-      version = 1;
-      break;
-    }
+  size_t box_start = reserve_box_header_space(writer);
 
-    for (uint32_t r : ref.to_item_ID) {
-      if (r > 0xFFFF) {
-        version = 1;
-        break;
-      }
-    }
+  if (m_children.size() > 0xFFFF) {
+    return {
+      heif_error_Usage_error,
+      heif_suberror_Unspecified,
+      "Too many dref children boxes."
+    };
   }
 
-  set_version(version);
+  writer.write32(static_cast<uint32_t>(m_children.size()));
+  write_children(writer);
+
+  prepend_header(writer, box_start);
+  return Error::Ok;
 }
 
 
-Error Box_iref::write(StreamWriter& writer) const
+std::string Box_dref::dump(Indent& indent) const
 {
-  size_t box_start = reserve_box_header_space(writer);
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
+  sstr << dump_children(indent);
 
-  int id_size = ((get_version() == 0) ? 2 : 4);
+  return sstr.str();
+}
 
-  for (const auto& ref : m_references) {
-    uint32_t box_size = uint32_t(4 + 4 + 2 + id_size * (1 + ref.to_item_ID.size()));
 
-    // we write the BoxHeader ourselves since it is very simple
-    writer.write32(box_size);
-    writer.write32(ref.header.get_short_type());
+Error Box_url::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  parse_full_box_header(range);
 
-    writer.write(id_size, ref.from_item_ID);
-    writer.write16((uint16_t) ref.to_item_ID.size());
+  if (get_version() > 0) {
+    return unsupported_version_error("url");
+  }
 
-    for (uint32_t r : ref.to_item_ID) {
-      writer.write(id_size, r);
-    }
+  if (get_flags() & 1) {
+    // data in same file
+    m_location.clear();
+  }
+  else {
+    m_location = range.read_string();
   }
 
+  return range.get_error();
+}
 
-  prepend_header(writer, box_start);
 
+Error Box_url::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  if (m_location.empty()) {
+    assert(get_flags() == 1);
+  }
+  else {
+    assert(get_flags() == 0);
+    writer.write(m_location);
+  }
+
+  prepend_header(writer, box_start);
   return Error::Ok;
 }
 
 
-std::string Box_iref::dump(Indent& indent) const
+std::string Box_url::dump(Indent& indent) const
 {
   std::ostringstream sstr;
   sstr << Box::dump(indent);
+  //sstr << dump_children(indent);
 
-  for (const auto& ref : m_references) {
-    sstr << indent << "reference with type '" << ref.header.get_type_string() << "'"
-         << " from ID: " << ref.from_item_ID
-         << " to IDs: ";
-    for (uint32_t id : ref.to_item_ID) {
-      sstr << id << " ";
-    }
-    sstr << "\n";
-  }
+  sstr << indent << "location: " << m_location << "\n";
 
   return sstr.str();
 }
 
 
-bool Box_iref::has_references(uint32_t itemID) const
+Error Box_udes::parse(BitstreamRange& range, const heif_security_limits* limits)
 {
-  for (const Reference& ref : m_references) {
-    if (ref.from_item_ID == itemID) {
-      return true;
-    }
+  parse_full_box_header(range);
+
+  if (get_version() > 0) {
+    return unsupported_version_error("udes");
   }
 
-  return false;
+  m_lang = range.read_string();
+  m_name = range.read_string();
+  m_description = range.read_string();
+  m_tags = range.read_string();
+  return range.get_error();
+}
+
+std::string Box_udes::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
+  sstr << indent << "lang: " << m_lang << "\n";
+  sstr << indent << "name: " << m_name << "\n";
+  sstr << indent << "description: " << m_description << "\n";
+  sstr << indent << "tags: " << m_lang << "\n";
+  return sstr.str();
+}
+
+Error Box_udes::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+  writer.write(m_lang);
+  writer.write(m_name);
+  writer.write(m_description);
+  writer.write(m_tags);
+  prepend_header(writer, box_start);
+  return Error::Ok;
 }
 
 
-std::vector<Box_iref::Reference> Box_iref::get_references_from(heif_item_id itemID) const
+void Box_cmin::RelativeIntrinsicMatrix::compute_focal_length(int image_width, int image_height,
+                                                             double& out_focal_length_x, double& out_focal_length_y) const
 {
-  std::vector<Reference> references;
+  out_focal_length_x = focal_length_x * image_width;
 
-  for (const Reference& ref : m_references) {
-    if (ref.from_item_ID == itemID) {
-      references.push_back(ref);
-    }
+  if (is_anisotropic) {
+    out_focal_length_y = focal_length_y * image_height;
+  }
+  else {
+    out_focal_length_y = out_focal_length_x;
   }
+}
 
-  return references;
+
+void Box_cmin::RelativeIntrinsicMatrix::compute_principal_point(int image_width, int image_height,
+                                                                double& out_principal_point_x, double& out_principal_point_y) const
+{
+  out_principal_point_x = principal_point_x * image_width;
+  out_principal_point_y = principal_point_y * image_height;
 }
 
 
-std::vector<uint32_t> Box_iref::get_references(uint32_t itemID, uint32_t ref_type) const
+Box_cmin::AbsoluteIntrinsicMatrix Box_cmin::RelativeIntrinsicMatrix::to_absolute(int image_width, int image_height) const
 {
-  for (const Reference& ref : m_references) {
-    if (ref.from_item_ID == itemID &&
-        ref.header.get_short_type() == ref_type) {
-      return ref.to_item_ID;
-    }
-  }
+  AbsoluteIntrinsicMatrix m{};
+  compute_focal_length(image_width, image_height, m.focal_length_x, m.focal_length_y);
+  compute_principal_point(image_width, image_height, m.principal_point_x, m.principal_point_y);
+  m.skew = skew;
 
-  return std::vector<uint32_t>();
+  return m;
 }
 
 
-void Box_iref::add_reference(heif_item_id from_id, uint32_t type, std::vector<heif_item_id> to_ids)
+std::string Box_cmin::dump(Indent& indent) const
 {
-  Reference ref;
-  ref.header.set_short_type(type);
-  ref.from_item_ID = from_id;
-  ref.to_item_ID = to_ids;
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
+  sstr << indent << "principal-point: " << m_matrix.principal_point_x << ", " << m_matrix.principal_point_y << "\n";
+  if (m_matrix.is_anisotropic) {
+    sstr << indent << "focal-length: " << m_matrix.focal_length_x << ", " << m_matrix.focal_length_y << "\n";
+    sstr << indent << "skew: " << m_matrix.skew << "\n";
+  }
+  else {
+    sstr << indent << "focal-length: " << m_matrix.focal_length_x << "\n";
+    sstr << indent << "no skew\n";
+  }
 
-  m_references.push_back(ref);
+  return sstr.str();
 }
 
 
-Error Box_hvcC::parse(BitstreamRange& range)
+Error Box_cmin::parse(BitstreamRange& range, const heif_security_limits* limits)
 {
-  //parse_full_box_header(range);
+  parse_full_box_header(range);
+
+  if (get_version() > 0) {
+    return unsupported_version_error("cmin");
+  }
+
+  m_denominatorShift = (get_flags() & 0x1F00) >> 8;
+  uint32_t denominator = (1U << m_denominatorShift);
+
+  m_matrix.focal_length_x = range.read32s() / (double)denominator;
+  m_matrix.principal_point_x = range.read32s() / (double)denominator;
+  m_matrix.principal_point_y = range.read32s() / (double)denominator;
 
-  uint8_t byte;
+  if (get_flags() & 1) {
+    m_skewDenominatorShift = ((get_flags()) & 0x1F0000) >> 16;
+    uint32_t skewDenominator = (1U << m_skewDenominatorShift);
 
-  auto& c = m_configuration; // abbreviation
+    m_matrix.focal_length_y = range.read32s() / (double)denominator;
+    m_matrix.skew = range.read32s() / (double)skewDenominator;
 
-  c.configuration_version = range.read8();
-  byte = range.read8();
-  c.general_profile_space = (byte >> 6) & 3;
-  c.general_tier_flag = (byte >> 5) & 1;
-  c.general_profile_idc = (byte & 0x1F);
+    m_matrix.is_anisotropic = true;
+  }
+  else {
+    m_matrix.is_anisotropic = false;
+    m_matrix.focal_length_y = 0;
+    m_matrix.skew = 0;
+  }
+  return range.get_error();
+}
+
+
+static uint32_t get_signed_fixed_point_shift(double v)
+{
+  if (v==0) {
+    return 31;
+  }
 
-  c.general_profile_compatibility_flags = range.read32();
+  v = std::abs(v);
 
-  for (int i = 0; i < 6; i++) {
-    byte = range.read8();
+  uint32_t shift = 0;
+  while (v < (1<<30)) {
+    v *= 2;
+    shift++;
 
-    for (int b = 0; b < 8; b++) {
-      c.general_constraint_indicator_flags[i * 8 + b] = (byte >> (7 - b)) & 1;
+    if (shift==31) {
+      return shift;
     }
   }
 
-  c.general_level_idc = range.read8();
-  c.min_spatial_segmentation_idc = range.read16() & 0x0FFF;
-  c.parallelism_type = range.read8() & 0x03;
-  c.chroma_format = range.read8() & 0x03;
-  c.bit_depth_luma = static_cast<uint8_t>((range.read8() & 0x07) + 8);
-  c.bit_depth_chroma = static_cast<uint8_t>((range.read8() & 0x07) + 8);
-  c.avg_frame_rate = range.read16();
+  return shift;
+}
+
+
+void Box_cmin::set_intrinsic_matrix(RelativeIntrinsicMatrix matrix)
+{
+  m_matrix = matrix;
+
+  uint32_t flags = 0;
+  flags |= matrix.is_anisotropic ? 1 : 0;
 
-  byte = range.read8();
-  c.constant_frame_rate = (byte >> 6) & 0x03;
-  c.num_temporal_layers = (byte >> 3) & 0x07;
-  c.temporal_id_nested = (byte >> 2) & 1;
+  uint32_t shift_fx = get_signed_fixed_point_shift(matrix.focal_length_x);
+  uint32_t shift_px = get_signed_fixed_point_shift(matrix.principal_point_x);
+  uint32_t shift_py = get_signed_fixed_point_shift(matrix.principal_point_y);
+  m_denominatorShift = std::min(std::min(shift_fx, shift_px), shift_py);
 
-  m_length_size = static_cast<uint8_t>((byte & 0x03) + 1);
+  if (matrix.is_anisotropic) {
+    uint32_t shift_fy = get_signed_fixed_point_shift(matrix.focal_length_y);
+    m_denominatorShift = std::min(m_denominatorShift, shift_fy);
 
-  int nArrays = range.read8();
+    m_skewDenominatorShift = get_signed_fixed_point_shift(matrix.skew);
+  }
+  else {
+    m_skewDenominatorShift = 0;
+  }
 
-  for (int i = 0; i < nArrays && !range.error(); i++) {
-    byte = range.read8();
+  flags |= (m_denominatorShift << 8);
+  flags |= (m_skewDenominatorShift << 16);
 
-    NalArray array;
+  set_flags(flags);
+}
 
-    array.m_array_completeness = (byte >> 6) & 1;
-    array.m_NAL_unit_type = (byte & 0x3F);
 
-    int nUnits = range.read16();
-    for (int u = 0; u < nUnits && !range.error(); u++) {
+Error Box_cmin::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
 
-      std::vector<uint8_t> nal_unit;
-      int size = range.read16();
-      if (!size) {
-        // Ignore empty NAL units.
-        continue;
-      }
+  uint32_t denominator = (1U << m_denominatorShift);
 
-      if (range.prepare_read(size)) {
-        nal_unit.resize(size);
-        range.get_istream()->read((char*) nal_unit.data(), size);
-      }
+  writer.write32s(static_cast<int32_t>(m_matrix.focal_length_x * denominator));
+  writer.write32s(static_cast<int32_t>(m_matrix.principal_point_x * denominator));
+  writer.write32s(static_cast<int32_t>(m_matrix.principal_point_y * denominator));
 
-      array.m_nal_units.push_back(std::move(nal_unit));
-    }
+  if (get_flags() & 1) {
+    writer.write32s(static_cast<int32_t>(m_matrix.focal_length_y * denominator));
 
-    m_nal_array.push_back(std::move(array));
+    uint32_t skewDenominator = (1U << m_skewDenominatorShift);
+    writer.write32s(static_cast<int32_t>(m_matrix.skew * skewDenominator));
   }
 
-  range.skip_to_end_of_box();
+  prepend_header(writer, box_start);
 
-  return range.get_error();
+  return Error::Ok;
 }
 
 
-std::string Box_hvcC::dump(Indent& indent) const
+static std::array<double,9> mul(const std::array<double,9>& a, const std::array<double,9>& b)
 {
-  std::ostringstream sstr;
-  sstr << Box::dump(indent);
+  std::array<double, 9> m{};
 
-  const auto& c = m_configuration; // abbreviation
+  m[0] = a[0]*b[0] + a[1]*b[3] + a[2]*b[6];
+  m[1] = a[0]*b[1] + a[1]*b[4] + a[2]*b[7];
+  m[2] = a[0]*b[2] + a[1]*b[5] + a[2]*b[8];
 
-  sstr << indent << "configuration_version: " << ((int) c.configuration_version) << "\n"
-       << indent << "general_profile_space: " << ((int) c.general_profile_space) << "\n"
-       << indent << "general_tier_flag: " << c.general_tier_flag << "\n"
-       << indent << "general_profile_idc: " << ((int) c.general_profile_idc) << "\n";
+  m[3] = a[3]*b[0] + a[4]*b[3] + a[5]*b[6];
+  m[4] = a[3]*b[1] + a[4]*b[4] + a[5]*b[7];
+  m[5] = a[3]*b[2] + a[4]*b[5] + a[5]*b[8];
 
-  sstr << indent << "general_profile_compatibility_flags: ";
-  for (int i = 0; i < 32; i++) {
-    sstr << ((c.general_profile_compatibility_flags >> (31 - i)) & 1);
-    if ((i % 8) == 7) sstr << ' ';
-    else if ((i % 4) == 3) sstr << '.';
-  }
-  sstr << "\n";
+  m[6] = a[6]*b[0] + a[7]*b[3] + a[8]*b[6];
+  m[7] = a[6]*b[1] + a[7]*b[4] + a[8]*b[7];
+  m[8] = a[6]*b[2] + a[7]*b[5] + a[8]*b[8];
 
-  sstr << indent << "general_constraint_indicator_flags: ";
-  int cnt = 0;
-  for (int i = 0; i < configuration::NUM_CONSTRAINT_INDICATOR_FLAGS; i++) {
-    bool b = c.general_constraint_indicator_flags[i];
+  return m;
+}
 
-    sstr << (b ? 1 : 0);
-    cnt++;
-    if ((cnt % 8) == 0)
-      sstr << ' ';
-  }
-  sstr << "\n";
 
-  sstr << indent << "general_level_idc: " << ((int) c.general_level_idc) << "\n"
-       << indent << "min_spatial_segmentation_idc: " << c.min_spatial_segmentation_idc << "\n"
-       << indent << "parallelism_type: " << ((int) c.parallelism_type) << "\n"
-       << indent << "chroma_format: " << ((int) c.chroma_format) << "\n"
-       << indent << "bit_depth_luma: " << ((int) c.bit_depth_luma) << "\n"
-       << indent << "bit_depth_chroma: " << ((int) c.bit_depth_chroma) << "\n"
-       << indent << "avg_frame_rate: " << c.avg_frame_rate << "\n"
-       << indent << "constant_frame_rate: " << ((int) c.constant_frame_rate) << "\n"
-       << indent << "num_temporal_layers: " << ((int) c.num_temporal_layers) << "\n"
-       << indent << "temporal_id_nested: " << ((int) c.temporal_id_nested) << "\n"
-       << indent << "length_size: " << ((int) m_length_size) << "\n";
-
-  for (const auto& array : m_nal_array) {
-    sstr << indent << "<array>\n";
+std::array<double,9> Box_cmex::ExtrinsicMatrix::calculate_rotation_matrix() const
+{
+  std::array<double,9> m{};
 
-    indent++;
-    sstr << indent << "array_completeness: " << ((int) array.m_array_completeness) << "\n"
-         << indent << "NAL_unit_type: " << ((int) array.m_NAL_unit_type) << "\n";
-
-    for (const auto& unit : array.m_nal_units) {
-      //sstr << "  unit with " << unit.size() << " bytes of data\n";
-      sstr << indent;
-      for (uint8_t b : unit) {
-        sstr << std::setfill('0') << std::setw(2) << std::hex << ((int) b) << " ";
-      }
-      sstr << "\n";
-      sstr << std::dec;
-    }
+  if (rotation_as_quaternions) {
+    double qx = quaternion_x;
+    double qy = quaternion_y;
+    double qz = quaternion_z;
+    double qw = quaternion_w;
 
-    indent--;
+    m[0] = 1-2*(qy*qy+qz*qz);
+    m[1] = 2*(qx*qy-qz*qw);
+    m[2] = 2*(qx*qz+qy*qw);
+    m[3] = 2*(qx*qy+qz*qw);
+    m[4] = 1-2*(qx*qx+qz*qz);
+    m[5] = 2*(qy*qz-qx*qw);
+    m[6] = 2*(qx*qz-qy*qw);
+    m[7] = 2*(qy*qz+qx*qw);
+    m[8] = 1-2*(qx*qx+qy*qy);
   }
+  else {
+    // This rotation order fits the conformance data
+    // https://github.com/MPEGGroup/FileFormatConformance
+    // branch m62054_extrinsics : FileFormatConformance/data/file_features/under_consideration/ex_in_trinsics/extrinsic_rotation
 
-  return sstr.str();
-}
+    std::array<double,9> m_yaw{};    // Z
+    std::array<double,9> m_pitch{};  // Y
+    std::array<double,9> m_roll{};   // X
 
+    const double d2r = M_PI/180;
 
-bool Box_hvcC::get_headers(std::vector<uint8_t>* dest) const
-{
-  for (const auto& array : m_nal_array) {
-    for (const auto& unit : array.m_nal_units) {
+    double x = d2r * rotation_roll;
+    double y = d2r * rotation_pitch;
+    double z = d2r * rotation_yaw;
 
-      dest->push_back((unit.size() >> 24) & 0xFF);
-      dest->push_back((unit.size() >> 16) & 0xFF);
-      dest->push_back((unit.size() >> 8) & 0xFF);
-      dest->push_back((unit.size() >> 0) & 0xFF);
+    // X
+    m_roll[0] = 1;
+    m_roll[4] = m_roll[8] = cos(x);
+    m_roll[5] = -sin(x);
+    m_roll[7] = sin(x);
 
-      /*
-      dest->push_back(0);
-      dest->push_back(0);
-      dest->push_back(1);
-      */
+    // Y
+    m_pitch[4] = 1;
+    m_pitch[0] = m_pitch[8] = cos(y);
+    m_pitch[6] = -sin(y);
+    m_pitch[2] = sin(y);
 
-      dest->insert(dest->end(), unit.begin(), unit.end());
-    }
+    // Z
+    m_yaw[8] = 1;
+    m_yaw[0] = m_yaw[4] = cos(z);
+    m_yaw[1] = -sin(z);
+    m_yaw[3] = sin(z);
+
+    m = mul(m_yaw, mul(m_pitch, m_roll));
   }
 
-  return true;
+  return m;
 }
 
 
-void Box_hvcC::append_nal_data(const std::vector<uint8_t>& nal)
+Error Box_cmex::parse(BitstreamRange& range, const heif_security_limits* limits)
 {
-  NalArray array;
-  array.m_array_completeness = 0;
-  array.m_NAL_unit_type = uint8_t(nal[0] >> 1);
-  array.m_nal_units.push_back(nal);
-
-  m_nal_array.push_back(array);
-}
+  parse_full_box_header(range);
 
-void Box_hvcC::append_nal_data(const uint8_t* data, size_t size)
-{
-  std::vector<uint8_t> nal;
-  nal.resize(size);
-  memcpy(nal.data(), data, size);
+  if (get_version() > 0) {
+    return unsupported_version_error("cmex");
+  }
 
-  NalArray array;
-  array.m_array_completeness = 0;
-  array.m_NAL_unit_type = uint8_t(nal[0] >> 1);
-  array.m_nal_units.push_back(std::move(nal));
+  m_matrix = ExtrinsicMatrix{};
 
-  m_nal_array.push_back(array);
-}
+  if (get_flags() & pos_x_present) {
+    m_has_pos_x = true;
+    m_matrix.pos_x = range.read32s();
+  }
 
+  if (get_flags() & pos_y_present) {
+    m_has_pos_y = true;
+    m_matrix.pos_y = range.read32s();
+  }
 
-Error Box_hvcC::write(StreamWriter& writer) const
-{
-  size_t box_start = reserve_box_header_space(writer);
+  if (get_flags() & pos_z_present) {
+    m_has_pos_z = true;
+    m_matrix.pos_z = range.read32s();
+  }
 
-  const auto& c = m_configuration; // abbreviation
+  if (get_flags() & orientation_present) {
+    m_has_orientation = true;
 
-  writer.write8(c.configuration_version);
+    if (get_version() == 0) {
+      bool use32bit = (get_flags() & rot_large_field_size);
+      int32_t quat_x = use32bit ? range.read32s() : range.read16s();
+      int32_t quat_y = use32bit ? range.read32s() : range.read16s();
+      int32_t quat_z = use32bit ? range.read32s() : range.read16s();
 
-  writer.write8((uint8_t) (((c.general_profile_space & 3) << 6) |
-                           ((c.general_tier_flag & 1) << 5) |
-                           (c.general_profile_idc & 0x1F)));
+      uint32_t div = 1U << (14 + (use32bit ? 16 : 0));
 
-  writer.write32(c.general_profile_compatibility_flags);
+      m_matrix.rotation_as_quaternions = true;
+      m_matrix.quaternion_x = quat_x / (double)div;
+      m_matrix.quaternion_y = quat_y / (double)div;
+      m_matrix.quaternion_z = quat_z / (double)div;
 
-  for (int i = 0; i < 6; i++) {
-    uint8_t byte = 0;
+      double q_sum = (m_matrix.quaternion_x * m_matrix.quaternion_x +
+                      m_matrix.quaternion_y * m_matrix.quaternion_y +
+                      m_matrix.quaternion_z * m_matrix.quaternion_z);
 
-    for (int b = 0; b < 8; b++) {
-      if (c.general_constraint_indicator_flags[i * 8 + b]) {
-        byte |= 1;
+      if (q_sum > 1.0) {
+        return Error(heif_error_Invalid_input,
+                     heif_suberror_Unspecified,
+                     "Invalid quaternion in extrinsic rotation matrix");
       }
 
-      byte = (uint8_t) (byte << 1);
+      m_matrix.quaternion_w = sqrt(1 - q_sum);
+
+    } else if (get_version() == 1) {
+      uint32_t div = 1<<16;
+      m_matrix.rotation_yaw = range.read32s() / (double)div;
+      m_matrix.rotation_pitch = range.read32s() / (double)div;
+      m_matrix.rotation_roll = range.read32s() / (double)div;
     }
+  }
 
-    writer.write8(byte);
+  if (get_flags() & id_present) {
+    m_has_world_coordinate_system_id = true;
+    m_matrix.world_coordinate_system_id = range.read32();
   }
 
-  writer.write8(c.general_level_idc);
-  writer.write16((c.min_spatial_segmentation_idc & 0x0FFF) | 0xF000);
-  writer.write8(c.parallelism_type | 0xFC);
-  writer.write8(c.chroma_format | 0xFC);
-  writer.write8((uint8_t) ((c.bit_depth_luma - 8) | 0xF8));
-  writer.write8((uint8_t) ((c.bit_depth_chroma - 8) | 0xF8));
-  writer.write16(c.avg_frame_rate);
+  return range.get_error();
+}
 
-  writer.write8((uint8_t) (((c.constant_frame_rate & 0x03) << 6) |
-                           ((c.num_temporal_layers & 0x07) << 3) |
-                           ((c.temporal_id_nested & 1) << 2) |
-                           ((m_length_size - 1) & 0x03)));
 
-  size_t nArrays = m_nal_array.size();
-  if (nArrays > 0xFF) {
-    // TODO: error: too many NAL units
+std::string Box_cmex::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
+  sstr << indent << "camera position (um): ";
+  sstr << m_matrix.pos_x << " ; ";
+  sstr << m_matrix.pos_y << " ; ";
+  sstr << m_matrix.pos_z << "\n";
+
+  sstr << indent << "orientation ";
+  if (m_matrix.rotation_as_quaternions) {
+    sstr << "(quaterion)\n";
+    sstr << indent << "  q = ["
+         << m_matrix.quaternion_x << ";"
+         << m_matrix.quaternion_y << ";"
+         << m_matrix.quaternion_z << ";"
+         << m_matrix.quaternion_w << "]\n";
+  }
+  else {
+    sstr << "(angles)\n";
+    sstr << indent << "  yaw:   " << m_matrix.rotation_yaw << "\n";
+    sstr << indent << "  pitch: " << m_matrix.rotation_pitch << "\n";
+    sstr << indent << "  roll:  " << m_matrix.rotation_roll << "\n";
   }
 
-  writer.write8((uint8_t) nArrays);
+  sstr << indent << "world coordinate system id: " << m_matrix.world_coordinate_system_id << "\n";
+
+  return sstr.str();
+}
 
-  for (const NalArray& array : m_nal_array) {
 
-    writer.write8((uint8_t) (((array.m_array_completeness & 1) << 6) |
-                             (array.m_NAL_unit_type & 0x3F)));
 
-    size_t nUnits = array.m_nal_units.size();
-    if (nUnits > 0xFFFF) {
-      // TODO: error: too many NAL units
-    }
 
-    writer.write16((uint16_t) nUnits);
+Error Box_cmex::set_extrinsic_matrix(ExtrinsicMatrix matrix)
+{
+  m_matrix = matrix;
 
-    for (const std::vector<uint8_t>& nal_unit : array.m_nal_units) {
-      writer.write16((uint16_t) nal_unit.size());
-      writer.write(nal_unit);
-    }
-  }
+  uint32_t flags = 0;
 
-  prepend_header(writer, box_start);
+  m_has_pos_x = (matrix.pos_x != 0);
+  m_has_pos_y = (matrix.pos_y != 0);
+  m_has_pos_z = (matrix.pos_z != 0);
 
-  return Error::Ok;
-}
+  if (m_has_pos_x) {
+    flags |= pos_x_present;
+  }
 
+  if (m_has_pos_y) {
+    flags |= pos_y_present;
+  }
 
-Error Box_av1C::parse(BitstreamRange& range)
-{
-  //parse_full_box_header(range);
+  if (m_has_pos_z) {
+    flags |= pos_z_present;
+  }
 
-  uint8_t byte;
+  if (matrix.rotation_as_quaternions) {
+    if (matrix.quaternion_x != 0 ||
+        matrix.quaternion_y != 0 ||
+        matrix.quaternion_z != 0) {
+      flags |= orientation_present;
 
-  auto& c = m_configuration; // abbreviation
+      double q_sum = (m_matrix.quaternion_x * m_matrix.quaternion_x +
+                      m_matrix.quaternion_y * m_matrix.quaternion_y +
+                      m_matrix.quaternion_z * m_matrix.quaternion_z);
 
-  byte = range.read8();
-  if ((byte & 0x80) == 0) {
-    // error: marker bit not set
-  }
+      if (q_sum > 1.0) {
+        return Error(heif_error_Invalid_input,
+                     heif_suberror_Unspecified,
+                     "Invalid quaternion in extrinsic rotation matrix");
+      }
 
-  c.version = byte & 0x7F;
+      if (matrix.quaternion_w < 0) {
+        matrix.quaternion_x = -matrix.quaternion_x;
+        matrix.quaternion_y = -matrix.quaternion_y;
+        matrix.quaternion_z = -matrix.quaternion_z;
+        matrix.quaternion_w = -matrix.quaternion_w;
+      }
+    }
+  }
+  else {
+    if (matrix.rotation_yaw != 0 ||
+        matrix.rotation_pitch != 0 ||
+        matrix.rotation_roll != 0) {
+      flags |= orientation_present;
 
-  byte = range.read8();
-  c.seq_profile = (byte >> 5) & 0x7;
-  c.seq_level_idx_0 = byte & 0x1f;
+      if (matrix.rotation_yaw < -180.0 || matrix.rotation_yaw >= 180.0) {
+        return Error(heif_error_Invalid_input,
+                     heif_suberror_Unspecified,
+                     "Invalid yaw angle");
+      }
 
-  byte = range.read8();
-  c.seq_tier_0 = (byte >> 7) & 1;
-  c.high_bitdepth = (byte >> 6) & 1;
-  c.twelve_bit = (byte >> 5) & 1;
-  c.monochrome = (byte >> 4) & 1;
-  c.chroma_subsampling_x = (byte >> 3) & 1;
-  c.chroma_subsampling_y = (byte >> 2) & 1;
-  c.chroma_sample_position = byte & 3;
+      if (matrix.rotation_pitch < -90.0 || matrix.rotation_pitch > 90.0) {
+        return Error(heif_error_Invalid_input,
+                     heif_suberror_Unspecified,
+                     "Invalid pitch angle");
+      }
 
-  byte = range.read8();
-  c.initial_presentation_delay_present = (byte >> 4) & 1;
-  if (c.initial_presentation_delay_present) {
-    c.initial_presentation_delay_minus_one = byte & 0x0F;
+      if (matrix.rotation_roll < -180.0 || matrix.rotation_roll >= 180.0) {
+        return Error(heif_error_Invalid_input,
+                     heif_suberror_Unspecified,
+                     "Invalid roll angle");
+      }
+    }
   }
 
-  const int64_t configOBUs_bytes = range.get_remaining_bytes();
-  m_config_OBUs.resize(configOBUs_bytes);
+  if (matrix.orientation_is_32bit) {
+    flags |= rot_large_field_size;
+  }
 
-  if (!range.read(m_config_OBUs.data(), configOBUs_bytes)) {
-    // error
+  if (matrix.world_coordinate_system_id != 0) {
+    flags |= id_present;
   }
 
-  return range.get_error();
+  set_flags(flags);
+  set_version(m_matrix.rotation_as_quaternions ? 0 : 1);
+
+  return Error::Ok;
 }
 
 
-Error Box_av1C::write(StreamWriter& writer) const
+Error Box_cmex::write(StreamWriter& writer) const
 {
   size_t box_start = reserve_box_header_space(writer);
 
-  const auto& c = m_configuration; // abbreviation
+  if (m_has_pos_x) {
+    writer.write32s(m_matrix.pos_x);
+  }
+
+  if (m_has_pos_y) {
+    writer.write32s(m_matrix.pos_y);
+  }
 
-  writer.write8(c.version | 0x80);
+  if (m_has_pos_z) {
+    writer.write32s(m_matrix.pos_z);
+  }
 
-  writer.write8((uint8_t) (((c.seq_profile & 0x7) << 5) |
-                           (c.seq_level_idx_0 & 0x1f)));
+  if (m_has_orientation) {
+    if (m_matrix.rotation_as_quaternions) {
+      if (m_matrix.orientation_is_32bit) {
+        writer.write32s(static_cast<int32_t>(m_matrix.quaternion_x * (1<<30)));
+        writer.write32s(static_cast<int32_t>(m_matrix.quaternion_y * (1<<30)));
+        writer.write32s(static_cast<int32_t>(m_matrix.quaternion_z * (1<<30)));
+      }
+      else {
+        writer.write16s(static_cast<int16_t>(m_matrix.quaternion_x * (1<<14)));
+        writer.write16s(static_cast<int16_t>(m_matrix.quaternion_y * (1<<14)));
+        writer.write16s(static_cast<int16_t>(m_matrix.quaternion_z * (1<<14)));
+      }
+    }
+    else {
+      writer.write32s(static_cast<int32_t>(m_matrix.rotation_yaw * (1<<16)));
+      writer.write32s(static_cast<int32_t>(m_matrix.rotation_pitch * (1<<16)));
+      writer.write32s(static_cast<int32_t>(m_matrix.rotation_roll * (1<<16)));
+    }
+  }
 
-  writer.write8((uint8_t) ((c.seq_tier_0 ? 0x80 : 0) |
-                           (c.high_bitdepth ? 0x40 : 0) |
-                           (c.twelve_bit ? 0x20 : 0) |
-                           (c.monochrome ? 0x10 : 0) |
-                           (c.chroma_subsampling_x ? 0x08 : 0) |
-                           (c.chroma_subsampling_y ? 0x04 : 0) |
-                           (c.chroma_sample_position & 0x03)));
+  if (m_has_world_coordinate_system_id) {
+    writer.write32(m_matrix.world_coordinate_system_id);
+  }
 
-  writer.write8(0); // TODO initial_presentation_delay
 
   prepend_header(writer, box_start);
 
@@ -2942,258 +4931,254 @@ Error Box_av1C::write(StreamWriter& writer) const
 }
 
 
-std::string Box_av1C::dump(Indent& indent) const
+std::string Box_taic::dump(const heif_tai_clock_info& info, Indent& indent)
 {
   std::ostringstream sstr;
-  sstr << Box::dump(indent);
-
-  const auto& c = m_configuration; // abbreviation
-
-  sstr << indent << "version: " << ((int) c.version) << "\n"
-       << indent << "seq_profile: " << ((int) c.seq_profile) << "\n"
-       << indent << "seq_level_idx_0: " << ((int) c.seq_level_idx_0) << "\n"
-       << indent << "high_bitdepth: " << ((int) c.high_bitdepth) << "\n"
-       << indent << "twelve_bit: " << ((int) c.twelve_bit) << "\n"
-       << indent << "chroma_subsampling_x: " << ((int) c.chroma_subsampling_x) << "\n"
-       << indent << "chroma_subsampling_y: " << ((int) c.chroma_subsampling_y) << "\n"
-       << indent << "chroma_sample_position: " << ((int) c.chroma_sample_position) << "\n"
-       << indent << "initial_presentation_delay: ";
-
-  if (c.initial_presentation_delay_present) {
-    sstr << c.initial_presentation_delay_minus_one + 1 << "\n";
+  sstr << indent << "time_uncertainty: ";
+  if (info.time_uncertainty == heif_tai_clock_info_time_uncertainty_unknown) {
+    sstr << "unknown\n";
+  }
+  else {
+    sstr << info.time_uncertainty << "\n";
+  }
+  sstr << indent << "clock_resolution: " << info.clock_resolution << "\n";
+  sstr << indent << "clock_drift_rate: ";
+  if (info.clock_drift_rate == heif_tai_clock_info_clock_drift_rate_unknown) {
+    sstr << "undefined\n";
   }
   else {
-    sstr << "not present\n";
+    sstr << info.clock_drift_rate << "\n";
   }
 
-  sstr << indent << "config OBUs:";
-  for (size_t i = 0; i < m_config_OBUs.size(); i++) {
-    sstr << " " << std::hex << std::setfill('0') << std::setw(2)
-         << ((int) m_config_OBUs[i]);
+  sstr << indent << "clock_type: " << int(info.clock_type) << " ";
+  switch (info.clock_type) {
+    case heif_tai_clock_info_clock_type_unknown: sstr << "(unknown)\n"; break;
+    case heif_tai_clock_info_clock_type_synchronized_to_atomic_source: sstr << "(synchronized to atomic source)\n"; break;
+    case heif_tai_clock_info_clock_type_not_synchronized_to_atomic_source: sstr << "(not synchronized to atomic source)\n"; break;
+    default: sstr << "(illegal value)\n"; break;;
   }
-  sstr << std::dec << "\n";
+  return sstr.str();
+}
+
+
+std::string Box_taic::dump(Indent& indent) const {
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
+  sstr << dump(m_info, indent);
 
   return sstr.str();
 }
 
+Error Box_taic::write(StreamWriter& writer) const {
+  size_t box_start = reserve_box_header_space(writer);
+  writer.write64(m_info.time_uncertainty);
+  writer.write32(m_info.clock_resolution);
+  writer.write32(m_info.clock_drift_rate);
+  writer.write8(m_info.clock_type);
 
-Error Box_idat::parse(BitstreamRange& range)
-{
-  //parse_full_box_header(range);
+  prepend_header(writer, box_start);
 
-  m_data_start_pos = range.get_istream()->get_position();
+  return Error::Ok;
+}
+
+Error Box_taic::parse(BitstreamRange& range, const heif_security_limits*) {
+  parse_full_box_header(range);
+
+  m_info.time_uncertainty = range.read64();
+  m_info.clock_resolution = range.read32();
 
+  m_info.clock_drift_rate = range.read32s();
+  m_info.clock_type = range.read8();
   return range.get_error();
 }
 
 
-Error Box_idat::write(StreamWriter& writer) const
+bool operator==(const heif_tai_clock_info& a,
+                const heif_tai_clock_info& b)
 {
-  size_t box_start = reserve_box_header_space(writer);
-
-  writer.write(m_data_for_writing);
+  return a.version == b.version &&
+         a.time_uncertainty == b.time_uncertainty &&
+         a.clock_resolution == b.clock_resolution &&
+         a.clock_drift_rate == b.clock_drift_rate &&
+         a.clock_type == b.clock_type;
+}
 
-  prepend_header(writer, box_start);
+bool Box_taic::operator==(const Box& other) const
+{
+  const auto* other_taic = dynamic_cast<const Box_taic*>(&other);
+  if (other_taic == nullptr) {
+    return false;
+  }
 
-  return Error::Ok;
+  return m_info == other_taic->m_info;
 }
 
 
-std::string Box_idat::dump(Indent& indent) const
-{
+std::string Box_itai::dump(Indent& indent) const {
   std::ostringstream sstr;
   sstr << Box::dump(indent);
-
-  sstr << indent << "number of data bytes: " << get_box_size() - get_header_size() << "\n";
-
+  sstr << indent << "tai_timestamp: " << m_timestamp.tai_timestamp << "\n";
+  sstr << indent << "synchronization_state: " << int(m_timestamp.synchronization_state) << "\n";
+  sstr << indent << "timestamp_generation_failure: " << int(m_timestamp.timestamp_generation_failure) << "\n";
+  sstr << indent << "timestamp_is_modified: " << int(m_timestamp.timestamp_is_modified) << "\n";
   return sstr.str();
 }
 
 
-Error Box_idat::read_data(std::shared_ptr<StreamReader> istr,
-                          uint64_t start, uint64_t length,
-                          std::vector<uint8_t>& out_data) const
+std::vector<uint8_t> Box_itai::encode_tai_to_bitstream(const heif_tai_timestamp_packet* tai)
 {
-  // --- security check that we do not allocate too much data
+  StreamWriter writer;
+  writer.write64(tai->tai_timestamp);
 
-  auto curr_size = out_data.size();
+  uint8_t status_bits = 0;
+  status_bits |= tai->synchronization_state ? (1 << 7) : 0;
+  status_bits |= tai->timestamp_generation_failure ? (1 << 6) : 0;
+  status_bits |= tai->timestamp_is_modified ? (1 << 5) : 0;
 
-  if (MAX_MEMORY_BLOCK_SIZE - curr_size < length) {
-    std::stringstream sstr;
-    sstr << "idat box contained " << length << " bytes, total memory size would be "
-         << (curr_size + length) << " bytes, exceeding the security limit of "
-         << MAX_MEMORY_BLOCK_SIZE << " bytes";
+  writer.write8(status_bits);
 
-    return Error(heif_error_Memory_allocation_error,
-                 heif_suberror_Security_limit_exceeded,
-                 sstr.str());
-  }
+  return writer.get_data();
+}
 
+bool operator==(const heif_tai_timestamp_packet& a,
+                const heif_tai_timestamp_packet& b)
+{
+  return a.version == b.version &&
+         a.tai_timestamp == b.tai_timestamp &&
+         a.synchronization_state == b.synchronization_state &&
+         a.timestamp_generation_failure == b.timestamp_generation_failure &&
+         a.timestamp_is_modified == b.timestamp_is_modified;
+}
 
-  // move to start of data
-  if (start > (uint64_t) m_data_start_pos + get_box_size()) {
-    return Error(heif_error_Invalid_input,
-                 heif_suberror_End_of_data);
-  }
-  else if (length > get_box_size() || start + length > get_box_size()) {
-    return Error(heif_error_Invalid_input,
-                 heif_suberror_End_of_data);
+bool Box_itai::operator==(const Box& other) const
+{
+  const auto* other_itai = dynamic_cast<const Box_itai*>(&other);
+  if (other_itai == nullptr) {
+    return false;
   }
 
-  StreamReader::grow_status status = istr->wait_for_file_size((int64_t) m_data_start_pos + start + length);
-  if (status == StreamReader::size_beyond_eof ||
-      status == StreamReader::timeout) {
-    // TODO: maybe we should introduce some 'Recoverable error' instead of 'Invalid input'
-    return Error(heif_error_Invalid_input,
-                 heif_suberror_End_of_data);
-  }
+  return m_timestamp == other_itai->m_timestamp;
+}
 
-  bool success;
-  success = istr->seek(m_data_start_pos + (std::streampos) start);
-  assert(success);
-  (void) success;
 
-  if (length > 0) {
-    // reserve space for the data in the output array
-    out_data.resize(static_cast<size_t>(curr_size + length));
-    uint8_t* data = &out_data[curr_size];
 
-    success = istr->read((char*) data, static_cast<size_t>(length));
-    assert(success);
-  }
+uint64_t uint8_vector_to_uint64_BE(const uint8_t* data)
+{
+  uint64_t value = ((static_cast<uint64_t>(data[0]) << 56) |
+                    (static_cast<uint64_t>(data[1]) << 48) |
+                    (static_cast<uint64_t>(data[2]) << 40) |
+                    (static_cast<uint64_t>(data[3]) << 32) |
+                    (static_cast<uint64_t>(data[4]) << 24) |
+                    (static_cast<uint64_t>(data[5]) << 16) |
+                    (static_cast<uint64_t>(data[6]) << 8) |
+                    (static_cast<uint64_t>(data[7]) << 0));
 
-  return Error::Ok;
+  return value;
 }
 
 
-Error Box_grpl::parse(BitstreamRange& range)
+Result<heif_tai_timestamp_packet> Box_itai::decode_tai_from_vector(const std::vector<uint8_t>& data)
 {
-  //parse_full_box_header(range);
+  if (data.size() != 9) {
+    return Error{heif_error_Invalid_input,
+                 heif_suberror_Unspecified,
+                 "Wrong size of TAI timestamp data"};
+  }
 
-  //return read_children(range);
+  uint8_t status_bits = data[8];
 
-  while (!range.eof()) {
-    EntityGroup group;
-    Error err = group.header.parse(range);
-    if (err != Error::Ok) {
-      return err;
-    }
+  heif_tai_timestamp_packet tai;
+  tai.version = 1;
+  tai.tai_timestamp = uint8_vector_to_uint64_BE(data.data());
+  tai.synchronization_state = !!(status_bits & 0x80);
+  tai.timestamp_generation_failure = !!(status_bits & 0x40);
+  tai.timestamp_is_modified = !!(status_bits & 0x20);
 
-    err = group.header.parse_full_box_header(range);
-    if (err != Error::Ok) {
-      return err;
-    }
+  return tai;
+}
 
-    group.group_id = range.read32();
-    int nEntities = range.read32();
-    for (int i = 0; i < nEntities; i++) {
-      if (range.eof()) {
-        break;
-      }
 
-      group.entity_ids.push_back(range.read32());
-    }
+Error Box_itai::write(StreamWriter& writer) const {
+  size_t box_start = reserve_box_header_space(writer);
 
-    m_entity_groups.push_back(group);
-  }
+  std::vector<uint8_t> tai_data = encode_tai_to_bitstream(&m_timestamp);
 
-  return range.get_error();
-}
+  writer.write(tai_data);
 
+  prepend_header(writer, box_start);
+  return Error::Ok;
+}
 
-std::string Box_grpl::dump(Indent& indent) const
-{
-  std::ostringstream sstr;
-  sstr << Box::dump(indent);
+Error Box_itai::parse(BitstreamRange& range, const heif_security_limits*) {
+  parse_full_box_header(range);
 
-  for (const auto& group : m_entity_groups) {
-    sstr << indent << "group type: " << group.header.get_type_string() << "\n"
-         << indent << "| group id: " << group.group_id << "\n"
-         << indent << "| entity IDs: ";
+  m_timestamp.version = 1;
+  m_timestamp.tai_timestamp = range.read64();
 
-    for (uint32_t id : group.entity_ids) {
-      sstr << id << " ";
-    }
+  uint8_t status_bits = range.read8();
 
-    sstr << "\n";
-  }
+  m_timestamp.synchronization_state = !!(status_bits & 0x80);
+  m_timestamp.timestamp_generation_failure = !!(status_bits & 0x40);
+  m_timestamp.timestamp_is_modified = !!(status_bits & 0x20);
 
-  return sstr.str();
+  return range.get_error();
 }
 
-
-Error Box_dinf::parse(BitstreamRange& range)
+Error Box_elng::parse(BitstreamRange& range, const heif_security_limits* limits)
 {
-  //parse_full_box_header(range);
+  parse_full_box_header(range);
 
-  return read_children(range);
-}
+  if (get_version() > 0) {
+    return unsupported_version_error("elng");
+  }
 
+  m_lang = range.read_string();
+  return range.get_error();
+}
 
-std::string Box_dinf::dump(Indent& indent) const
+std::string Box_elng::dump(Indent& indent) const
 {
   std::ostringstream sstr;
   sstr << Box::dump(indent);
-  sstr << dump_children(indent);
-
+  sstr << indent << "extended_language: " << m_lang << "\n";
   return sstr.str();
 }
 
-
-Error Box_dref::parse(BitstreamRange& range)
+Error Box_elng::write(StreamWriter& writer) const
 {
-  parse_full_box_header(range);
-
-  int nEntities = range.read32();
-
-  /*
-  for (int i=0;i<nEntities;i++) {
-    if (range.eof()) {
-      break;
-    }
-  }
-  */
-
-  Error err = read_children(range, nEntities);
-  if (err) {
-    return err;
-  }
-
-  if ((int) m_children.size() != nEntities) {
-    // TODO return Error(
-  }
-
-  return err;
+  size_t box_start = reserve_box_header_space(writer);
+  writer.write(m_lang);
+  prepend_header(writer, box_start);
+  return Error::Ok;
 }
 
 
-std::string Box_dref::dump(Indent& indent) const
+Error Box_gimi_content_id::parse(BitstreamRange& range, const heif_security_limits* limits)
 {
-  std::ostringstream sstr;
-  sstr << Box::dump(indent);
-  sstr << dump_children(indent);
+  m_content_id = range.read_string_until_eof();
 
-  return sstr.str();
+  return range.get_error();
 }
 
 
-Error Box_url::parse(BitstreamRange& range)
+Error Box_gimi_content_id::write(StreamWriter& writer) const
 {
-  parse_full_box_header(range);
+  size_t box_start = reserve_box_header_space(writer);
 
-  m_location = range.read_string();
+  writer.write(m_content_id, false);
 
-  return range.get_error();
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
 }
 
 
-std::string Box_url::dump(Indent& indent) const
+std::string Box_gimi_content_id::dump(Indent& indent) const
 {
   std::ostringstream sstr;
   sstr << Box::dump(indent);
-  //sstr << dump_children(indent);
 
-  sstr << indent << "location: " << m_location << "\n";
+  sstr << indent << "content ID: " << m_content_id << "\n";
 
   return sstr.str();
 }
diff --git a/libheif/box.h b/libheif/box.h
index 2256861d10..103ccab64a 100644
--- a/libheif/box.h
+++ b/libheif/box.h
@@ -1,6 +1,6 @@
 /*
  * HEIF codec.
- * Copyright (c) 2017 struktur AG, Dirk Farin <farin@struktur.de>
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
  *
  * This file is part of libheif.
  *
@@ -21,13 +21,16 @@
 #ifndef LIBHEIF_BOX_H
 #define LIBHEIF_BOX_H
 
-#if defined(HAVE_CONFIG_H)
-#include "config.h"
-#endif
-
+#include <cstdint>
+#include "common_utils.h"
+#include "libheif/heif.h"
+#include "libheif/heif_experimental.h"
+#include "libheif/heif_properties.h"
+#include "libheif/heif_tai_timestamps.h"
 #include <cinttypes>
 #include <cstddef>
 
+#include <utility>
 #include <vector>
 #include <string>
 #include <memory>
@@ -35,9 +38,9 @@
 #include <istream>
 #include <bitset>
 #include <utility>
+#include <optional>
 
 #include "error.h"
-#include "heif.h"
 #include "logging.h"
 #include "bitstream.h"
 
@@ -46,1172 +49,1879 @@
 #define HAS_BOOL_ARRAY 1
 #endif
 
-namespace heif {
+/*
+  constexpr uint32_t fourcc(const char* string)
+  {
+  return ((string[0]<<24) |
+  (string[1]<<16) |
+  (string[2]<< 8) |
+  (string[3]));
+  }
+*/
+
 
-#define fourcc(id) (((uint32_t)(id[0])<<24) | (id[1]<<16) | (id[2]<<8) | (id[3]))
+class Fraction
+{
+public:
+  Fraction() = default;
 
-  /*
-    constexpr uint32_t fourcc(const char* string)
-    {
-    return ((string[0]<<24) |
-    (string[1]<<16) |
-    (string[2]<< 8) |
-    (string[3]));
-    }
-  */
+  Fraction(int32_t num, int32_t den);
 
+  // may only use values up to int32_t maximum
+  Fraction(uint32_t num, uint32_t den);
 
-  class Fraction
-  {
-  public:
-    Fraction()
-    {}
+  // Values will be reduced until they fit into int32_t.
+  Fraction(int64_t num, int64_t den);
 
-    Fraction(int32_t num, int32_t den);
+  Fraction operator+(const Fraction&) const;
 
-    // may only use values up to int32_t maximum
-    Fraction(uint32_t num, uint32_t den);
+  Fraction operator-(const Fraction&) const;
 
-    Fraction operator+(const Fraction&) const;
+  Fraction operator+(int) const;
 
-    Fraction operator-(const Fraction&) const;
+  Fraction operator-(int) const;
 
-    Fraction operator+(int) const;
+  Fraction operator/(int) const;
 
-    Fraction operator-(int) const;
+  int32_t round_down() const;
 
-    Fraction operator/(int) const;
+  int32_t round_up() const;
 
-    int32_t round_down() const;
+  int32_t round() const;
 
-    int32_t round_up() const;
+  bool is_valid() const;
 
-    int32_t round() const;
+  double to_double() const {
+    return numerator / (double)denominator;
+  }
 
-    bool is_valid() const;
+  int32_t numerator = 0;
+  int32_t denominator = 1;
+};
 
-    int32_t numerator = 0;
-    int32_t denominator = 1;
-  };
 
+inline std::ostream& operator<<(std::ostream& str, const Fraction& f)
+{
+  str << f.numerator << "/" << f.denominator;
+  return str;
+}
+
+
+class BoxHeader
+{
+public:
+  BoxHeader();
+
+  virtual ~BoxHeader() = default;
+
+  constexpr static uint64_t size_until_end_of_file = 0;
+
+  uint64_t get_box_size() const { return m_size; }
+
+  bool has_fixed_box_size() const { return m_size != 0; }
+
+  uint32_t get_header_size() const { return m_header_size; }
+
+  uint32_t get_short_type() const { return m_type; }
+
+  std::vector<uint8_t> get_type() const;
+
+  std::string get_type_string() const;
 
-  inline std::ostream& operator<<(std::ostream& str, const Fraction& f)
+  virtual const char* debug_box_name() const { return nullptr; }
+
+  void set_short_type(uint32_t type) { m_type = type; }
+
+
+  // should only be called if get_short_type == fourcc("uuid")
+  std::vector<uint8_t> get_uuid_type() const;
+
+  void set_uuid_type(const std::vector<uint8_t>&);
+
+
+  Error parse_header(BitstreamRange& range);
+
+  virtual std::string dump(Indent&) const;
+
+
+  virtual bool is_full_box_header() const { return false; }
+
+
+private:
+  uint64_t m_size = 0;
+
+  uint32_t m_type = 0;
+  std::vector<uint8_t> m_uuid_type;
+
+protected:
+  uint32_t m_header_size = 0;
+};
+
+
+enum class BoxStorageMode {
+  Undefined,
+  Memory,
+  Parsed,
+  File
+};
+
+
+// Consequence of a box parse error
+enum class parse_error_fatality {
+  fatal,     // failure to parse this box leads to the associated item being unreable
+  ignorable, // ignoring this box will lead to unexpected output, but may be better than nothing
+  optional   // the box contains extra information that is not essential for viewing
+};
+
+
+class Box : public BoxHeader
+{
+public:
+  Box() = default;
+
+  void set_short_header(const BoxHeader& hdr)
   {
-    str << f.numerator << "/" << f.denominator;
-    return str;
+    *(BoxHeader*) this = hdr;
   }
 
+  // header size without the FullBox fields (if applicable)
+  int calculate_header_size(bool data64bit) const;
+
+  static Error read(BitstreamRange& range, std::shared_ptr<Box>* box, const heif_security_limits*);
+
+  virtual Error write(StreamWriter& writer) const;
+
+  // check, which box version is required and set this in the (full) box header
+  virtual void derive_box_version() {}
 
-  class BoxHeader
+  void derive_box_version_recursive();
+
+  virtual void patch_file_pointers(StreamWriter&, size_t offset) {}
+
+  void patch_file_pointers_recursively(StreamWriter&, size_t offset);
+
+  std::string dump(Indent&) const override;
+
+  template<typename T> [[nodiscard]] std::shared_ptr<T> get_child_box() const
   {
-  public:
-    BoxHeader();
+    // TODO: we could remove the dynamic_cast<> by adding the fourcc type of each Box
+    //       as a "constexpr uint32_t Box::short_type", compare to that and use static_cast<>
+    for (auto& box : m_children) {
+      if (auto typed_box = std::dynamic_pointer_cast<T>(box)) {
+        return typed_box;
+      }
+    }
 
-    virtual ~BoxHeader()
-    {}
+    return nullptr;
+  }
 
-    constexpr static uint64_t size_until_end_of_file = 0;
+  template<typename T> bool replace_child_box(const std::shared_ptr<T>& box)
+  {
+    for (auto & b : m_children) {
+      if (std::dynamic_pointer_cast<T>(b) != nullptr) {
+        b = box;
+        return true;
+      }
+    }
 
-    uint64_t get_box_size() const
-    { return m_size; }
+    append_child_box(box);
+    return false;
+  }
 
-    uint32_t get_header_size() const
-    { return m_header_size; }
+  template<typename T>
+  std::vector<std::shared_ptr<T>> get_child_boxes() const
+  {
+    std::vector<std::shared_ptr<T>> result;
+    for (auto& box : m_children) {
+      if (auto typed_box = std::dynamic_pointer_cast<T>(box)) {
+        result.push_back(typed_box);
+      }
+    }
 
-    uint32_t get_short_type() const
-    { return m_type; }
+    return result;
+  }
 
-    std::vector<uint8_t> get_type() const;
+  const std::vector<std::shared_ptr<Box>>& get_all_child_boxes() const { return m_children; }
 
-    std::string get_type_string() const;
+  uint32_t append_child_box(const std::shared_ptr<Box>& box)
+  {
+    m_children.push_back(box);
+    return (int) m_children.size() - 1;
+  }
 
-    void set_short_type(uint32_t type)
-    { m_type = type; }
+  bool has_child_boxes() const { return !m_children.empty(); }
 
+  bool remove_child_box(const std::shared_ptr<const Box>& box);
 
-    Error parse(BitstreamRange& range);
+  virtual bool operator==(const Box& other) const;
 
-    virtual std::string dump(Indent&) const;
+  static bool equal(const std::shared_ptr<Box>& box1, const std::shared_ptr<Box>& box2);
 
+  BoxStorageMode get_box_storage_mode() const { return m_storage_mode; }
 
-    // --- full box
+  void set_output_position(uint64_t pos) { m_output_position = pos; }
 
-    Error parse_full_box_header(BitstreamRange& range);
+  virtual parse_error_fatality get_parse_error_fatality() const { return parse_error_fatality::fatal; }
 
-    uint8_t get_version() const
-    { return m_version; }
+  // Note: this function may never be called for `ispe` items since it depends
+  //       on the image item type whether the `ispe` is essential.
+  virtual bool is_essential() const { return m_is_essential; } // only used for properties
 
-    void set_version(uint8_t version)
-    { m_version = version; }
+  void set_is_essential(bool flag) { m_is_essential = flag; }
 
-    uint32_t get_flags() const
-    { return m_flags; }
+  virtual bool is_transformative_property() const { return false; } // only used for properties
 
-    void set_flags(uint32_t flags)
-    { m_flags = flags; }
+protected:
+  virtual Error parse(BitstreamRange& range, const heif_security_limits* limits);
 
-    void set_is_full_box(bool flag = true)
-    { m_is_full_box = flag; }
+  std::vector<std::shared_ptr<Box>> m_children;
 
-    bool is_full_box_header() const
-    { return m_is_full_box; }
+  BoxStorageMode m_storage_mode = BoxStorageMode::Undefined;
 
+  const static uint64_t INVALID_POSITION = 0xFFFFFFFFFFFFFFFF;
 
-    // --- writing
+  uint64_t m_input_position = INVALID_POSITION;
+  uint64_t m_output_position = INVALID_POSITION;
+  std::vector<uint8_t> m_box_data; // including header
 
-    size_t reserve_box_header_space(StreamWriter& writer) const;
+  std::string m_debug_box_type;
 
-    Error prepend_header(StreamWriter&, size_t box_start) const;
+  bool m_is_essential = false;
 
-  private:
-    uint64_t m_size = 0;
-    uint32_t m_header_size = 0;
+  const static uint32_t READ_CHILDREN_ALL = 0xFFFFFFFF;
 
-    uint32_t m_type = 0;
-    std::vector<uint8_t> m_uuid_type;
+  Error read_children(BitstreamRange& range, uint32_t number /* READ_CHILDREN_ALL */, const heif_security_limits* limits);
 
+  Error write_children(StreamWriter& writer) const;
 
-    bool m_is_full_box = false;
+  std::string dump_children(Indent&, bool with_index = false) const;
 
-    uint8_t m_version = 0;
-    uint32_t m_flags = 0;
-  };
+
+  // --- writing
+
+  virtual size_t reserve_box_header_space(StreamWriter& writer, bool data64bit = false) const;
+
+  Error prepend_header(StreamWriter&, size_t box_start, bool data64bit = false) const;
+
+  virtual Error write_header(StreamWriter&, size_t total_box_size, bool data64bit = false) const;
+};
+
+
+class FullBox : public Box
+{
+public:
+  bool is_full_box_header() const override { return true; }
+
+  std::string dump(Indent& indent) const override;
+
+  void derive_box_version() override { set_version(0); }
 
 
-  class Box : public BoxHeader
+  Error parse_full_box_header(BitstreamRange& range);
+
+  uint8_t get_version() const { return m_version; }
+
+  void set_version(uint8_t version) { m_version = version; }
+
+  uint32_t get_flags() const { return m_flags; }
+
+  void set_flags(uint32_t flags) { m_flags = flags; }
+
+protected:
+
+  // --- writing
+
+  size_t reserve_box_header_space(StreamWriter& writer, bool data64bit = false) const override;
+
+  Error write_header(StreamWriter&, size_t total_size, bool data64bit = false) const override;
+
+  Error unsupported_version_error(const char* box) const;
+
+private:
+  uint8_t m_version = 0;
+  uint32_t m_flags = 0;
+};
+
+
+class Box_other : public Box
+{
+public:
+  Box_other(uint32_t short_type)
   {
-  public:
-    Box()
-    {}
+    set_short_type(short_type);
+  }
 
-    Box(const BoxHeader& hdr) : BoxHeader(hdr)
-    {}
+  const std::vector<uint8_t>& get_raw_data() const { return m_data; }
 
-    static Error read(BitstreamRange& range, std::shared_ptr<heif::Box>* box);
+  void set_raw_data(const std::vector<uint8_t>& data) { m_data = data; }
 
-    virtual Error write(StreamWriter& writer) const;
+  Error write(StreamWriter& writer) const override;
 
-    // check, which box version is required and set this in the (full) box header
-    virtual void derive_box_version()
-    { set_version(0); }
+  std::string dump(Indent&) const override;
 
-    void derive_box_version_recursive();
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
 
-    virtual std::string dump(Indent&) const;
+  std::vector<uint8_t> m_data;
+};
 
-    std::shared_ptr<Box> get_child_box(uint32_t short_type) const;
 
-    std::vector<std::shared_ptr<Box>> get_child_boxes(uint32_t short_type) const;
 
-    const std::vector<std::shared_ptr<Box>>& get_all_child_boxes() const
-    { return m_children; }
+class Box_Error : public Box
+{
+public:
+  Box_Error(uint32_t box4cc, Error err, parse_error_fatality fatality)
+  {
+    set_short_type(fourcc("ERR "));
 
-    int append_child_box(std::shared_ptr<Box> box)
-    {
-      m_children.push_back(box);
-      return (int) m_children.size() - 1;
-    }
+    m_box_type_with_parse_error = box4cc;
+    m_error = std::move(err);
+    m_fatality = fatality;
+  }
 
-  protected:
-    virtual Error parse(BitstreamRange& range);
+  Error write(StreamWriter& writer) const override { return {heif_error_Usage_error, heif_suberror_Unspecified, "Cannot write dummy error box."}; }
 
-    std::vector<std::shared_ptr<Box>> m_children;
+  std::string dump(Indent&) const override;
 
-    const static int READ_CHILDREN_ALL = -1;
+  [[nodiscard]] parse_error_fatality get_parse_error_fatality() const override;
 
-    Error read_children(BitstreamRange& range, int number = READ_CHILDREN_ALL);
+  [[nodiscard]] Error get_error() const { return m_error; }
 
-    Error write_children(StreamWriter& writer) const;
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override { assert(false); return Error::Ok; }
 
-    std::string dump_children(Indent&) const;
-  };
+  uint32_t m_box_type_with_parse_error;
+  Error m_error;
+  parse_error_fatality m_fatality;
+};
 
 
-  class Box_ftyp : public Box
+
+
+class Box_ftyp : public Box
+{
+public:
+  Box_ftyp()
   {
-  public:
-    Box_ftyp()
-    {
-      set_short_type(fourcc("ftyp"));
-      set_is_full_box(false);
-    }
+    set_short_type(fourcc("ftyp"));
+  }
 
-    Box_ftyp(const BoxHeader& hdr) : Box(hdr)
-    {}
+  std::string dump(Indent&) const override;
 
-    std::string dump(Indent&) const override;
+  const char* debug_box_name() const override { return "File Type"; }
 
-    bool has_compatible_brand(uint32_t brand) const;
+  bool has_compatible_brand(uint32_t brand) const;
 
-    std::vector<uint32_t> list_brands() const { return m_compatible_brands; }
+  std::vector<uint32_t> list_brands() const { return m_compatible_brands; }
 
-    
-    void set_major_brand(uint32_t major_brand)
-    { m_major_brand = major_brand; }
+  uint32_t get_major_brand() const { return m_major_brand; }
 
-    void set_minor_version(uint32_t minor_version)
-    { m_minor_version = minor_version; }
+  void set_major_brand(heif_brand2 major_brand) { m_major_brand = major_brand; }
 
-    void clear_compatible_brands()
-    { m_compatible_brands.clear(); }
+  uint32_t get_minor_version() const { return m_minor_version; }
 
-    void add_compatible_brand(uint32_t brand);
+  void set_minor_version(uint32_t minor_version) { m_minor_version = minor_version; }
 
-    Error write(StreamWriter& writer) const override;
+  void clear_compatible_brands() { m_compatible_brands.clear(); }
 
-  protected:
-    Error parse(BitstreamRange& range) override;
+  void add_compatible_brand(heif_brand2 brand);
 
-  private:
-    uint32_t m_major_brand = 0;
-    uint32_t m_minor_version = 0;
-    std::vector<uint32_t> m_compatible_brands;
-  };
+  Error write(StreamWriter& writer) const override;
 
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
 
-  class Box_meta : public Box
+private:
+  uint32_t m_major_brand = 0;
+  uint32_t m_minor_version = 0;
+  std::vector<heif_brand2> m_compatible_brands;
+};
+
+
+class Box_free : public Box
+{
+public:
+  Box_free()
   {
-  public:
-    Box_meta()
-    {
-      set_short_type(fourcc("meta"));
-      set_is_full_box(true);
-    }
+    set_short_type(fourcc("free"));
+  }
 
-    Box_meta(const BoxHeader& hdr) : Box(hdr)
-    {}
+  std::string dump(Indent&) const override;
 
-    std::string dump(Indent&) const override;
+  const char* debug_box_name() const override { return "Free Space"; }
 
-  protected:
-    Error parse(BitstreamRange& range) override;
-  };
+  Error write(StreamWriter& writer) const override;
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+};
 
 
-  class Box_hdlr : public Box
+class Box_meta : public FullBox
+{
+public:
+  Box_meta()
   {
-  public:
-    Box_hdlr()
-    {
-      set_short_type(fourcc("hdlr"));
-      set_is_full_box(true);
-    }
+    set_short_type(fourcc("meta"));
+  }
+
+  std::string dump(Indent&) const override;
 
-    Box_hdlr(const BoxHeader& hdr) : Box(hdr)
-    {}
+  const char* debug_box_name() const override { return "Metadata"; }
 
-    std::string dump(Indent&) const override;
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+};
 
-    uint32_t get_handler_type() const
-    { return m_handler_type; }
 
-    void set_handler_type(uint32_t handler)
-    { m_handler_type = handler; }
+class Box_hdlr : public FullBox
+{
+public:
+  Box_hdlr()
+  {
+    set_short_type(fourcc("hdlr"));
+  }
 
-    Error write(StreamWriter& writer) const override;
+  std::string dump(Indent&) const override;
 
-    void set_name(std::string name) { m_name = std::move(name); }
+  const char* debug_box_name() const override { return "Handler Reference"; }
 
-  protected:
-    Error parse(BitstreamRange& range) override;
+  uint32_t get_handler_type() const { return m_handler_type; }
 
-  private:
-    uint32_t m_pre_defined = 0;
-    uint32_t m_handler_type = fourcc("pict");
-    uint32_t m_reserved[3] = {0,};
-    std::string m_name;
-  };
+  void set_handler_type(uint32_t handler) { m_handler_type = handler; }
 
+  Error write(StreamWriter& writer) const override;
 
-  class Box_pitm : public Box
+  void set_name(std::string name) { m_name = std::move(name); }
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+
+private:
+  uint32_t m_pre_defined = 0;
+  uint32_t m_handler_type = fourcc("pict");
+  uint32_t m_reserved[3] = {0,};
+  std::string m_name;
+};
+
+
+class Box_pitm : public FullBox
+{
+public:
+  Box_pitm()
   {
-  public:
-    Box_pitm()
-    {
-      set_short_type(fourcc("pitm"));
-      set_is_full_box(true);
-    }
+    set_short_type(fourcc("pitm"));
+  }
 
-    Box_pitm(const BoxHeader& hdr) : Box(hdr)
-    {}
+  std::string dump(Indent&) const override;
 
-    std::string dump(Indent&) const override;
+  const char* debug_box_name() const override { return "Primary Item"; }
 
-    heif_item_id get_item_ID() const
-    { return m_item_ID; }
+  heif_item_id get_item_ID() const { return m_item_ID; }
 
-    void set_item_ID(heif_item_id id)
-    { m_item_ID = id; }
+  void set_item_ID(heif_item_id id) { m_item_ID = id; }
 
-    void derive_box_version() override;
+  void derive_box_version() override;
 
-    Error write(StreamWriter& writer) const override;
+  Error write(StreamWriter& writer) const override;
 
-  protected:
-    Error parse(BitstreamRange& range) override;
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
 
-  private:
-    heif_item_id m_item_ID = 0;
-  };
+private:
+  heif_item_id m_item_ID = 0;
+};
+
+
+class Box_iloc : public FullBox
+{
+public:
+  Box_iloc();
+
+  ~Box_iloc() override;
+
+  void set_use_tmp_file(bool flag);
 
+  std::string dump(Indent&) const override;
 
-  class Box_iloc : public Box
+  const char* debug_box_name() const override { return "Item Location"; }
+
+  struct Extent
   {
-  public:
-    Box_iloc()
-    {
-      set_short_type(fourcc("iloc"));
-      set_is_full_box(true);
-    }
+    uint64_t index = 0;
+    uint64_t offset = 0;
+    uint64_t length = 0;
 
-    Box_iloc(const BoxHeader& hdr) : Box(hdr)
-    {}
+    std::vector<uint8_t> data; // only used when writing data
+  };
 
-    std::string dump(Indent&) const override;
+  struct Item
+  {
+    heif_item_id item_ID = 0;
+    uint8_t construction_method = 0; // >= version 1
+    uint16_t data_reference_index = 0;
+    uint64_t base_offset = 0;
 
-    struct Extent
-    {
-      uint64_t index = 0;
-      uint64_t offset = 0;
-      uint64_t length = 0;
+    std::vector<Extent> extents;
+  };
 
-      std::vector<uint8_t> data; // only used when writing data
-    };
+  const std::vector<Item>& get_items() const { return m_items; }
 
-    struct Item
-    {
-      heif_item_id item_ID = 0;
-      uint8_t construction_method = 0; // >= version 1
-      uint16_t data_reference_index = 0;
-      uint64_t base_offset = 0;
+  Error read_data(heif_item_id item,
+                  const std::shared_ptr<StreamReader>& istr,
+                  const std::shared_ptr<class Box_idat>&,
+                  std::vector<uint8_t>* dest,
+                  const heif_security_limits* limits) const;
 
-      std::vector<Extent> extents;
-    };
+  // Note: size==std::numeric_limits<uint64_t>::max() reads the data until the end
+  Error read_data(heif_item_id item,
+                  const std::shared_ptr<StreamReader>& istr,
+                  const std::shared_ptr<class Box_idat>&,
+                  std::vector<uint8_t>* dest,
+                  uint64_t offset, uint64_t size,
+                  const heif_security_limits* limits) const;
 
-    const std::vector<Item>& get_items() const
-    { return m_items; }
+  void set_min_version(uint8_t min_version) { m_user_defined_min_version = min_version; }
 
-    Error read_data(const Item& item,
-                    std::shared_ptr<StreamReader> istr,
-                    const std::shared_ptr<class Box_idat>&,
-                    std::vector<uint8_t>* dest) const;
+  // append bitstream data that will be written later (after iloc box)
+  // TODO: use an enum for the construction method
+  Error append_data(heif_item_id item_ID,
+                    const std::vector<uint8_t>& data,
+                    uint8_t construction_method = 0);
 
-    void set_min_version(uint8_t min_version)
-    { m_user_defined_min_version = min_version; }
+  Error replace_data(heif_item_id item_ID,
+                     uint64_t output_offset,
+                     const std::vector<uint8_t>& data,
+                     uint8_t construction_method);
 
-    // append bitstream data that will be written later (after iloc box)
-    Error append_data(heif_item_id item_ID,
-                      const std::vector<uint8_t>& data,
-                      uint8_t construction_method = 0);
+  // append bitstream data that already has been written (before iloc box)
+  // Error write_mdat_before_iloc(heif_image_id item_ID,
+  //                              std::vector<uint8_t>& data)
 
-    // append bitstream data that already has been written (before iloc box)
-    // Error write_mdat_before_iloc(heif_image_id item_ID,
-    //                              std::vector<uint8_t>& data)
+  // reserve data entry that will be written later
+  // Error reserve_mdat_item(heif_image_id item_ID,
+  //                         uint8_t construction_method,
+  //                         uint32_t* slot_ID);
+  // void patch_mdat_slot(uint32_t slot_ID, size_t start, size_t length);
 
-    // reserve data entry that will be written later
-    // Error reserve_mdat_item(heif_image_id item_ID,
-    //                         uint8_t construction_method,
-    //                         uint32_t* slot_ID);
-    // void patch_mdat_slot(uint32_t slot_ID, size_t start, size_t length);
+  void derive_box_version() override;
 
-    void derive_box_version() override;
+  Error write(StreamWriter& writer) const override;
 
-    Error write(StreamWriter& writer) const override;
+  Error write_mdat_after_iloc(StreamWriter& writer);
 
-    Error write_mdat_after_iloc(StreamWriter& writer);
+  void append_item(Item &item) { m_items.push_back(item); }
 
-  protected:
-    Error parse(BitstreamRange& range) override;
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
 
-  private:
-    std::vector<Item> m_items;
+private:
+  std::vector<Item> m_items;
 
-    mutable size_t m_iloc_box_start = 0;
-    uint8_t m_user_defined_min_version = 0;
-    uint8_t m_offset_size = 0;
-    uint8_t m_length_size = 0;
-    uint8_t m_base_offset_size = 0;
-    uint8_t m_index_size = 0;
+  mutable size_t m_iloc_box_start = 0;
+  uint8_t m_user_defined_min_version = 0;
+  uint8_t m_offset_size = 0;
+  uint8_t m_length_size = 0;
+  uint8_t m_base_offset_size = 0;
+  uint8_t m_index_size = 0;
 
-    void patch_iloc_header(StreamWriter& writer) const;
+  void patch_iloc_header(StreamWriter& writer) const;
 
-    int m_idat_offset = 0; // only for writing: offset of next data array
-  };
+  int m_idat_offset = 0; // only for writing: offset of next data array
 
+  bool m_use_tmpfile = false;
+  int m_tmpfile_fd = 0;
+  char m_tmp_filename[20];
+};
 
-  class Box_infe : public Box
+
+class Box_infe : public FullBox
+{
+public:
+  Box_infe()
   {
-  public:
-    Box_infe()
-    {
-      set_short_type(fourcc("infe"));
-      set_is_full_box(true);
-    }
+    set_short_type(fourcc("infe"));
+  }
 
-    Box_infe(const BoxHeader& hdr) : Box(hdr)
-    {}
+  std::string dump(Indent&) const override;
 
-    std::string dump(Indent&) const override;
+  const char* debug_box_name() const override { return "Item Info Entry"; }
 
-    bool is_hidden_item() const
-    { return m_hidden_item; }
+  bool is_hidden_item() const { return m_hidden_item; }
 
-    void set_hidden_item(bool hidden);
+  void set_hidden_item(bool hidden);
 
-    heif_item_id get_item_ID() const
-    { return m_item_ID; }
+  heif_item_id get_item_ID() const { return m_item_ID; }
 
-    void set_item_ID(heif_item_id id)
-    { m_item_ID = id; }
+  void set_item_ID(heif_item_id id) { m_item_ID = id; }
 
-    std::string get_item_type() const
-    { return m_item_type; }
+  uint32_t get_item_type_4cc() const { return m_item_type_4cc; }
 
-    void set_item_type(std::string type)
-    { m_item_type = type; }
+  void set_item_type_4cc(uint32_t type) { m_item_type_4cc = type; }
 
-    void set_item_name(std::string name)
-    { m_item_name = name; }
+  void set_item_name(const std::string& name) { m_item_name = name; }
 
-    std::string get_content_type() const
-    { return m_content_type; }
+  const std::string& get_item_name() const { return m_item_name; }
 
-    void set_content_type(std::string content_type)
-    { m_content_type = content_type; }
+  const std::string& get_content_type() const { return m_content_type; }
 
-    void derive_box_version() override;
+  const std::string& get_content_encoding() const { return m_content_encoding; }
 
-    Error write(StreamWriter& writer) const override;
+  void set_content_type(const std::string& content_type) { m_content_type = content_type; }
 
-  protected:
-    Error parse(BitstreamRange& range) override;
+  void set_content_encoding(const std::string& content_encoding) { m_content_encoding = content_encoding; }
 
-  private:
-    heif_item_id m_item_ID = 0;
-    uint16_t m_item_protection_index = 0;
+  void derive_box_version() override;
 
-    std::string m_item_type;
-    std::string m_item_name;
-    std::string m_content_type;
-    std::string m_content_encoding;
-    std::string m_item_uri_type;
+  Error write(StreamWriter& writer) const override;
 
-    // if set, this item should not be part of the presentation (i.e. hidden)
-    bool m_hidden_item = false;
-  };
+  const std::string& get_item_uri_type() const { return m_item_uri_type; }
+
+  void set_item_uri_type(const std::string& uritype) { m_item_uri_type = uritype; }
 
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
 
-  class Box_iinf : public Box
+private:
+  heif_item_id m_item_ID = 0;
+  uint16_t m_item_protection_index = 0;
+
+  uint32_t m_item_type_4cc = 0;
+  std::string m_item_name;
+  std::string m_content_type;
+  std::string m_content_encoding;
+  std::string m_item_uri_type;
+
+  // if set, this item should not be part of the presentation (i.e. hidden)
+  bool m_hidden_item = false;
+};
+
+
+class Box_iinf : public FullBox
+{
+public:
+  Box_iinf()
   {
-  public:
-    Box_iinf()
-    {
-      set_short_type(fourcc("iinf"));
-      set_is_full_box(true);
-    }
+    set_short_type(fourcc("iinf"));
+  }
 
-    Box_iinf(const BoxHeader& hdr) : Box(hdr)
-    {}
+  std::string dump(Indent&) const override;
 
-    std::string dump(Indent&) const override;
+  const char* debug_box_name() const override { return "Item Information"; }
 
-    void derive_box_version() override;
+  void derive_box_version() override;
 
-    Error write(StreamWriter& writer) const override;
+  Error write(StreamWriter& writer) const override;
 
-  protected:
-    Error parse(BitstreamRange& range) override;
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
 
-  private:
-    //std::vector< std::shared_ptr<Box_infe> > m_iteminfos;
-  };
+private:
+  //std::vector< std::shared_ptr<Box_infe> > m_iteminfos;
+};
 
 
-  class Box_iprp : public Box
+class Box_iprp : public Box
+{
+public:
+  Box_iprp()
   {
-  public:
-    Box_iprp()
-    {
-      set_short_type(fourcc("iprp"));
-      set_is_full_box(false);
-    }
+    set_short_type(fourcc("iprp"));
+  }
 
-    Box_iprp(const BoxHeader& hdr) : Box(hdr)
-    {}
+  std::string dump(Indent&) const override;
 
-    std::string dump(Indent&) const override;
+  const char* debug_box_name() const override { return "Item Properties"; }
 
-  protected:
-    Error parse(BitstreamRange& range) override;
-  };
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+};
 
 
-  class Box_ipco : public Box
+class Box_ipco : public Box
+{
+public:
+  Box_ipco()
   {
-  public:
-    Box_ipco()
-    {
-      set_short_type(fourcc("ipco"));
-      set_is_full_box(false);
-    }
+    set_short_type(fourcc("ipco"));
+  }
 
-    Box_ipco(const BoxHeader& hdr) : Box(hdr)
-    {}
+  uint32_t find_or_append_child_box(const std::shared_ptr<Box>& box);
 
-    struct Property
-    {
-      bool essential;
-      std::shared_ptr<Box> property;
-    };
+  Error get_properties_for_item_ID(heif_item_id itemID,
+                                   const std::shared_ptr<class Box_ipma>&,
+                                   std::vector<std::shared_ptr<Box>>& out_properties) const;
 
-    Error get_properties_for_item_ID(heif_item_id itemID,
-                                     const std::shared_ptr<class Box_ipma>&,
-                                     std::vector<Property>& out_properties) const;
+  std::shared_ptr<Box> get_property_for_item_ID(heif_item_id itemID,
+                                                const std::shared_ptr<class Box_ipma>&,
+                                                uint32_t property_box_type) const;
 
-    std::shared_ptr<Box> get_property_for_item_ID(heif_item_id itemID,
-                                                  const std::shared_ptr<class Box_ipma>&,
-                                                  uint32_t property_box_type) const;
+  bool is_property_essential_for_item(heif_item_id itemId,
+                                      const std::shared_ptr<const class Box>& property,
+                                      const std::shared_ptr<class Box_ipma>&) const;
 
-    std::string dump(Indent&) const override;
+  std::string dump(Indent&) const override;
 
-  protected:
-    Error parse(BitstreamRange& range) override;
-  };
+  const char* debug_box_name() const override { return "Item Property Container"; }
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+};
 
 
-  class Box_ispe : public Box
+class Box_ispe : public FullBox
+{
+public:
+  Box_ispe()
   {
-  public:
-    Box_ispe()
-    {
-      set_short_type(fourcc("ispe"));
-      set_is_full_box(true);
-    }
+    set_short_type(fourcc("ispe"));
+  }
+
+  uint32_t get_width() const { return m_image_width; }
 
-    Box_ispe(const BoxHeader& hdr) : Box(hdr)
-    {}
+  uint32_t get_height() const { return m_image_height; }
 
-    uint32_t get_width() const
-    { return m_image_width; }
+  void set_size(uint32_t width, uint32_t height)
+  {
+    m_image_width = width;
+    m_image_height = height;
+  }
 
-    uint32_t get_height() const
-    { return m_image_height; }
+  std::string dump(Indent&) const override;
 
-    void set_size(uint32_t width, uint32_t height)
-    {
-      m_image_width = width;
-      m_image_height = height;
-    }
+  const char* debug_box_name() const override { return "Image Spatial Extents"; }
 
-    std::string dump(Indent&) const override;
+  Error write(StreamWriter& writer) const override;
 
-    Error write(StreamWriter& writer) const override;
+  bool operator==(const Box& other) const override;
 
-  protected:
-    Error parse(BitstreamRange& range) override;
+  // Note: this depends on the image item type. Never call this for an `ispe` property.
+  bool is_essential() const override { assert(false); return false; }
 
-  private:
-    uint32_t m_image_width = 0;
-    uint32_t m_image_height = 0;
-  };
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+
+private:
+  uint32_t m_image_width = 0;
+  uint32_t m_image_height = 0;
+};
 
 
-  class Box_ipma : public Box
+class Box_ipma : public FullBox
+{
+public:
+  Box_ipma()
   {
-  public:
-    Box_ipma()
-    {
-      set_short_type(fourcc("ipma"));
-      set_is_full_box(true);
-    }
+    set_short_type(fourcc("ipma"));
+  }
+
+  std::string dump(Indent&) const override;
+
+  const char* debug_box_name() const override { return "Item Property Association"; }
 
-    Box_ipma(const BoxHeader& hdr) : Box(hdr)
-    {}
+  struct PropertyAssociation
+  {
+    bool essential;
+    uint16_t property_index;
+  };
 
-    std::string dump(Indent&) const override;
+  const std::vector<PropertyAssociation>* get_properties_for_item_ID(heif_item_id itemID) const;
 
-    struct PropertyAssociation
-    {
-      bool essential;
-      uint16_t property_index;
-    };
+  bool is_property_essential_for_item(heif_item_id itemId, int propertyIndex) const;
 
-    const std::vector<PropertyAssociation>* get_properties_for_item_ID(heif_item_id itemID) const;
+  void add_property_for_item_ID(heif_item_id itemID,
+                                PropertyAssociation assoc);
 
-    void add_property_for_item_ID(heif_item_id itemID,
-                                  PropertyAssociation assoc);
+  void derive_box_version() override;
 
-    void derive_box_version() override;
+  Error write(StreamWriter& writer) const override;
 
-    Error write(StreamWriter& writer) const override;
+  void insert_entries_from_other_ipma_box(const Box_ipma& b);
 
-  protected:
-    Error parse(BitstreamRange& range) override;
+  // sorts properties such that descriptive properties precede the transformative properties
+  void sort_properties(const std::shared_ptr<Box_ipco>&);
 
-    struct Entry
-    {
-      heif_item_id item_ID;
-      std::vector<PropertyAssociation> associations;
-    };
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
 
-    std::vector<Entry> m_entries;
+  struct Entry
+  {
+    heif_item_id item_ID;
+    std::vector<PropertyAssociation> associations;
   };
 
+  std::vector<Entry> m_entries;
+};
 
-  class Box_auxC : public Box
+
+class Box_auxC : public FullBox
+{
+public:
+  Box_auxC()
   {
-  public:
-    Box_auxC()
-    {
-      set_short_type(fourcc("auxC"));
-      set_is_full_box(true);
-    }
+    set_short_type(fourcc("auxC"));
+  }
 
-    Box_auxC(const BoxHeader& hdr) : Box(hdr)
-    {}
+  const std::string& get_aux_type() const { return m_aux_type; }
 
-    std::string get_aux_type() const
-    { return m_aux_type; }
+  void set_aux_type(const std::string& type) { m_aux_type = type; }
 
-    void set_aux_type(std::string type)
-    { m_aux_type = type; }
+  const std::vector<uint8_t>& get_subtypes() const { return m_aux_subtypes; }
 
-    std::vector<uint8_t> get_subtypes() const
-    { return m_aux_subtypes; }
+  bool is_essential() const override { return true; }
 
-    std::string dump(Indent&) const override;
+  std::string dump(Indent&) const override;
 
-  protected:
-    Error parse(BitstreamRange& range) override;
+  const char* debug_box_name() const override { return "Image Properties for Auxiliary Images"; }
 
-    Error write(StreamWriter& writer) const override;
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
 
-  private:
-    std::string m_aux_type;
-    std::vector<uint8_t> m_aux_subtypes;
-  };
+  Error write(StreamWriter& writer) const override;
+
+private:
+  std::string m_aux_type;
+  std::vector<uint8_t> m_aux_subtypes;
+};
 
 
-  class Box_irot : public Box
+class Box_irot : public Box
+{
+public:
+  Box_irot()
   {
-  public:
-    Box_irot(const BoxHeader& hdr) : Box(hdr)
-    {}
+    set_short_type(fourcc("irot"));
+  }
 
-    std::string dump(Indent&) const override;
+  bool is_essential() const override { return true; }
 
-    int get_rotation() const
-    { return m_rotation; }
+  bool is_transformative_property() const override { return true; }
 
-  protected:
-    Error parse(BitstreamRange& range) override;
+  std::string dump(Indent&) const override;
 
-  private:
-    int m_rotation = 0; // in degrees (CCW)
-  };
+  const char* debug_box_name() const override { return "Image Rotation"; }
+
+  int get_rotation_ccw() const { return m_rotation; }
+
+  // Only these multiples of 90 are allowed: 0, 90, 180, 270.
+  void set_rotation_ccw(int rot) { m_rotation = rot; }
+
+  [[nodiscard]] parse_error_fatality get_parse_error_fatality() const override { return parse_error_fatality::ignorable; }
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
 
+  Error write(StreamWriter& writer) const override;
 
-  class Box_imir : public Box
+private:
+  int m_rotation = 0; // in degrees (CCW)
+};
+
+
+class Box_imir : public Box
+{
+public:
+  Box_imir()
   {
-  public:
-    Box_imir(const BoxHeader& hdr) : Box(hdr)
-    {}
+    set_short_type(fourcc("imir"));
+  }
 
-    enum class MirrorDirection : uint8_t
-    {
-      Vertical = 0,
-      Horizontal = 1
-    };
+  bool is_essential() const override { return true; }
 
-    MirrorDirection get_mirror_direction() const
-    { return m_axis; }
+  bool is_transformative_property() const override { return true; }
 
-    std::string dump(Indent&) const override;
+  heif_transform_mirror_direction get_mirror_direction() const { return m_axis; }
 
-  protected:
-    Error parse(BitstreamRange& range) override;
+  void set_mirror_direction(heif_transform_mirror_direction dir) { m_axis = dir; }
 
-  private:
-    MirrorDirection m_axis = MirrorDirection::Vertical;
-  };
+  std::string dump(Indent&) const override;
+
+  const char* debug_box_name() const override { return "Image Mirroring"; }
 
+  [[nodiscard]] parse_error_fatality get_parse_error_fatality() const override { return parse_error_fatality::ignorable; }
 
-  class Box_clap : public Box
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+
+  Error write(StreamWriter& writer) const override;
+
+private:
+  heif_transform_mirror_direction m_axis = heif_transform_mirror_direction_vertical;
+};
+
+
+class Box_clap : public Box
+{
+public:
+  Box_clap()
   {
-  public:
-    Box_clap()
-    {
-      set_short_type(fourcc("clap"));
-      set_is_full_box(false);
-    }
+    set_short_type(fourcc("clap"));
+  }
 
-    Box_clap(const BoxHeader& hdr) : Box(hdr)
-    {}
+  bool is_essential() const override { return true; }
 
-    std::string dump(Indent&) const override;
+  bool is_transformative_property() const override { return true; }
 
-    int left_rounded(int image_width) const;  // first column
-    int right_rounded(int image_width) const; // last column that is part of the cropped image
-    int top_rounded(int image_height) const;   // first row
-    int bottom_rounded(int image_height) const; // last row included in the cropped image
+  std::string dump(Indent&) const override;
 
-    int get_width_rounded() const;
+  const char* debug_box_name() const override { return "Clean Aperture"; }
 
-    int get_height_rounded() const;
+  int left_rounded(uint32_t image_width) const;  // first column
+  int right_rounded(uint32_t image_width) const; // last column that is part of the cropped image
+  int top_rounded(uint32_t image_height) const;   // first row
+  int bottom_rounded(uint32_t image_height) const; // last row included in the cropped image
 
-    void set(uint32_t clap_width, uint32_t clap_height,
-             uint32_t image_width, uint32_t image_height);
+  double left(int image_width) const;
+  double top(int image_height) const;
 
-  protected:
-    Error parse(BitstreamRange& range) override;
+  int get_width_rounded() const;
 
-    Error write(StreamWriter& writer) const override;
+  int get_height_rounded() const;
 
-  private:
-    Fraction m_clean_aperture_width;
-    Fraction m_clean_aperture_height;
-    Fraction m_horizontal_offset;
-    Fraction m_vertical_offset;
-  };
+  void set(uint32_t clap_width, uint32_t clap_height,
+           uint32_t image_width, uint32_t image_height);
+
+  [[nodiscard]] parse_error_fatality get_parse_error_fatality() const override { return parse_error_fatality::ignorable; }
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+
+  Error write(StreamWriter& writer) const override;
+
+private:
+  Fraction m_clean_aperture_width;
+  Fraction m_clean_aperture_height;
+  Fraction m_horizontal_offset;
+  Fraction m_vertical_offset;
+};
 
 
-  class Box_iref : public Box
+class Box_iref : public FullBox
+{
+public:
+  Box_iref()
   {
-  public:
-    Box_iref()
-    {
-      set_short_type(fourcc("iref"));
-      set_is_full_box(true);
-    }
+    set_short_type(fourcc("iref"));
+  }
+
+  struct Reference
+  {
+    BoxHeader header;
 
-    Box_iref(const BoxHeader& hdr) : Box(hdr)
-    {}
+    heif_item_id from_item_ID;
+    std::vector<heif_item_id> to_item_ID;
+  };
 
-    struct Reference
-    {
-      BoxHeader header;
 
-      heif_item_id from_item_ID;
-      std::vector<heif_item_id> to_item_ID;
-    };
+  std::string dump(Indent&) const override;
 
+  const char* debug_box_name() const override { return "Item Reference"; }
 
-    std::string dump(Indent&) const override;
+  bool has_references(heif_item_id itemID) const;
 
-    bool has_references(heif_item_id itemID) const;
+  std::vector<heif_item_id> get_references(heif_item_id itemID, uint32_t ref_type) const;
 
-    std::vector<heif_item_id> get_references(heif_item_id itemID, uint32_t ref_type) const;
+  std::vector<Reference> get_references_from(heif_item_id itemID) const;
 
-    std::vector<Reference> get_references_from(heif_item_id itemID) const;
+  void add_references(heif_item_id from_id, uint32_t type, const std::vector<heif_item_id>& to_ids);
 
-    void add_reference(heif_item_id from_id, uint32_t type, std::vector<heif_item_id> to_ids);
+  void overwrite_reference(heif_item_id from_id, uint32_t type, uint32_t reference_idx, heif_item_id to_item);
 
-  protected:
-    Error parse(BitstreamRange& range) override;
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
 
-    Error write(StreamWriter& writer) const override;
+  Error write(StreamWriter& writer) const override;
 
-    void derive_box_version() override;
+  void derive_box_version() override;
 
-  private:
-    std::vector<Reference> m_references;
-  };
+  Error check_for_double_references() const;
 
+private:
+  std::vector<Reference> m_references;
+};
 
-  class Box_hvcC : public Box
+
+class Box_idat : public Box
+{
+public:
+  std::string dump(Indent&) const override;
+
+  const char* debug_box_name() const override { return "Item Data"; }
+
+  Error read_data(const std::shared_ptr<StreamReader>& istr,
+                  uint64_t start, uint64_t length,
+                  std::vector<uint8_t>& out_data,
+                  const heif_security_limits* limits) const;
+
+  int append_data(const std::vector<uint8_t>& data)
   {
-  public:
-    Box_hvcC()
-    {
-      set_short_type(fourcc("hvcC"));
-      set_is_full_box(false);
-    }
+    auto pos = m_data_for_writing.size();
 
-    Box_hvcC(const BoxHeader& hdr) : Box(hdr)
-    {}
+    m_data_for_writing.insert(m_data_for_writing.end(),
+                              data.begin(),
+                              data.end());
 
-    struct configuration
-    {
-      uint8_t configuration_version;
-      uint8_t general_profile_space;
-      bool general_tier_flag;
-      uint8_t general_profile_idc;
-      uint32_t general_profile_compatibility_flags;
+    return (int) pos;
+  }
 
-      static const int NUM_CONSTRAINT_INDICATOR_FLAGS = 48;
-      std::bitset<NUM_CONSTRAINT_INDICATOR_FLAGS> general_constraint_indicator_flags;
+  Error write(StreamWriter& writer) const override;
 
-      uint8_t general_level_idc;
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
 
-      uint16_t min_spatial_segmentation_idc;
-      uint8_t parallelism_type;
-      uint8_t chroma_format;
-      uint8_t bit_depth_luma;
-      uint8_t bit_depth_chroma;
-      uint16_t avg_frame_rate;
+  std::streampos m_data_start_pos;
 
-      uint8_t constant_frame_rate;
-      uint8_t num_temporal_layers;
-      uint8_t temporal_id_nested;
-    };
+  std::vector<uint8_t> m_data_for_writing;
+};
 
 
-    std::string dump(Indent&) const override;
+class Box_grpl : public Box
+{
+public:
+  Box_grpl()
+  {
+    set_short_type(fourcc("grpl"));
+  }
 
-    bool get_headers(std::vector<uint8_t>* dest) const;
+  std::string dump(Indent&) const override;
 
-    void set_configuration(const configuration& config)
-    { m_configuration = config; }
+  const char* debug_box_name() const override { return "Groups List"; }
 
-    configuration get_configuration() const
-    { return m_configuration; }
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+};
 
-    void append_nal_data(const std::vector<uint8_t>& nal);
 
-    void append_nal_data(const uint8_t* data, size_t size);
+class Box_EntityToGroup : public FullBox
+{
+public:
+  std::string dump(Indent&) const override;
 
-    Error write(StreamWriter& writer) const override;
+  Error write(StreamWriter& writer) const override;
 
-  protected:
-    Error parse(BitstreamRange& range) override;
+  void set_group_id(heif_entity_group_id id) { group_id = id; }
 
-  private:
-    struct NalArray
-    {
-      uint8_t m_array_completeness;
-      uint8_t m_NAL_unit_type;
+  heif_entity_group_id get_group_id() const { return group_id; }
 
-      std::vector<std::vector<uint8_t> > m_nal_units;
-    };
+  void set_item_ids(const std::vector<heif_item_id>& ids) { entity_ids = ids; }
 
-    configuration m_configuration;
-    uint8_t m_length_size = 4; // default: 4 bytes for NAL unit lengths
+  const std::vector<heif_item_id>& get_item_ids() const { return entity_ids; }
 
-    std::vector<NalArray> m_nal_array;
-  };
+protected:
+  heif_entity_group_id group_id = 0;
+  std::vector<heif_item_id> entity_ids;
 
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
 
-  class Box_av1C : public Box
+  void write_entity_group_ids(StreamWriter& writer) const;
+};
+
+
+class Box_ster : public Box_EntityToGroup
+{
+public:
+  Box_ster()
   {
-  public:
-    Box_av1C()
-    {
-      set_short_type(fourcc("av1C"));
-      set_is_full_box(false);
-    }
+    set_short_type(fourcc("ster"));
+  }
 
-    Box_av1C(const BoxHeader& hdr) : Box(hdr)
-    {}
-
-    struct configuration
-    {
-      //unsigned int (1) marker = 1;
-      uint8_t version = 1;
-      uint8_t seq_profile = 0;
-      uint8_t seq_level_idx_0 = 0;
-      uint8_t seq_tier_0 = 0;
-      uint8_t high_bitdepth = 0;
-      uint8_t twelve_bit = 0;
-      uint8_t monochrome = 0;
-      uint8_t chroma_subsampling_x = 0;
-      uint8_t chroma_subsampling_y = 0;
-      uint8_t chroma_sample_position = 0;
-      //uint8_t reserved = 0;
-
-      uint8_t initial_presentation_delay_present = 0;
-      uint8_t initial_presentation_delay_minus_one = 0;
-
-      //unsigned int (8)[] configOBUs;
-    };
-
-
-    std::string dump(Indent&) const override;
-
-    bool get_headers(std::vector<uint8_t>* dest) const
-    {
-      *dest = m_config_OBUs;
-      return true;
-    }
+  std::string dump(Indent&) const override;
+
+  const char* debug_box_name() const override { return "Stereo pair"; }
+
+  heif_item_id get_left_image() const { return entity_ids[0]; }
+  heif_item_id get_right_image() const { return entity_ids[1]; }
+
+protected:
 
-    void set_configuration(const configuration& config)
-    { m_configuration = config; }
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+};
 
-    configuration get_configuration() const
-    { return m_configuration; }
 
-    //void append_nal_data(const std::vector<uint8_t>& nal);
-    //void append_nal_data(const uint8_t* data, size_t size);
+class Box_pymd : public Box_EntityToGroup
+{
+public:
+  Box_pymd()
+  {
+    set_short_type(fourcc("pymd"));
+  }
 
-    Error write(StreamWriter& writer) const override;
+  std::string dump(Indent&) const override;
 
-  protected:
-    Error parse(BitstreamRange& range) override;
+  const char* debug_box_name() const override { return "Image pyramid group"; }
 
-  private:
-    configuration m_configuration;
+  Error write(StreamWriter& writer) const override;
 
-    std::vector<uint8_t> m_config_OBUs;
+  struct LayerInfo {
+    uint16_t layer_binning;
+    uint16_t tiles_in_layer_row_minus1;
+    uint16_t tiles_in_layer_column_minus1;
   };
 
+  void set_layers(uint16_t _tile_size_x,
+                  uint16_t _tile_size_y,
+                  const std::vector<LayerInfo>& layers,
+                  const std::vector<heif_item_id>& layer_item_ids) // low to high resolution
+  {
+    set_item_ids(layer_item_ids);
+    m_layer_infos = layers;
+    tile_size_x = _tile_size_x;
+    tile_size_y = _tile_size_y;
+  }
+
+  const std::vector<LayerInfo>& get_layers() const { return m_layer_infos; }
+
+  [[nodiscard]] parse_error_fatality get_parse_error_fatality() const override { return parse_error_fatality::ignorable; }
+
+protected:
+  uint16_t tile_size_x = 0;
+  uint16_t tile_size_y = 0;
+
+  std::vector<LayerInfo> m_layer_infos;
+
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+};
+
+
+
 
-  class Box_idat : public Box
+class Box_dinf : public Box
+{
+public:
+  Box_dinf()
   {
-  public:
-    Box_idat(const BoxHeader& hdr) : Box(hdr)
-    {}
+    set_short_type(fourcc("dinf"));
+  }
 
-    std::string dump(Indent&) const override;
+  std::string dump(Indent&) const override;
 
-    Error read_data(std::shared_ptr<StreamReader> istr,
-                    uint64_t start, uint64_t length,
-                    std::vector<uint8_t>& out_data) const;
+  const char* debug_box_name() const override { return "Data Information"; }
 
-    int append_data(const std::vector<uint8_t>& data) {
-      auto pos = m_data_for_writing.size();
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+};
 
-      m_data_for_writing.insert(m_data_for_writing.end(),
-                                data.begin(),
-                                data.end());
 
-      return (int)pos;
-    }
+class Box_dref : public FullBox
+{
+public:
+  Box_dref()
+  {
+    set_short_type(fourcc("dref"));
+  }
 
-    Error write(StreamWriter& writer) const override;
+  std::string dump(Indent&) const override;
 
-  protected:
-    Error parse(BitstreamRange& range) override;
+  const char* debug_box_name() const override { return "Data Reference"; }
 
-    std::streampos m_data_start_pos;
+  Error write(StreamWriter& writer) const override;
 
-    std::vector<uint8_t> m_data_for_writing;
-  };
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+};
 
 
-  class Box_grpl : public Box
+class Box_url : public FullBox
+{
+public:
+  Box_url()
   {
-  public:
-    Box_grpl(const BoxHeader& hdr) : Box(hdr)
-    {}
+    set_short_type(fourcc("url "));
+    set_flags(1);
+  }
 
-    std::string dump(Indent&) const override;
+  std::string dump(Indent&) const override;
 
-  protected:
-    Error parse(BitstreamRange& range) override;
+  const char* debug_box_name() const override { return "Data Entry URL"; }
 
-    struct EntityGroup
-    {
-      BoxHeader header;
-      uint32_t group_id;
+  bool is_same_file() const { return m_location.empty(); }
 
-      std::vector<heif_item_id> entity_ids;
-    };
+  void set_location(const std::string& loc) { m_location = loc; set_flags(m_location.empty() ? 1 : 0); }
 
-    std::vector<EntityGroup> m_entity_groups;
-  };
+  void set_location_same_file() { m_location.clear(); set_flags(1); }
+
+  Error write(StreamWriter& writer) const override;
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
 
+  std::string m_location;
+};
 
-  class Box_dinf : public Box
+class Box_pixi : public FullBox
+{
+public:
+  Box_pixi()
   {
-  public:
-    Box_dinf(const BoxHeader& hdr) : Box(hdr)
-    {}
+    set_short_type(fourcc("pixi"));
+  }
 
-    std::string dump(Indent&) const override;
+  int get_num_channels() const { return (int) m_bits_per_channel.size(); }
 
-  protected:
-    Error parse(BitstreamRange& range) override;
-  };
+  int get_bits_per_channel(int channel) const { return m_bits_per_channel[channel]; }
 
+  void add_channel_bits(uint8_t c)
+  {
+    m_bits_per_channel.push_back(c);
+  }
+
+  std::string dump(Indent&) const override;
+
+  const char* debug_box_name() const override { return "Pixel Information"; }
+
+  Error write(StreamWriter& writer) const override;
+
+  [[nodiscard]] parse_error_fatality get_parse_error_fatality() const override { return parse_error_fatality::optional; }
 
-  class Box_dref : public Box
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+
+private:
+  std::vector<uint8_t> m_bits_per_channel;
+};
+
+
+class Box_pasp : public Box
+{
+public:
+  Box_pasp()
   {
-  public:
-    Box_dref(const BoxHeader& hdr) : Box(hdr)
-    {}
+    set_short_type(fourcc("pasp"));
+  }
 
-    std::string dump(Indent&) const override;
+  uint32_t hSpacing = 1;
+  uint32_t vSpacing = 1;
 
-  protected:
-    Error parse(BitstreamRange& range) override;
-  };
+  std::string dump(Indent&) const override;
+
+  const char* debug_box_name() const override { return "Pixel Aspect Ratio"; }
 
+  Error write(StreamWriter& writer) const override;
 
-  class Box_url : public Box
+  [[nodiscard]] parse_error_fatality get_parse_error_fatality() const override { return parse_error_fatality::optional; }
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+};
+
+
+class Box_lsel : public Box
+{
+public:
+  Box_lsel()
   {
-  public:
-    Box_url(const BoxHeader& hdr) : Box(hdr)
-    {}
+    set_short_type(fourcc("lsel"));
+  }
+
+  uint16_t layer_id = 0;
+
+  std::string dump(Indent&) const override;
+
+  const char* debug_box_name() const override { return "Layer Selection"; }
+
+  Error write(StreamWriter& writer) const override;
+
+  [[nodiscard]] parse_error_fatality get_parse_error_fatality() const override { return parse_error_fatality::optional; }
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+};
+
+
+class Box_clli : public Box
+{
+public:
+  Box_clli()
+  {
+    set_short_type(fourcc("clli"));
+
+    clli.max_content_light_level = 0;
+    clli.max_pic_average_light_level = 0;
+  }
+
+  heif_content_light_level clli;
+
+  std::string dump(Indent&) const override;
+
+  const char* debug_box_name() const override { return "Content Light Level Information"; }
+
+  Error write(StreamWriter& writer) const override;
+
+  [[nodiscard]] parse_error_fatality get_parse_error_fatality() const override { return parse_error_fatality::optional; }
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+};
+
+
+class Box_mdcv : public Box
+{
+public:
+  Box_mdcv();
+
+  heif_mastering_display_colour_volume mdcv;
+
+  std::string dump(Indent&) const override;
+
+  const char* debug_box_name() const override { return "Master Display Colour Volume"; }
+
+  Error write(StreamWriter& writer) const override;
+
+  [[nodiscard]] parse_error_fatality get_parse_error_fatality() const override { return parse_error_fatality::optional; }
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+};
+
+
+class Box_amve : public Box
+{
+public:
+  Box_amve();
+
+  heif_ambient_viewing_environment amve;
+
+  std::string dump(Indent&) const override;
 
-    std::string dump(Indent&) const override;
+  const char* debug_box_name() const override { return "Ambient Viewing Environment"; }
 
-  protected:
-    Error parse(BitstreamRange& range) override;
+  Error write(StreamWriter& writer) const override;
 
-    std::string m_location;
+  [[nodiscard]] parse_error_fatality get_parse_error_fatality() const override { return parse_error_fatality::optional; }
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+};
+
+
+class Box_cclv : public Box
+{
+public:
+  Box_cclv();
+
+  bool ccv_primaries_are_valid() const { return m_ccv_primaries_valid; }
+  int32_t get_ccv_primary_x0() const { return m_ccv_primaries_x[0]; }
+  int32_t get_ccv_primary_y0() const { return m_ccv_primaries_y[0]; }
+  int32_t get_ccv_primary_x1() const { return m_ccv_primaries_x[1]; }
+  int32_t get_ccv_primary_y1() const { return m_ccv_primaries_y[1]; }
+  int32_t get_ccv_primary_x2() const { return m_ccv_primaries_x[2]; }
+  int32_t get_ccv_primary_y2() const { return m_ccv_primaries_y[2]; }
+  void set_primaries(int32_t x0, int32_t y0, int32_t x1, int32_t y1, int32_t x2, int32_t y2);
+
+  bool min_luminance_is_valid() const { return m_ccv_min_luminance_value.has_value(); }
+  uint32_t get_min_luminance() const { return *m_ccv_min_luminance_value; }
+  void set_min_luminance(uint32_t luminance) { m_ccv_min_luminance_value = luminance; }
+
+  bool max_luminance_is_valid() const { return m_ccv_max_luminance_value.has_value(); }
+  uint32_t get_max_luminance() const { return *m_ccv_max_luminance_value; }
+  void set_max_luminance(uint32_t luminance) { m_ccv_max_luminance_value = luminance; }
+
+  bool avg_luminance_is_valid() const { return m_ccv_avg_luminance_value.has_value(); }
+  uint32_t get_avg_luminance() const { return *m_ccv_avg_luminance_value; }
+  void set_avg_luminance(uint32_t luminance) { m_ccv_avg_luminance_value = luminance; }
+
+  std::string dump(Indent&) const override;
+
+  // TODO const char* debug_box_name() const override { return ""; }
+
+  Error write(StreamWriter& writer) const override;
+
+  [[nodiscard]] parse_error_fatality get_parse_error_fatality() const override { return parse_error_fatality::optional; }
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+
+private:
+  bool m_ccv_primaries_valid = false;
+  int32_t m_ccv_primaries_x[3] {};
+  int32_t m_ccv_primaries_y[3] {};
+
+  std::optional<uint32_t> m_ccv_min_luminance_value;
+  std::optional<uint32_t> m_ccv_max_luminance_value;
+  std::optional<uint32_t> m_ccv_avg_luminance_value;
+};
+
+
+class Box_cmin : public FullBox
+{
+public:
+  Box_cmin()
+  {
+    set_short_type(fourcc("cmin"));
+  }
+
+  struct AbsoluteIntrinsicMatrix;
+
+  struct RelativeIntrinsicMatrix
+  {
+    double focal_length_x = 0;
+    double principal_point_x = 0;
+    double principal_point_y = 0;
+
+    bool is_anisotropic = false;
+    double focal_length_y = 0;
+    double skew = 0;
+
+    void compute_focal_length(int image_width, int image_height,
+                              double& out_focal_length_x, double& out_focal_length_y) const;
+
+    void compute_principal_point(int image_width, int image_height,
+                                 double& out_principal_point_x, double& out_principal_point_y) const;
+
+    struct AbsoluteIntrinsicMatrix to_absolute(int image_width, int image_height) const;
   };
 
-  class Box_pixi : public Box
+  struct AbsoluteIntrinsicMatrix
   {
-  public:
-    Box_pixi()
-    {
-      set_short_type(fourcc("pixi"));
-      set_is_full_box(true);
+    double focal_length_x;
+    double focal_length_y;
+    double principal_point_x;
+    double principal_point_y;
+    double skew = 0;
+
+    void apply_clap(const Box_clap* clap, int image_width, int image_height) {
+      principal_point_x -= clap->left(image_width);
+      principal_point_y -= clap->top(image_height);
     }
 
-    Box_pixi(const BoxHeader& hdr) : Box(hdr)
-    {}
+    void apply_imir(const Box_imir* imir, uint32_t image_width, uint32_t image_height) {
+      switch (imir->get_mirror_direction()) {
+        case heif_transform_mirror_direction_horizontal:
+          focal_length_x *= -1;
+          skew *= -1;
+          principal_point_x = image_width - 1 - principal_point_x;
+          break;
+        case heif_transform_mirror_direction_vertical:
+          focal_length_y *= -1;
+          principal_point_y = image_height - 1 - principal_point_y;
+          break;
+        case heif_transform_mirror_direction_invalid:
+          break;
+      }
+    }
+  };
 
-    int get_num_channels() const
-    { return (int) m_bits_per_channel.size(); }
+  std::string dump(Indent&) const override;
 
-    int get_bits_per_channel(int channel) const
-    { return m_bits_per_channel[channel]; }
+  const char* debug_box_name() const override { return "Camera Intrinsic Matrix"; }
 
-    void add_channel_bits(uint8_t c){
-      m_bits_per_channel.push_back(c);
-    }
+  RelativeIntrinsicMatrix get_intrinsic_matrix() const { return m_matrix; }
 
-    std::string dump(Indent&) const override;
+  void set_intrinsic_matrix(RelativeIntrinsicMatrix matrix);
 
-    Error write(StreamWriter& writer) const override;
+  [[nodiscard]] parse_error_fatality get_parse_error_fatality() const override { return parse_error_fatality::optional; }
 
-  protected:
-    Error parse(BitstreamRange& range) override;
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
 
-  private:
-    std::vector<uint8_t> m_bits_per_channel;
-  };
+  Error write(StreamWriter& writer) const override;
 
+private:
+  RelativeIntrinsicMatrix m_matrix;
+
+  uint32_t m_denominatorShift = 0;
+  uint32_t m_skewDenominatorShift = 0;
+};
+
+
+class Box_cmex : public FullBox
+{
+public:
+  Box_cmex()
+  {
+    set_short_type(fourcc("cmex"));
+  }
 
-  class color_profile
+  struct ExtrinsicMatrix
   {
-  public:
-    virtual ~color_profile()
-    {}
+    // in micrometers (um)
+    int32_t pos_x = 0;
+    int32_t pos_y = 0;
+    int32_t pos_z = 0;
 
-    virtual uint32_t get_type() const = 0;
+    bool rotation_as_quaternions = true;
+    bool orientation_is_32bit = false;
 
-    virtual std::string dump(Indent&) const = 0;
+    double quaternion_x = 0;
+    double quaternion_y = 0;
+    double quaternion_z = 0;
+    double quaternion_w = 1.0;
 
-    virtual Error write(StreamWriter& writer) const = 0;
+    // rotation angle in degrees
+    double rotation_yaw = 0;   //  [-180 ; 180)
+    double rotation_pitch = 0; //  [-90 ; 90]
+    double rotation_roll = 0;  //  [-180 ; 180)
+
+    uint32_t world_coordinate_system_id = 0;
+
+    // Returns rotation matrix in row-major order.
+    std::array<double,9> calculate_rotation_matrix() const;
   };
 
-  class color_profile_raw : public color_profile
-  {
-  public:
-    color_profile_raw(uint32_t type, std::vector<uint8_t> data)
-        : m_type(type), m_data(data)
-    {}
+  std::string dump(Indent&) const override;
+
+  const char* debug_box_name() const override { return "Camera Extrinsic Matrix"; }
+
+  ExtrinsicMatrix get_extrinsic_matrix() const { return m_matrix; }
+
+  Error set_extrinsic_matrix(ExtrinsicMatrix matrix);
 
-    uint32_t get_type() const override
-    { return m_type; }
+  [[nodiscard]] parse_error_fatality get_parse_error_fatality() const override { return parse_error_fatality::optional; }
 
-    std::vector<uint8_t> get_data() const
-    { return m_data; }
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
 
-    std::string dump(Indent&) const override;
+  Error write(StreamWriter& writer) const override;
 
-    Error write(StreamWriter& writer) const override;
+private:
+  ExtrinsicMatrix m_matrix;
 
-  private:
-    uint32_t m_type;
-    std::vector<uint8_t> m_data;
+  bool m_has_pos_x = false;
+  bool m_has_pos_y = false;
+  bool m_has_pos_z = false;
+  bool m_has_orientation = false;
+  bool m_has_world_coordinate_system_id = false;
+
+  enum Flags
+  {
+    pos_x_present = 0x01,
+    pos_y_present = 0x02,
+    pos_z_present = 0x04,
+    orientation_present = 0x08,
+    rot_large_field_size = 0x10,
+    id_present = 0x20
   };
+};
+
+
+
 
+/**
+ * User Description property.
+ *
+ * Permits the association of items or entity groups with a user-defined name, description and tags;
+ * there may be multiple udes properties, each with a different language code.
+ *
+ * See ISO/IEC 23008-12:2022(E) Section 6.5.20.
+ */
+class Box_udes : public FullBox
+{
+public:
+  Box_udes()
+  {
+    set_short_type(fourcc("udes"));
+  }
 
-  class color_profile_nclx : public color_profile
+  std::string dump(Indent&) const override;
+
+  const char* debug_box_name() const override { return "User Description"; }
+
+  Error write(StreamWriter& writer) const override;
+
+  /**
+   * Language tag.
+   *
+   * An RFC 5646 compliant language identifier for the language of the text contained in the other properties.
+   * Examples: "en-AU", "de-DE", or "zh-CN“.
+   * When is empty, the language is unknown or not undefined.
+   */
+  std::string get_lang() const { return m_lang; }
+
+  /**
+   * Set the language tag.
+   *
+   * An RFC 5646 compliant language identifier for the language of the text contained in the other properties.
+   * Examples: "en-AU", "de-DE", or "zh-CN“.
+   */
+  void set_lang(const std::string lang) { m_lang = lang; }
+
+  /**
+   * Name.
+   *
+   * Human readable name for the item or group being described.
+   * May be empty, indicating no name is applicable.
+   */
+  std::string get_name() const { return m_name; }
+
+  /**
+  * Set the name.
+  *
+  * Human readable name for the item or group being described.
+  */
+  void set_name(const std::string name) { m_name = name; }
+
+  /**
+   * Description.
+   *
+   * Human readable description for the item or group.
+   * May be empty, indicating no description has been provided.
+   */
+  std::string get_description() const { return m_description; }
+
+  /**
+   * Set the description.
+   *
+   * Human readable description for the item or group.
+   */
+  void set_description(const std::string description) { m_description = description; }
+
+  /**
+   * Tags.
+   *
+   * Comma separated user defined tags applicable to the item or group.
+   * May be empty, indicating no tags have been assigned.
+   */
+  std::string get_tags() const { return m_tags; }
+
+  /**
+   * Set the tags.
+   *
+   * Comma separated user defined tags applicable to the item or group.
+   */
+  void set_tags(const std::string tags) { m_tags = tags; }
+
+  [[nodiscard]] parse_error_fatality get_parse_error_fatality() const override { return parse_error_fatality::optional; }
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+
+private:
+  std::string m_lang;
+  std::string m_name;
+  std::string m_description;
+  std::string m_tags;
+};
+
+
+void initialize_heif_tai_clock_info(heif_tai_clock_info* taic);
+void initialize_heif_tai_timestamp_packet(heif_tai_timestamp_packet* itai);
+
+
+class Box_taic : public FullBox
+{
+public:
+  Box_taic()
   {
-  public:
-    color_profile_nclx()
-    { set_default(); }
+    set_short_type(fourcc("taic"));
+    initialize_heif_tai_clock_info(&m_info);
+  }
 
-    uint32_t get_type() const override
-    { return fourcc("nclx"); }
+  static std::string dump(const heif_tai_clock_info& info, Indent&);
+
+  std::string dump(Indent&) const override;
+
+  const char* debug_box_name() const override { return "TAI Clock Information"; }
+
+  Error write(StreamWriter& writer) const override;
+
+  /**
+   * time_uncertainty.
+   * 
+   * The standard deviation measurement uncertainty in nanoseconds
+   * for the timestamp generation process. 
+   */
+  void set_time_uncertainty(uint64_t time_uncertainty) { m_info.time_uncertainty = time_uncertainty;}
+  
+  /**
+   * clock_resolution.
+   * 
+   * Specifies the resolution of the receptor clock in nanoseconds.
+   * For example, a microsecond clock has a clock_resolution of 1000.
+   */
+  void set_clock_resolution(uint32_t clock_resolution) { m_info.clock_resolution = clock_resolution; }
+  
+  /**
+   * clock_drift_rate.
+   * 
+   * The difference between the synchronized and unsynchronized
+   * time, over a period of one second. 
+   */
+  void set_clock_drift_rate(int32_t clock_drift_rate) { m_info.clock_drift_rate = clock_drift_rate; }
+  
+  /**
+   * clock_type.
+   * 
+   * 0 = Clock type is unknown
+   * 1 = The clock does not synchronize to an atomic source of absolute TAI time
+   * 2 = The clock can synchronize to an atomic source of absolute TAI time
+   */
+  void set_clock_type(uint8_t clock_type) { m_info.clock_type = clock_type; }
+
+  uint64_t get_time_uncertainty() const { return m_info.time_uncertainty; }
+  
+  uint32_t get_clock_resolution() const { return m_info.clock_resolution; }
+  
+  int32_t get_clock_drift_rate() const { return m_info.clock_drift_rate; }
+  
+  uint8_t get_clock_type() const { return m_info.clock_type; }
+
+  void set_from_tai_clock_info(const heif_tai_clock_info* info) {
+    heif_tai_clock_info_copy(&m_info, info);
+  }
 
-    std::string dump(Indent&) const override;
+  const heif_tai_clock_info* get_tai_clock_info() const
+  {
+    return &m_info;
+  }
 
-    Error parse(BitstreamRange& range);
+  bool operator==(const Box& other) const override;
 
-    Error write(StreamWriter& writer) const override;
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
 
-    uint16_t get_colour_primaries() const
-    { return m_colour_primaries; }
+private:
+  heif_tai_clock_info m_info;
+};
 
-    uint16_t get_transfer_characteristics() const
-    { return m_transfer_characteristics; }
+bool operator==(const heif_tai_clock_info& a,
+                const heif_tai_clock_info& b);
 
-    uint16_t get_matrix_coefficients() const
-    { return m_matrix_coefficients; }
 
-    bool get_full_range_flag() const
-    { return m_full_range_flag; }
+class Box_itai : public FullBox
+{
+public:
+  Box_itai()
+  {
+    set_short_type(fourcc("itai"));
+    initialize_heif_tai_timestamp_packet(&m_timestamp);
+  }
 
-    void set_colour_primaries(uint16_t primaries)
-    { m_colour_primaries = primaries; }
+  std::string dump(Indent&) const override;
 
-    void set_transfer_characteristics(uint16_t characteristics)
-    { m_transfer_characteristics = characteristics; }
+  const char* debug_box_name() const override { return "Item TAI Timestamp"; }
 
-    void set_matrix_coefficients(uint16_t coefficients)
-    { m_matrix_coefficients = coefficients; }
+  Error write(StreamWriter& writer) const override;
 
-    void set_full_range_flag(bool full_range)
-    { m_full_range_flag = full_range; }
+  static std::vector<uint8_t> encode_tai_to_bitstream(const heif_tai_timestamp_packet*);
 
-    void set_default();
+  static Result<heif_tai_timestamp_packet> decode_tai_from_vector(const std::vector<uint8_t>&);
 
-    void set_undefined();
+  /**
+   * The number of nanoseconds since the TAI epoch of 1958-01-01T00:00:00.0Z.
+   */
+  void set_tai_timestamp(uint64_t timestamp) { m_timestamp.tai_timestamp = timestamp; }
 
-    Error get_nclx_color_profile(struct heif_color_profile_nclx** out_data) const;
+  /**
+  * synchronization_state (0=unsynchronized, 1=synchronized)
+  */
+  void set_synchronization_state(bool state) { m_timestamp.synchronization_state = state; }
 
-    static struct heif_color_profile_nclx* alloc_nclx_color_profile();
+  /**
+  * timestamp_generation_failure (0=generated, 1=failed)
+  */
+  void set_timestamp_generation_failure(bool failure) { m_timestamp.timestamp_generation_failure = failure; }
 
-    static void free_nclx_color_profile(struct heif_color_profile_nclx* profile);
+  /**
+   * timestamp_is_modified (0=original 1=modified)
+   */
+  void set_timestamp_is_modified(bool is_modified) { m_timestamp.timestamp_is_modified = is_modified; }
 
-    void set_from_heif_color_profile_nclx(const struct heif_color_profile_nclx* nclx);
+  uint64_t get_tai_timestamp() const { return m_timestamp.tai_timestamp; }
 
-  private:
-    uint16_t m_colour_primaries = 0;
-    uint16_t m_transfer_characteristics = 0;
-    uint16_t m_matrix_coefficients = 0;
-    bool m_full_range_flag = true;
-  };
+  bool get_synchronization_state() const { return m_timestamp.synchronization_state; }
 
+  bool get_timestamp_generation_failure() const { return m_timestamp.timestamp_generation_failure; }
+
+  bool get_timestamp_is_modified() const { return m_timestamp.timestamp_is_modified; }
+
+  void set_from_tai_timestamp_packet(const heif_tai_timestamp_packet* tai) {
+    heif_tai_timestamp_packet_copy(&m_timestamp, tai);
+  }
 
-  class Box_colr : public Box
+  const heif_tai_timestamp_packet* get_tai_timestamp_packet() const
   {
-  public:
-    Box_colr()
-    {
-      set_short_type(fourcc("colr"));
-      set_is_full_box(false);
-    }
+    return &m_timestamp;
+  }
 
-    Box_colr(const BoxHeader& hdr) : Box(hdr)
-    {}
+  bool operator==(const Box& other) const override;
 
-    std::string dump(Indent&) const override;
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
 
-    uint32_t get_color_profile_type() const
-    { return m_color_profile->get_type(); }
+private:
+  heif_tai_timestamp_packet m_timestamp;
+};
 
-    std::shared_ptr<const color_profile> get_color_profile() const
-    { return m_color_profile; }
+class Box_gimi_content_id : public Box
+{
+public:
+  Box_gimi_content_id()
+  {
+    set_uuid_type(std::vector<uint8_t>{0x26, 0x1e, 0xf3, 0x74, 0x1d, 0x97, 0x5b, 0xba, 0xac, 0xbd, 0x9d, 0x2c, 0x8e, 0xa7, 0x35, 0x22});
+  }
 
-    void set_color_profile(std::shared_ptr<const color_profile> prof)
-    { m_color_profile = prof; }
+  bool is_essential() const override { return false; }
 
+  bool is_transformative_property() const override { return false; }
 
-    Error write(StreamWriter& writer) const override;
+  std::string dump(Indent&) const override;
 
-  protected:
-    Error parse(BitstreamRange& range) override;
+  const char* debug_box_name() const override { return "GIMI Content ID"; }
 
-  private:
-    std::shared_ptr<const color_profile> m_color_profile;
-  };
+  std::string get_content_id() const { return m_content_id; }
 
-}
+  void set_content_id(const std::string& id) { m_content_id = id; }
+
+  [[nodiscard]] parse_error_fatality get_parse_error_fatality() const override { return parse_error_fatality::ignorable; }
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+
+  Error write(StreamWriter& writer) const override;
+
+private:
+  std::string m_content_id;
+};
+
+
+bool operator==(const heif_tai_timestamp_packet& a,
+                const heif_tai_timestamp_packet& b);
+
+
+/**
+ * Extended language property.
+ *
+ * Permits the association of language information with an item.
+ *
+ * See ISO/IEC 23008-12:2025(E) Section 6.10.2.2 and ISO/IEC 14496-12:2022(E) Section 8.4.6.
+ */
+class Box_elng : public FullBox
+{
+public:
+  Box_elng()
+  {
+    set_short_type(fourcc("elng"));
+  }
+
+  std::string dump(Indent&) const override;
+
+  const char* debug_box_name() const override { return "Extended language"; }
+
+  Error write(StreamWriter& writer) const override;
+
+  /**
+   * Language.
+   *
+   * An RFC 5646 (IETF BCP 47) compliant language identifier for the language of the text.
+   * Examples: "en-AU", "de-DE", or "zh-CN“.
+   */
+  std::string get_extended_language() const { return m_lang; }
+
+  /**
+   * Set the language.
+   *
+   * An RFC 5646 (IETF BCP 47) compliant language identifier for the language of the text.
+   * Examples: "en-AU", "de-DE", or "zh-CN“.
+   */
+  void set_lang(const std::string lang) { m_lang = lang; }
+
+  [[nodiscard]] parse_error_fatality get_parse_error_fatality() const override { return parse_error_fatality::optional; }
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+
+private:
+  std::string m_lang;
+};
 
 #endif
diff --git a/libheif/brands.cc b/libheif/brands.cc
new file mode 100644
index 0000000000..cf3486ac11
--- /dev/null
+++ b/libheif/brands.cc
@@ -0,0 +1,176 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2025 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "brands.h"
+#include "file.h"
+#include "sequences/track_visual.h"
+#include <utility>
+
+
+static bool check_mif1(const HeifContext* ctx)
+{
+  auto file = ctx->get_heif_file();
+
+  auto meta = file->get_meta_box();
+  if (!meta || meta->get_version() != 0) {
+    return false;
+  }
+
+  auto hdlr = meta->get_child_box<Box_hdlr>();
+  if (!hdlr || hdlr->get_version() != 0) {
+    return false;
+  }
+
+  auto iloc = meta->get_child_box<Box_iloc>();
+  if (!iloc || iloc->get_version() > 2) {
+    return false;
+  }
+
+  auto iinf = meta->get_child_box<Box_iinf>();
+  if (!iinf || iinf->get_version() > 1) {
+    return false;
+  }
+
+  auto infe = iinf->get_child_box<Box_infe>();
+  if (!infe || infe->get_version() < 2 || infe->get_version() > 3) {
+    return false;
+  }
+
+  auto pitm = meta->get_child_box<Box_pitm>();
+  if (!pitm || pitm->get_version() > 1) {
+    return false;
+  }
+
+  auto iprp = meta->get_child_box<Box_iprp>();
+  if (!iprp) {
+    return false;
+  }
+
+  return true;
+}
+
+
+std::vector<std::shared_ptr<const ImageItem>> get_primary_and_alternative_images(const HeifContext* ctx)
+{
+  auto img = ctx->get_primary_image(false);
+  if (img) {
+    return {std::move(img)};
+  }
+  else {
+    return {};
+  }
+}
+
+
+std::vector<heif_brand2> compute_compatible_brands(const HeifContext* ctx, heif_brand2* out_main_brand)
+{
+  std::vector<heif_brand2> compatible_brands;
+
+  heif_brand2 dummy;
+  if (out_main_brand == nullptr) {
+    out_main_brand = &dummy; // so that we do not have to check for NULL out_main_brand in the following
+  }
+
+  *out_main_brand = 0;
+
+  // --- "mif" brands
+
+  bool is_mif1 = check_mif1(ctx);
+
+  if (is_mif1) {
+    compatible_brands.push_back(heif_brand2_mif1);
+    *out_main_brand = heif_brand2_mif1;
+  }
+
+  bool is_structural_image = is_mif1;
+
+
+  // --- image brand
+
+  std::vector<std::shared_ptr<const ImageItem>> images = get_primary_and_alternative_images(ctx);
+
+  bool miaf_compatible = true;
+
+  for (auto& img : images) {
+    heif_brand2 brand = img->get_compatible_brand();
+    if (brand != 0 &&
+        is_structural_image &&
+        std::find(compatible_brands.begin(),
+                  compatible_brands.end(),
+                  brand) == compatible_brands.end()) {
+      compatible_brands.push_back(brand);
+    }
+
+    if (!img->is_miaf_compatible()) {
+      miaf_compatible = false;
+    }
+  }
+
+  // --- "miaf"
+
+  if (miaf_compatible && is_structural_image) {
+    compatible_brands.push_back(heif_brand2_miaf);
+  }
+
+
+  // --- main brand is first image brand
+
+  if (!images.empty()) {
+    heif_brand2 brand = images[0]->get_compatible_brand();
+    if (brand != 0) {
+      *out_main_brand = brand;
+    }
+  }
+
+  // --- --- sequences
+
+  if (ctx->has_sequence()) {
+    compatible_brands.push_back(heif_brand2_msf1);
+    compatible_brands.push_back(heif_brand2_isom);
+
+    auto track_result = ctx->get_track(0);
+    assert(track_result);
+
+    std::shared_ptr<const Track> track = *track_result;
+    std::shared_ptr<const Track_Visual> visual_track = std::dynamic_pointer_cast<const Track_Visual>(track);
+
+    heif_brand2 track_brand = visual_track->get_compatible_brand();
+    if (track_brand != 0) {
+      compatible_brands.push_back(track_brand);
+
+      // overwrite any image brand
+      *out_main_brand = track_brand;
+    }
+
+    // if we don't have a track brand, use at least the sequence structural brand
+    if (*out_main_brand == 0) {
+      *out_main_brand = heif_brand2_msf1;
+    }
+  }
+
+  // --- "unif" brand
+
+  if (ctx->get_unif()) {
+    compatible_brands.push_back(heif_brand2_unif);
+  }
+
+  return compatible_brands;
+}
+
diff --git a/libheif/brands.h b/libheif/brands.h
new file mode 100644
index 0000000000..38cba880b6
--- /dev/null
+++ b/libheif/brands.h
@@ -0,0 +1,32 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2025 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_BRANDS_H
+#define LIBHEIF_BRANDS_H
+
+#include "context.h"
+#include "error.h"
+
+#include <memory>
+#include <vector>
+
+std::vector<heif_brand2> compute_compatible_brands(const HeifContext* ctx, heif_brand2* out_main_brand);
+
+#endif
diff --git a/libheif/codecs/avc_boxes.cc b/libheif/codecs/avc_boxes.cc
new file mode 100644
index 0000000000..ddd945f276
--- /dev/null
+++ b/libheif/codecs/avc_boxes.cc
@@ -0,0 +1,461 @@
+/*
+ * HEIF AVC codec.
+ * Copyright (c) 2023 Brad Hards <bradh@frogmouth.net>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "avc_boxes.h"
+#include <cstdint>
+#include <iomanip>
+#include <iostream>
+#include <vector>
+#include "file.h"
+#include "context.h"
+#include "avc_dec.h"
+#include "hevc_boxes.h"
+#include <utility>
+#include <set>
+
+
+Error Box_avcC::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  m_configuration.configuration_version = range.read8();
+  m_configuration.AVCProfileIndication = range.read8();
+  m_configuration.profile_compatibility = range.read8();
+  m_configuration.AVCLevelIndication = range.read8();
+  uint8_t lengthSizeMinusOneWithReserved = range.read8();
+  m_configuration.lengthSize =
+      (lengthSizeMinusOneWithReserved & 0b00000011) + 1;
+
+  uint8_t numOfSequenceParameterSets = (range.read8() & 0b00011111);
+  for (int i = 0; i < numOfSequenceParameterSets; i++) {
+    uint16_t sequenceParameterSetLength = range.read16();
+    std::vector<uint8_t> sps(sequenceParameterSetLength);
+    range.read(sps.data(), sps.size());
+    m_sps.push_back(sps);
+  }
+
+  uint8_t numOfPictureParameterSets = range.read8();
+  for (int i = 0; i < numOfPictureParameterSets; i++) {
+    uint16_t pictureParameterSetLength = range.read16();
+    std::vector<uint8_t> pps(pictureParameterSetLength);
+    range.read(pps.data(), pps.size());
+    m_pps.push_back(pps);
+  }
+
+  // See ISO/IEC 14496-15 2017 Section 5.3.3.1.2
+  if (range.get_remaining_bytes() > 0) {
+    if ((m_configuration.AVCProfileIndication != 66) &&
+        (m_configuration.AVCProfileIndication != 77) &&
+        (m_configuration.AVCProfileIndication != 88)) {
+      m_configuration.chroma_format = (heif_chroma) (range.read8() & 0b00000011);
+      m_configuration.bit_depth_luma = 8 + (range.read8() & 0b00000111);
+      m_configuration.bit_depth_chroma = 8 + (range.read8() & 0b00000111);
+      uint8_t numOfSequenceParameterSetExt = range.read8();
+      for (int i = 0; i < numOfSequenceParameterSetExt; i++) {
+        uint16_t sequenceParameterSetExtLength = range.read16();
+        std::vector<uint8_t> sps_ext(sequenceParameterSetExtLength);
+        range.read(sps_ext.data(), sps_ext.size());
+        m_sps_ext.push_back(sps_ext);
+      }
+    }
+  }
+
+  return range.get_error();
+}
+
+Error Box_avcC::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  writer.write8(m_configuration.configuration_version);
+  writer.write8(m_configuration.AVCProfileIndication);
+  writer.write8(m_configuration.profile_compatibility);
+  writer.write8(m_configuration.AVCLevelIndication);
+  uint8_t lengthSizeMinusOneWithReserved = 0b11111100 | ((m_configuration.lengthSize - 1) & 0b11);
+  writer.write8(lengthSizeMinusOneWithReserved);
+
+  if (m_sps.size() > 0b00011111) {
+    return {
+      heif_error_Encoding_error,
+      heif_suberror_Unspecified,
+      "Cannot write more than 31 PPS into avcC box."
+    };
+  }
+
+  uint8_t numSpsWithReserved = 0b11100000 | (m_sps.size() & 0b00011111);
+  writer.write8(numSpsWithReserved);
+  for (const auto& sps : m_sps) {
+    if (sps.size() > 0xFFFF) {
+      return {
+        heif_error_Encoding_error,
+        heif_suberror_Unspecified,
+        "Cannot write SPS larger than 65535 bytes into avcC box."
+      };
+    }
+    writer.write16((uint16_t) sps.size());
+    writer.write(sps);
+  }
+
+  if (m_pps.size() > 0xFF) {
+    return {
+      heif_error_Encoding_error,
+      heif_suberror_Unspecified,
+      "Cannot write more than 255 PPS into avcC box."
+    };
+  }
+
+  writer.write8(m_pps.size() & 0xFF);
+  for (const auto& pps : m_pps) {
+    if (pps.size() > 0xFFFF) {
+      return {
+        heif_error_Encoding_error,
+        heif_suberror_Unspecified,
+        "Cannot write PPS larger than 65535 bytes into avcC box."
+      };
+    }
+    writer.write16((uint16_t) pps.size());
+    writer.write(pps);
+  }
+
+  if ((m_configuration.AVCProfileIndication != 66) &&
+      (m_configuration.AVCProfileIndication != 77) &&
+      (m_configuration.AVCProfileIndication != 88)) {
+    writer.write8(m_configuration.chroma_format);
+    writer.write8(m_configuration.bit_depth_luma - 8);
+    writer.write8(m_configuration.bit_depth_chroma - 8);
+
+    if (m_sps_ext.size() > 0xFF) {
+      return {
+        heif_error_Encoding_error,
+        heif_suberror_Unspecified,
+        "Cannot write more than 255 SPS-Ext into avcC box."
+      };
+    }
+
+    writer.write8(m_sps_ext.size() & 0xFF);
+    for (const auto& spsext : m_sps_ext) {
+      if (spsext.size() > 0xFFFF) {
+        return {
+          heif_error_Encoding_error,
+          heif_suberror_Unspecified,
+          "Cannot write SPS-Ext larger than 65535 bytes into avcC box."
+        };
+      }
+      writer.write16((uint16_t) spsext.size());
+      writer.write(spsext);
+    }
+  }
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+std::string Box_avcC::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
+  sstr << indent << "configuration_version: " << ((int) m_configuration.configuration_version) << "\n"
+      << indent << "AVCProfileIndication: " << ((int) m_configuration.AVCProfileIndication) << " (" << profileIndicationAsText() << ")\n"
+      << indent << "profile_compatibility: " << ((int) m_configuration.profile_compatibility) << "\n"
+      << indent << "AVCLevelIndication: " << ((int) m_configuration.AVCLevelIndication) << "\n"
+      << indent << "Chroma format: ";
+
+  switch (m_configuration.chroma_format) {
+    case heif_chroma_monochrome:
+      sstr << "4:0:0\n";
+      break;
+    case heif_chroma_420:
+      sstr << "4:2:0\n";
+      break;
+    case heif_chroma_422:
+      sstr << "4:2:2\n";
+      break;
+    case heif_chroma_444:
+      sstr << "4:4:4\n";
+      break;
+    default:
+      sstr << "unsupported\n";
+      break;
+  }
+
+  sstr << indent << "Bit depth luma: " << ((int) m_configuration.bit_depth_luma) << "\n"
+      << indent << "Bit depth chroma: " << ((int) m_configuration.bit_depth_chroma) << "\n";
+
+  for (const auto& sps : m_sps) {
+    sstr << indent << "SPS: ";
+    for (uint8_t b : sps) {
+      sstr << std::setfill('0') << std::setw(2) << std::hex << ((int) b) << " ";
+    }
+    sstr << "\n";
+    sstr << std::dec;
+  }
+
+  for (const auto& spsext : m_sps_ext) {
+    sstr << indent << "SPS-EXT: ";
+    for (uint8_t b : spsext) {
+      sstr << std::setfill('0') << std::setw(2) << std::hex << ((int) b) << " ";
+    }
+    sstr << "\n";
+    sstr << std::dec;
+  }
+
+  for (const auto& pps : m_pps) {
+    sstr << indent << "PPS: ";
+    for (uint8_t b : pps) {
+      sstr << std::setfill('0') << std::setw(2) << std::hex << ((int) b) << " ";
+    }
+    sstr << "\n";
+    sstr << std::dec;
+  }
+
+  return sstr.str();
+}
+
+std::string Box_avcC::profileIndicationAsText() const
+{
+  // See ISO/IEC 14496-10:2022 Annex A
+  switch (m_configuration.AVCProfileIndication) {
+    case 44:
+      return "CALVC 4:4:4";
+    case 66:
+      return "Constrained Baseline";
+    case 77:
+      return "Main";
+    case 88:
+      return "Extended";
+    case 100:
+      return "High variant";
+    case 110:
+      return "High 10";
+    case 122:
+      return "High 4:2:2";
+    case 244:
+      return "High 4:4:4";
+    default:
+      return "Unknown";
+  }
+}
+
+
+void Box_avcC::get_header_nals(std::vector<uint8_t>& data) const
+{
+  for (const auto& sps : m_sps) {
+    data.push_back((sps.size() >> 24) & 0xFF);
+    data.push_back((sps.size() >> 16) & 0xFF);
+    data.push_back((sps.size() >> 8) & 0xFF);
+    data.push_back((sps.size() >> 0) & 0xFF);
+
+    data.insert(data.end(), sps.begin(), sps.end());
+  }
+
+  for (const auto& spsext : m_sps_ext) {
+    data.push_back((spsext.size() >> 24) & 0xFF);
+    data.push_back((spsext.size() >> 16) & 0xFF);
+    data.push_back((spsext.size() >> 8) & 0xFF);
+    data.push_back((spsext.size() >> 0) & 0xFF);
+
+    data.insert(data.end(), spsext.begin(), spsext.end());
+  }
+
+  for (const auto& pps : m_pps) {
+    data.push_back((pps.size() >> 24) & 0xFF);
+    data.push_back((pps.size() >> 16) & 0xFF);
+    data.push_back((pps.size() >> 8) & 0xFF);
+    data.push_back((pps.size() >> 0) & 0xFF);
+
+    data.insert(data.end(), pps.begin(), pps.end());
+  }
+}
+
+
+void Box_avcC::append_sps_nal(const uint8_t* data, size_t size)
+{
+  std::vector<uint8_t> vec(data, data + size);
+  m_sps.emplace_back(std::move(vec));
+}
+
+void Box_avcC::append_sps_ext_nal(const uint8_t* data, size_t size)
+{
+  std::vector<uint8_t> vec(data, data + size);
+  m_sps_ext.emplace_back(std::move(vec));
+}
+
+void Box_avcC::append_pps_nal(const uint8_t* data, size_t size)
+{
+  std::vector<uint8_t> vec(data, data + size);
+  m_pps.emplace_back(std::move(vec));
+}
+
+void skip_scaling_list(BitReader& reader, int sizeOfScalingList)
+{
+  int lastScale = 8;
+  int nextScale = 8;
+
+  // TODO: it seems that this can be simplified by exiting the loop
+  //       as soon as nextScale==0.
+
+#if 0
+  // original version
+  for (int j = 0; j < sizeOfScalingList; j++) {
+    if (nextScale != 0) {
+      int delta_scale;
+      reader.get_svlc(&delta_scale);
+      nextScale = (lastScale + delta_scale + 256) % 256;
+    }
+
+    lastScale = (nextScale == 0) ? lastScale : nextScale;
+  }
+#else
+  // fast version
+  for (int j = 0; j < sizeOfScalingList; j++) {
+    int delta_scale;
+    reader.get_svlc(&delta_scale);
+    nextScale = (lastScale + delta_scale + 256) % 256;
+
+    if (nextScale == 0) {
+      break;
+    }
+
+    lastScale = nextScale;
+  }
+#endif
+}
+
+
+Error parse_sps_for_avcC_configuration(const uint8_t* sps, size_t size,
+                                       Box_avcC::configuration* config,
+                                       int* width, int* height)
+{
+  // remove start-code emulation bytes from SPS header stream
+
+  std::vector<uint8_t> sps_no_emul = remove_start_code_emulation(sps, size);
+
+  sps = sps_no_emul.data();
+  size = sps_no_emul.size();
+
+
+  BitReader reader(sps, (int) size);
+
+  // skip NAL header
+  reader.skip_bits(8);
+
+  config->configuration_version = 1;
+  config->AVCProfileIndication = reader.get_bits8(8);
+  config->profile_compatibility = reader.get_bits8(8);
+  config->AVCLevelIndication = reader.get_bits8(8);
+  config->lengthSize = 4;
+
+  int value;
+  reader.get_uvlc(&value); // SPS ID
+
+  Error invalidUVLC{
+    heif_error_Invalid_input,
+    heif_suberror_Unspecified,
+    "Invalid variable length code in AVC SPS header"
+  };
+
+  if (std::set<int>{100, 110, 122, 244, 44, 83, 86}.contains(config->AVCProfileIndication)) {
+    if (!reader.get_uvlc(&value)) {
+      return invalidUVLC;
+    }
+
+    config->chroma_format = (heif_chroma) value;
+    if (config->chroma_format == heif_chroma_444) {
+      reader.skip_bits(1);
+    }
+
+    if (!reader.get_uvlc(&value)) {
+      return invalidUVLC;
+    }
+    config->bit_depth_luma = static_cast<uint8_t>(8 + value);
+
+    if (!reader.get_uvlc(&value)) {
+      return invalidUVLC;
+    }
+    config->bit_depth_chroma = static_cast<uint8_t>(8 + value);
+
+    reader.skip_bits(1);
+    int seq_scaling_matrix_present_flag = reader.get_bits(1);
+    if (seq_scaling_matrix_present_flag) {
+      for (int i = 0; i < ((config->chroma_format != heif_chroma_444) ? 8 : 12); i++) {
+        int scaling_list_present_flag = reader.get_bits(1);
+        if (scaling_list_present_flag) {
+          if (i < 6) {
+            skip_scaling_list(reader, 16);
+          }
+          else {
+            skip_scaling_list(reader, 64);
+          }
+        }
+      }
+    }
+  }
+  else {
+    config->chroma_format = heif_chroma_420;
+    config->bit_depth_luma = 8;
+    config->bit_depth_chroma = 8;
+  }
+
+  reader.get_uvlc(&value); // log2_max_frame_num_minus4
+  int pic_order_cnt_type;
+  reader.get_uvlc(&pic_order_cnt_type);
+  if (pic_order_cnt_type == 0) {
+    reader.get_uvlc(&value);
+  }
+  else if (pic_order_cnt_type == 1) {
+    reader.get_bits(1);
+    reader.get_svlc(&value);
+    reader.get_svlc(&value);
+    int num_ref_franes_in_pic_order_cnt_cycle;
+    reader.get_uvlc(&num_ref_franes_in_pic_order_cnt_cycle);
+    for (int i = 0; i < num_ref_franes_in_pic_order_cnt_cycle; i++) {
+      reader.get_uvlc(&value);
+    }
+  }
+
+  reader.get_uvlc(&value); // num_ref_frames
+  reader.skip_bits(1);
+
+  int pic_width_in_mbs_minus1;
+  int pic_height_in_mbs_minus1;
+  reader.get_uvlc(&pic_width_in_mbs_minus1);
+  reader.get_uvlc(&pic_height_in_mbs_minus1);
+
+  *width = (pic_width_in_mbs_minus1 + 1) * 16;
+  *height = (pic_height_in_mbs_minus1 + 1) * 16;
+
+  uint32_t frame_mbs_only_flag = reader.get_bits(1);
+  if (!frame_mbs_only_flag) {
+    reader.skip_bits(1);
+  }
+  reader.skip_bits(1);
+  uint32_t frame_cropping_flag = reader.get_bits(1);
+  if (frame_cropping_flag) {
+    int left, right, top, bottom;
+    reader.get_uvlc(&left);
+    reader.get_uvlc(&right);
+    reader.get_uvlc(&top);
+    reader.get_uvlc(&bottom);
+
+    *width -= left + right;
+    *height -= top + bottom;
+  }
+
+  return {};
+}
diff --git a/libheif/codecs/avc_boxes.h b/libheif/codecs/avc_boxes.h
new file mode 100644
index 0000000000..22c60177cd
--- /dev/null
+++ b/libheif/codecs/avc_boxes.h
@@ -0,0 +1,120 @@
+/*
+ * HEIF AVC codec.
+ * Copyright (c) 2023 Brad Hards <bradh@frogmouth.net>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef HEIF_AVC_BOXES_H
+#define HEIF_AVC_BOXES_H
+
+#include "box.h"
+#include "error.h"
+#include <cstdint>
+#include <vector>
+#include <string>
+#include <memory>
+#include "image-items/image_item.h"
+#include "sequences/seq_boxes.h"
+
+
+class Box_avcC : public Box {
+public:
+  Box_avcC() { set_short_type(fourcc("avcC")); }
+
+  bool is_essential() const override { return true; }
+
+  struct configuration {
+    uint8_t configuration_version = 0;
+    uint8_t AVCProfileIndication = 0; // profile_idc
+    uint8_t profile_compatibility = 0; // constraint set flags
+    uint8_t AVCLevelIndication = 0; // level_idc
+    uint8_t lengthSize = 0; // length of NAL size field. Must be one of: 1,2,4
+    heif_chroma chroma_format = heif_chroma_420; // Note: avcC integer value can be cast to heif_chroma enum
+    uint8_t bit_depth_luma = 8;
+    uint8_t bit_depth_chroma = 8;
+  };
+
+  void set_configuration(const configuration& config)
+  {
+    m_configuration = config;
+  }
+
+  const configuration& get_configuration() const
+  {
+    return m_configuration;
+  }
+
+  configuration& get_configuration()
+  {
+    return m_configuration;
+  }
+
+  const std::vector< std::vector<uint8_t> > getSequenceParameterSets() const
+  {
+    return m_sps;
+  }
+
+  const std::vector< std::vector<uint8_t> > getPictureParameterSets() const
+  {
+    return m_pps;
+  }
+
+  const std::vector< std::vector<uint8_t> > getSequenceParameterSetExt() const
+  {
+    return m_sps_ext;
+  }
+
+  void get_header_nals(std::vector<uint8_t>& data) const;
+
+  void append_sps_nal(const uint8_t* data, size_t size);
+
+  void append_sps_ext_nal(const uint8_t* data, size_t size);
+
+  void append_pps_nal(const uint8_t* data, size_t size);
+
+  std::string dump(Indent &) const override;
+
+  Error write(StreamWriter &writer) const override;
+
+protected:
+  Error parse(BitstreamRange &range, const heif_security_limits* limits) override;
+
+  std::string profileIndicationAsText() const;
+
+private:
+  configuration m_configuration;
+  std::vector< std::vector<uint8_t> > m_sps;
+  std::vector< std::vector<uint8_t> > m_pps;
+  std::vector< std::vector<uint8_t> > m_sps_ext;
+};
+
+
+
+class Box_avc1 : public Box_VisualSampleEntry
+{
+public:
+  Box_avc1()
+  {
+    set_short_type(fourcc("avc1"));
+  }
+};
+
+Error parse_sps_for_avcC_configuration(const uint8_t* sps, size_t size,
+                                       Box_avcC::configuration* inout_config,
+                                       int* width, int* height);
+
+#endif
diff --git a/libheif/codecs/avc_dec.cc b/libheif/codecs/avc_dec.cc
new file mode 100644
index 0000000000..8af79a4c6a
--- /dev/null
+++ b/libheif/codecs/avc_dec.cc
@@ -0,0 +1,62 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "avc_dec.h"
+#include "avc_boxes.h"
+#include "error.h"
+#include "context.h"
+
+#include <string>
+
+
+Result<std::vector<uint8_t>> Decoder_AVC::read_bitstream_configuration_data() const
+{
+  std::vector<uint8_t> data;
+  m_avcC->get_header_nals(data);
+
+  return data;
+}
+
+
+int Decoder_AVC::get_luma_bits_per_pixel() const
+{
+  return m_avcC->get_configuration().bit_depth_luma;
+}
+
+
+int Decoder_AVC::get_chroma_bits_per_pixel() const
+{
+  return m_avcC->get_configuration().bit_depth_chroma;
+}
+
+
+Error Decoder_AVC::get_coded_image_colorspace(heif_colorspace* out_colorspace, heif_chroma* out_chroma) const
+{
+  *out_chroma = m_avcC->get_configuration().chroma_format;
+
+  if (*out_chroma == heif_chroma_monochrome) {
+    *out_colorspace = heif_colorspace_monochrome;
+  }
+  else {
+    *out_colorspace = heif_colorspace_YCbCr;
+  }
+
+  return Error::Ok;
+}
diff --git a/libheif/codecs/avc_dec.h b/libheif/codecs/avc_dec.h
new file mode 100644
index 0000000000..3d08653b6b
--- /dev/null
+++ b/libheif/codecs/avc_dec.h
@@ -0,0 +1,53 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef HEIF_AVC_DEC_H
+#define HEIF_AVC_DEC_H
+
+#include "libheif/heif.h"
+#include "error.h"
+
+#include <memory>
+#include <vector>
+#include <codecs/decoder.h>
+
+class Box_avcC;
+
+
+class Decoder_AVC : public Decoder
+{
+public:
+  explicit Decoder_AVC(const std::shared_ptr<const Box_avcC>& avcC) : m_avcC(avcC) {}
+
+  heif_compression_format get_compression_format() const override { return heif_compression_AVC; }
+
+  int get_luma_bits_per_pixel() const override;
+
+  int get_chroma_bits_per_pixel() const override;
+
+  Error get_coded_image_colorspace(heif_colorspace*, heif_chroma*) const override;
+
+  Result<std::vector<uint8_t>> read_bitstream_configuration_data() const override;
+
+private:
+  const std::shared_ptr<const Box_avcC> m_avcC;
+};
+
+#endif
diff --git a/libheif/codecs/avc_enc.cc b/libheif/codecs/avc_enc.cc
new file mode 100644
index 0000000000..1e6973fe82
--- /dev/null
+++ b/libheif/codecs/avc_enc.cc
@@ -0,0 +1,303 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2025 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "avc_enc.h"
+#include "avc_boxes.h"
+#include "error.h"
+#include "context.h"
+#include "api_structs.h"
+
+#include <string>
+
+#include "plugins/nalu_utils.h"
+
+
+// TODO: can we use the new sequences interface for this to avoid duplicate code.
+Result<Encoder::CodedImageData> Encoder_AVC::encode(const std::shared_ptr<HeifPixelImage>& image,
+                                                    heif_encoder* encoder,
+                                                    const heif_encoding_options& options,
+                                                    heif_image_input_class input_class)
+{
+  CodedImageData codedImage;
+
+  auto avcC = std::make_shared<Box_avcC>();
+
+  heif_image c_api_image;
+  c_api_image.image = image;
+
+  heif_error err = encoder->plugin->encode_image(encoder->encoder, &c_api_image, input_class);
+  if (err.code) {
+    return Error(err.code,
+                 err.subcode,
+                 err.message);
+  }
+
+  int encoded_width = 0;
+  int encoded_height = 0;
+
+  for (;;) {
+    uint8_t* data;
+    int size;
+
+    err = encoder->plugin->get_compressed_data(encoder->encoder, &data, &size, nullptr);
+    if (err.code) {
+      return Error(err.code, err.subcode, err.message);
+    }
+
+    if (data == nullptr) {
+      break;
+    }
+
+    uint8_t nal_type = data[0] & 0x1f;
+
+    if (nal_type == AVC_NAL_UNIT_SPS_NUT) {
+      parse_sps_for_avcC_configuration(data, size, &avcC->get_configuration(), &encoded_width, &encoded_height);
+
+      codedImage.encoded_image_width = encoded_width;
+      codedImage.encoded_image_height = encoded_height;
+    }
+
+    switch (nal_type) {
+      case AVC_NAL_UNIT_SPS_NUT:
+        avcC->append_sps_nal(data, size);
+        break;
+      case AVC_NAL_UNIT_SPS_EXT_NUT:
+        avcC->append_sps_ext_nal(data, size);
+        break;
+      case AVC_NAL_UNIT_PPS_NUT:
+        avcC->append_pps_nal(data, size);
+        break;
+
+      default:
+        codedImage.append_with_4bytes_size(data, size);
+    }
+  }
+
+  if (!encoded_width || !encoded_height) {
+    return Error(heif_error_Encoder_plugin_error,
+                 heif_suberror_Invalid_image_size);
+  }
+
+  codedImage.properties.push_back(avcC);
+
+
+  // Make sure that the encoder plugin works correctly and the encoded image has the correct size.
+
+  if (encoder->plugin->plugin_api_version >= 3 &&
+      encoder->plugin->query_encoded_size != nullptr) {
+    uint32_t check_encoded_width = image->get_width(), check_encoded_height = image->get_height();
+
+    encoder->plugin->query_encoded_size(encoder->encoder,
+                                        image->get_width(), image->get_height(),
+                                        &check_encoded_width,
+                                        &check_encoded_height);
+
+    assert((int)check_encoded_width == encoded_width);
+    assert((int)check_encoded_height == encoded_height);
+  }
+
+  codedImage.codingConstraints.intra_pred_used = true;
+  codedImage.codingConstraints.all_ref_pics_intra = true; // TODO: change when we use predicted frames
+
+  return codedImage;
+}
+
+
+Error Encoder_AVC::encode_sequence_frame(const std::shared_ptr<HeifPixelImage>& image,
+                                         heif_encoder* encoder,
+                                         const heif_sequence_encoding_options& options,
+                                         heif_image_input_class input_class,
+                                         uint32_t framerate_num, uint32_t framerate_denom,
+                                         uintptr_t frame_number)
+{
+  heif_image c_api_image;
+  c_api_image.image = image;
+
+  if (!m_encoder_active) {
+    heif_error err = encoder->plugin->start_sequence_encoding(encoder->encoder, &c_api_image,
+                                                              input_class,
+                                                              framerate_num, framerate_denom,
+                                                              &options);
+    if (err.code) {
+      return {
+        err.code,
+        err.subcode,
+        err.message
+      };
+    }
+
+    m_avcC = std::make_shared<Box_avcC>();
+    m_encoder_active = true;
+  }
+
+  Error dataErr = get_data(encoder);
+  if (dataErr) {
+    return dataErr;
+  }
+
+  heif_error err = encoder->plugin->encode_sequence_frame(encoder->encoder, &c_api_image, frame_number);
+  if (err.code) {
+    return {
+      err.code,
+      err.subcode,
+      err.message
+    };
+  }
+
+  return get_data(encoder);
+}
+
+
+Error Encoder_AVC::encode_sequence_flush(heif_encoder* encoder)
+{
+  encoder->plugin->end_sequence_encoding(encoder->encoder);
+  m_encoder_active = false;
+  m_end_of_sequence_reached = true;
+
+  return get_data(encoder);
+}
+
+
+std::optional<Encoder::CodedImageData> Encoder_AVC::encode_sequence_get_data()
+{
+  if (m_output_image_complete) {
+    m_output_image_complete = false;
+    return std::move(m_current_output_data);
+  }
+  else {
+    return std::nullopt;
+  }
+}
+
+Error Encoder_AVC::get_data(heif_encoder* encoder)
+{
+  //CodedImageData codedImage;
+
+  for (;;) {
+    uint8_t* data;
+    int size;
+
+    uintptr_t frameNr=0;
+    int more_frame_packets = 1;
+    struct heif_error err = encoder->plugin->get_compressed_data2(encoder->encoder, &data, &size, &frameNr, nullptr, &more_frame_packets);
+    if (err.code) {
+      return Error(err.code, err.subcode, err.message);
+    }
+
+    if (data == nullptr) {
+      break;
+    }
+
+    const uint8_t nal_type = (data[0] & 0x1f);
+    const bool is_sync = (nal_type == 5);
+    const bool is_image_data = (nal_type > 0 && nal_type <= AVC_NAL_UNIT_MAX_VCL);
+
+    m_output_image_complete |= is_image_data;
+
+    // std::cout << "received frameNr=" << frameNr << " nal_type:" << ((int)nal_type) << " size: " << size << "\n";
+
+    if (nal_type == AVC_NAL_UNIT_SPS_NUT && m_avcC) {
+      parse_sps_for_avcC_configuration(data, size,
+                                       &m_avcC->get_configuration(),
+                                       &m_encoded_image_width, &m_encoded_image_height);
+    }
+
+    if (is_image_data) {
+      // more_frame_packets = 0;
+    }
+
+    switch (nal_type) {
+      case AVC_NAL_UNIT_SPS_NUT:
+        if (m_avcC && !m_avcC_has_SPS) m_avcC->append_sps_nal(data, size);
+        m_avcC_has_SPS = true;
+        break;
+
+      case AVC_NAL_UNIT_SPS_EXT_NUT:
+        if (m_avcC /*&& !m_avcC_has_SPS*/) m_avcC->append_sps_ext_nal(data, size);
+        //m_avcC_has_SPS = true;
+        break;
+
+      case AVC_NAL_UNIT_PPS_NUT:
+        if (m_avcC && !m_avcC_has_PPS) m_avcC->append_pps_nal(data, size);
+        m_avcC_has_PPS = true;
+        break;
+
+      default:
+        if (!m_current_output_data) {
+          m_current_output_data = CodedImageData{};
+        }
+        m_current_output_data->append_with_4bytes_size(data, size);
+
+        if (is_image_data) {
+          m_current_output_data->is_sync_frame = is_sync;
+          m_current_output_data->frame_nr = frameNr;
+        }
+    }
+
+    if (!more_frame_packets) {
+      break;
+    }
+  }
+
+  if (!m_output_image_complete) {
+    return {};
+  }
+
+  if (!m_encoded_image_width || !m_encoded_image_height) {
+    return Error(heif_error_Encoder_plugin_error,
+                 heif_suberror_Invalid_image_size);
+  }
+
+
+  // --- return avcC when all headers are included and it was not returned yet
+  //     TODO: it's maybe better to return this at the end so that we are sure to have all headers
+  //           and also complete codingConstraints.
+
+  if (m_end_of_sequence_reached && m_avcC && !m_avcC_sent) {
+    m_current_output_data->properties.push_back(m_avcC);
+    m_avcC = nullptr;
+    m_avcC_sent = true;
+  }
+
+  m_current_output_data->encoded_image_width = m_encoded_image_width;
+  m_current_output_data->encoded_image_height = m_encoded_image_height;
+
+  m_current_output_data->codingConstraints.intra_pred_used = true;
+  m_current_output_data->codingConstraints.all_ref_pics_intra = true; // TODO: change when we use predicted frames
+
+  return {};
+}
+
+
+std::shared_ptr<Box_VisualSampleEntry> Encoder_AVC::get_sample_description_box(const CodedImageData& data) const
+{
+  auto avc1 = std::make_shared<Box_avc1>();
+  avc1->get_VisualSampleEntry().compressorname = "AVC";
+
+  for (auto prop : data.properties) {
+    if (prop->get_short_type() == fourcc("avcC")) {
+      avc1->append_child_box(prop);
+      return avc1;
+    }
+  }
+
+  // box not yet available
+  return nullptr;
+}
diff --git a/libheif/codecs/avc_enc.h b/libheif/codecs/avc_enc.h
new file mode 100644
index 0000000000..c63d406d27
--- /dev/null
+++ b/libheif/codecs/avc_enc.h
@@ -0,0 +1,78 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2025 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef HEIF_ENCODER_AVC_H
+#define HEIF_ENCODER_AVC_H
+
+#include "libheif/heif.h"
+#include "box.h"
+#include "error.h"
+#include "file.h"
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+#include "codecs/encoder.h"
+
+
+class Encoder_AVC : public Encoder {
+public:
+  Result<CodedImageData> encode(const std::shared_ptr<HeifPixelImage>& image,
+                                heif_encoder* encoder,
+                                const heif_encoding_options& options,
+                                heif_image_input_class input_class) override;
+
+  bool encode_sequence_started() const override { return m_encoder_active; }
+
+  Error encode_sequence_frame(const std::shared_ptr<HeifPixelImage>& image,
+                              heif_encoder* encoder,
+                              const heif_sequence_encoding_options& options,
+                              heif_image_input_class input_class,
+                              uint32_t framerate_num, uint32_t framerate_denom,
+                              uintptr_t frame_number) override;
+
+  Error encode_sequence_flush(heif_encoder* encoder) override;
+
+  std::optional<CodedImageData> encode_sequence_get_data() override;
+
+  std::shared_ptr<Box_VisualSampleEntry> get_sample_description_box(const CodedImageData&) const override;
+
+private:
+  bool m_encoder_active = false;
+  bool m_end_of_sequence_reached = false;
+
+  // Whether the hvcC is complete and was returned in an encode_sequence_get_data() call.
+  bool m_avcC_has_SPS = false;
+  bool m_avcC_has_PPS = false;
+  std::shared_ptr<class Box_avcC> m_avcC;
+  bool m_avcC_sent = false;
+
+  int m_encoded_image_width = 0;
+  int m_encoded_image_height = 0;
+
+  std::optional<CodedImageData> m_current_output_data;
+  bool m_output_image_complete = false;
+
+  Error get_data(heif_encoder*);
+};
+
+
+#endif
diff --git a/libheif/heif_avif.cc b/libheif/codecs/avif_boxes.cc
similarity index 61%
rename from libheif/heif_avif.cc
rename to libheif/codecs/avif_boxes.cc
index bd233b3728..3a79d791e6 100644
--- a/libheif/heif_avif.cc
+++ b/libheif/codecs/avif_boxes.cc
@@ -1,6 +1,6 @@
 /*
  * HEIF codec.
- * Copyright (c) 2017 struktur AG, Dirk Farin <farin@struktur.de>
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
  *
  * This file is part of libheif.
  *
@@ -18,36 +18,143 @@
  * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "heif_image.h"
-#include "heif_avif.h"
+#include "pixelimage.h"
+#include "avif_boxes.h"
+#include "avif_dec.h"
 #include "bitstream.h"
+#include "common_utils.h"
+#include "api_structs.h"
+#include "file.h"
+#include <iomanip>
 #include <limits>
-
-using namespace heif;
+#include <string>
+#include <cstring>
 
 // https://aomediacodec.github.io/av1-spec/av1-spec.pdf
 
 
-Error heif::fill_av1C_configuration(Box_av1C::configuration* inout_config, std::shared_ptr<HeifPixelImage> image)
+Error Box_av1C::parse(BitstreamRange& range, const heif_security_limits* limits)
 {
-  int bpp = image->get_bits_per_pixel(heif_channel_Y);
-  heif_chroma chroma = image->get_chroma_format();
+  //parse_full_box_header(range);
+
+  if (!has_fixed_box_size()) {
+    // Note: in theory, it is allowed to have an av1C box with unspecified size (until the end of the file),
+    // but that would be very uncommon and give us problems in the calculation of `configOBUs_bytes` below.
+    // It's better to error on this case than to open a DoS vulnerability.
+    return Error{heif_error_Invalid_input, heif_suberror_Unspecified, "av1C with unspecified box size"};
+  }
+
+  uint8_t byte;
 
-  uint8_t profile;
+  auto& c = m_configuration; // abbreviation
 
-  if (bpp <= 10 &&
-      (chroma == heif_chroma_420 ||
-       chroma == heif_chroma_monochrome)) {
-    profile = 0;
+  byte = range.read8();
+  if ((byte & 0x80) == 0) {
+    // error: marker bit not set
   }
-  else if (bpp <= 10 &&
-           chroma == heif_chroma_444) {
-    profile = 1;
+
+  c.version = byte & 0x7F;
+
+  byte = range.read8();
+  c.seq_profile = (byte >> 5) & 0x7;
+  c.seq_level_idx_0 = byte & 0x1f;
+
+  byte = range.read8();
+  c.seq_tier_0 = (byte >> 7) & 1;
+  c.high_bitdepth = (byte >> 6) & 1;
+  c.twelve_bit = (byte >> 5) & 1;
+  c.monochrome = (byte >> 4) & 1;
+  c.chroma_subsampling_x = (byte >> 3) & 1;
+  c.chroma_subsampling_y = (byte >> 2) & 1;
+  c.chroma_sample_position = byte & 3;
+
+  byte = range.read8();
+  c.initial_presentation_delay_present = (byte >> 4) & 1;
+  if (c.initial_presentation_delay_present) {
+    c.initial_presentation_delay_minus_one = byte & 0x0F;
+  }
+
+  const size_t configOBUs_bytes = range.get_remaining_bytes();
+  m_config_OBUs.resize(configOBUs_bytes);
+
+  if (!range.read(m_config_OBUs.data(), configOBUs_bytes)) {
+    // error
+  }
+
+  return range.get_error();
+}
+
+
+Error Box_av1C::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  const auto& c = m_configuration; // abbreviation
+
+  writer.write8(c.version | 0x80);
+
+  writer.write8((uint8_t) (((c.seq_profile & 0x7) << 5) |
+                           (c.seq_level_idx_0 & 0x1f)));
+
+  writer.write8((uint8_t) ((c.seq_tier_0 ? 0x80 : 0) |
+                           (c.high_bitdepth ? 0x40 : 0) |
+                           (c.twelve_bit ? 0x20 : 0) |
+                           (c.monochrome ? 0x10 : 0) |
+                           (c.chroma_subsampling_x ? 0x08 : 0) |
+                           (c.chroma_subsampling_y ? 0x04 : 0) |
+                           (c.chroma_sample_position & 0x03)));
+
+  writer.write8(0); // TODO initial_presentation_delay
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+
+std::string Box_av1C::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
+
+  const auto& c = m_configuration; // abbreviation
+
+  sstr << indent << "version: " << ((int) c.version) << "\n"
+       << indent << "seq_profile: " << ((int) c.seq_profile) << "\n"
+       << indent << "seq_level_idx_0: " << ((int) c.seq_level_idx_0) << "\n"
+       << indent << "high_bitdepth: " << ((int) c.high_bitdepth) << "\n"
+       << indent << "twelve_bit: " << ((int) c.twelve_bit) << "\n"
+       << indent << "monochrome: " << ((int) c.monochrome) << "\n"
+       << indent << "chroma_subsampling_x: " << ((int) c.chroma_subsampling_x) << "\n"
+       << indent << "chroma_subsampling_y: " << ((int) c.chroma_subsampling_y) << "\n"
+       << indent << "chroma_sample_position: " << ((int) c.chroma_sample_position) << "\n"
+       << indent << "initial_presentation_delay: ";
+
+  if (c.initial_presentation_delay_present) {
+    sstr << c.initial_presentation_delay_minus_one + 1 << "\n";
   }
   else {
-    profile = 2;
+    sstr << "not present\n";
   }
 
+  sstr << indent << "config OBUs:";
+  for (size_t i = 0; i < m_config_OBUs.size(); i++) {
+    sstr << " " << std::hex << std::setfill('0') << std::setw(2)
+         << ((int) m_config_OBUs[i]);
+  }
+  sstr << std::dec << "\n";
+
+  return sstr.str();
+}
+
+
+Error fill_av1C_configuration(Box_av1C::configuration* inout_config, const std::shared_ptr<HeifPixelImage>& image)
+{
+  int bpp = image->get_bits_per_pixel(heif_channel_Y);
+  heif_chroma chroma = image->get_chroma_format();
+
+  uint8_t profile = compute_avif_profile(bpp, chroma);
+
   int width = image->get_width(heif_channel_Y);
   int height = image->get_height(heif_channel_Y);
 
@@ -83,11 +190,92 @@ Error heif::fill_av1C_configuration(Box_av1C::configuration* inout_config, std::
 }
 
 
+Error Box_a1op::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  op_index = range.read8();
+
+  return range.get_error();
+}
+
+
+std::string Box_a1op::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
+
+  sstr << indent << "op-index: " << ((int) op_index) << "\n";
+
+  return sstr.str();
+}
+
+
+Error Box_a1op::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  writer.write8(op_index);
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+
+Error Box_a1lx::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  uint8_t flags = range.read8();
+
+  for (int i = 0; i < 3; i++) {
+    if (flags & 1) {
+      layer_size[i] = range.read32();
+    }
+    else {
+      layer_size[i] = range.read16();
+    }
+  }
+
+  return range.get_error();
+}
+
+
+std::string Box_a1lx::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
+
+  sstr << indent << "layer-sizes: [" << layer_size[0] << "," << layer_size[1] << "," << layer_size[2] << "]\n";
+
+  return sstr.str();
+}
+
+
+Error Box_a1lx::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  bool large = (layer_size[0] > 0xFFFF || layer_size[1] > 0xFFFF || layer_size[2] > 0xFFFF);
+  writer.write8(large ? 1 : 0);
+
+  for (int i = 0; i < 3; i++) {
+    if (large) {
+      writer.write32(layer_size[i]);
+    }
+    else {
+      writer.write16((uint16_t) layer_size[i]);
+    }
+  }
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+
 static uint64_t leb128(BitReader& reader)
 {
   uint64_t val = 0;
   for (int i = 0; i < 8; i++) {
-    int v = reader.get_bits(8);
+    int64_t v = reader.get_bits(8);
     val |= (v & 0x7F) << (i * 7);
     if (!(v & 0x80)) {
       break;
@@ -140,7 +328,7 @@ const static int HEIF_CSP_UNKNOWN = 0;
 // 2 - CSP_COLOCATED
 // 3 - CSP_RESERVED
 
-bool heif::fill_av1C_configuration_from_stream(Box_av1C::configuration* out_config, const uint8_t* data, int dataSize)
+bool fill_av1C_configuration_from_stream(Box_av1C::configuration* out_config, const uint8_t* data, int dataSize)
 {
   BitReader reader(data, dataSize);
 
@@ -275,8 +463,8 @@ bool heif::fill_av1C_configuration_from_stream(Box_av1C::configuration* out_conf
     }
 
     // screen content
-    int force_screen_content_tools = 0;
-    if (reader.get_bits(1)) {
+    int force_screen_content_tools = 2;
+    if (reader.get_bits(1) == 0) {
       force_screen_content_tools = reader.get_bits(1);
     }
 
diff --git a/libheif/codecs/avif_boxes.h b/libheif/codecs/avif_boxes.h
new file mode 100644
index 0000000000..f7de65583f
--- /dev/null
+++ b/libheif/codecs/avif_boxes.h
@@ -0,0 +1,171 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef HEIF_AVIF_BOXES_H
+#define HEIF_AVIF_BOXES_H
+
+#include <cassert>
+#include <cmath>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "libheif/heif.h"
+#include "box.h"
+#include "error.h"
+#include "image-items/image_item.h"
+#include "sequences/seq_boxes.h"
+
+
+class Box_av1C : public Box
+{
+
+// allow access to protected parse() method
+friend class Box_mini;
+
+public:
+  Box_av1C()
+  {
+    set_short_type(fourcc("av1C"));
+  }
+
+  bool is_essential() const override { return true; }
+
+  struct configuration
+  {
+    //unsigned int (1) marker = 1;
+    uint8_t version = 1;
+    uint8_t seq_profile = 0;
+    uint8_t seq_level_idx_0 = 0;
+    uint8_t seq_tier_0 = 0;
+    uint8_t high_bitdepth = 0;
+    uint8_t twelve_bit = 0;
+    uint8_t monochrome = 0;
+    uint8_t chroma_subsampling_x = 0; // (minus 1) that is: either 0 or 1
+    uint8_t chroma_subsampling_y = 0; // (minus 1)
+    uint8_t chroma_sample_position = 0;
+    //uint8_t reserved = 0;
+
+    uint8_t initial_presentation_delay_present = 0;
+    uint8_t initial_presentation_delay_minus_one = 0;
+
+    //unsigned int (8)[] configOBUs;
+
+    heif_chroma get_heif_chroma() const {
+      if (monochrome) {
+        return heif_chroma_monochrome;
+      }
+      else if (chroma_subsampling_x==1 && chroma_subsampling_y==1) {
+        return heif_chroma_420;
+      }
+      else if (chroma_subsampling_x==1 && chroma_subsampling_y==0) {
+        return heif_chroma_422;
+      }
+      else if (chroma_subsampling_x==0 && chroma_subsampling_y==0) {
+        return heif_chroma_444;
+      }
+      else {
+        return heif_chroma_undefined;
+      }
+    }
+  };
+
+
+  std::string dump(Indent&) const override;
+
+  bool get_headers(std::vector<uint8_t>* dest) const
+  {
+    *dest = m_config_OBUs;
+    return true;
+  }
+
+  void set_configuration(const configuration& config) { m_configuration = config; }
+
+  const configuration& get_configuration() const { return m_configuration; }
+
+  //void append_nal_data(const std::vector<uint8_t>& nal);
+  //void append_nal_data(const uint8_t* data, size_t size);
+
+  Error write(StreamWriter& writer) const override;
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits* limits) override;
+
+private:
+  configuration m_configuration;
+
+  std::vector<uint8_t> m_config_OBUs;
+};
+
+
+class Box_av01 : public Box_VisualSampleEntry
+{
+public:
+  Box_av01()
+  {
+    set_short_type(fourcc("av01"));
+  }
+};
+
+class Box_a1op : public Box
+{
+public:
+  Box_a1op()
+  {
+    set_short_type(fourcc("a1op"));
+  }
+
+  uint8_t op_index = 0;
+
+  std::string dump(Indent&) const override;
+
+  Error write(StreamWriter& writer) const override;
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits* limits) override;
+};
+
+
+class Box_a1lx : public Box
+{
+public:
+  Box_a1lx()
+  {
+    set_short_type(fourcc("a1lx"));
+  }
+
+  uint32_t layer_size[3]{};
+
+  std::string dump(Indent&) const override;
+
+  Error write(StreamWriter& writer) const override;
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits* limits) override;
+};
+
+
+class HeifPixelImage;
+
+Error fill_av1C_configuration(Box_av1C::configuration* inout_config, const std::shared_ptr<HeifPixelImage>& image);
+
+bool fill_av1C_configuration_from_stream(Box_av1C::configuration* out_config, const uint8_t* data, int dataSize);
+
+#endif
diff --git a/libheif/codecs/avif_dec.cc b/libheif/codecs/avif_dec.cc
new file mode 100644
index 0000000000..e0446a2de6
--- /dev/null
+++ b/libheif/codecs/avif_dec.cc
@@ -0,0 +1,74 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "avif_dec.h"
+#include "avif_boxes.h"
+#include "error.h"
+#include "context.h"
+
+#include <string>
+
+
+Result<std::vector<uint8_t>> Decoder_AVIF::read_bitstream_configuration_data() const
+{
+  std::vector<uint8_t> data;
+  if (!m_av1C->get_headers(&data)) {
+    return Error{heif_error_Invalid_input,
+                 heif_suberror_No_item_data};
+  }
+
+  return data;
+}
+
+
+int Decoder_AVIF::get_luma_bits_per_pixel() const
+{
+  Box_av1C::configuration config = m_av1C->get_configuration();
+  if (!config.high_bitdepth) {
+    return 8;
+  }
+  else if (config.twelve_bit) {
+    return 12;
+  }
+  else {
+    return 10;
+  }
+}
+
+
+int Decoder_AVIF::get_chroma_bits_per_pixel() const
+{
+  return get_luma_bits_per_pixel();
+}
+
+
+Error Decoder_AVIF::get_coded_image_colorspace(heif_colorspace* out_colorspace, heif_chroma* out_chroma) const
+{
+  *out_chroma = (heif_chroma) (m_av1C->get_configuration().get_heif_chroma());
+
+  if (*out_chroma == heif_chroma_monochrome) {
+    *out_colorspace = heif_colorspace_monochrome;
+  }
+  else {
+    *out_colorspace = heif_colorspace_YCbCr;
+  }
+
+  return Error::Ok;
+}
diff --git a/libheif/codecs/avif_dec.h b/libheif/codecs/avif_dec.h
new file mode 100644
index 0000000000..441f1864ac
--- /dev/null
+++ b/libheif/codecs/avif_dec.h
@@ -0,0 +1,53 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef HEIF_AVIF_DEC_H
+#define HEIF_AVIF_DEC_H
+
+#include "libheif/heif.h"
+#include "error.h"
+
+#include <memory>
+#include <vector>
+#include <codecs/decoder.h>
+
+class Box_av1C;
+
+
+class Decoder_AVIF : public Decoder
+{
+public:
+  explicit Decoder_AVIF(const std::shared_ptr<const Box_av1C>& av1C) : m_av1C(av1C) {}
+
+  heif_compression_format get_compression_format() const override { return heif_compression_AV1; }
+
+  int get_luma_bits_per_pixel() const override;
+
+  int get_chroma_bits_per_pixel() const override;
+
+  Error get_coded_image_colorspace(heif_colorspace*, heif_chroma*) const override;
+
+  Result<std::vector<uint8_t>> read_bitstream_configuration_data() const override;
+
+private:
+  const std::shared_ptr<const Box_av1C> m_av1C;
+};
+
+#endif
diff --git a/libheif/codecs/avif_enc.cc b/libheif/codecs/avif_enc.cc
new file mode 100644
index 0000000000..800494e95d
--- /dev/null
+++ b/libheif/codecs/avif_enc.cc
@@ -0,0 +1,222 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "avif_enc.h"
+#include "avif_boxes.h"
+#include "error.h"
+#include "context.h"
+#include "api_structs.h"
+
+#include <string>
+
+enum heif_av1_obu_type : uint8_t
+{
+  heif_av1_obu_type_frame = 2
+};
+
+
+Result<Encoder::CodedImageData> Encoder_AVIF::encode(const std::shared_ptr<HeifPixelImage>& image,
+                                                     heif_encoder* encoder,
+                                                     const heif_encoding_options& options,
+                                                     heif_image_input_class input_class)
+{
+  CodedImageData codedImage;
+
+  Box_av1C::configuration config;
+
+  // Fill preliminary av1C in case we cannot parse the sequence_header() correctly in the code below.
+  // TODO: maybe we can remove this later.
+  fill_av1C_configuration(&config, image);
+
+  heif_image c_api_image;
+  c_api_image.image = image;
+
+  heif_error err = encoder->plugin->encode_image(encoder->encoder, &c_api_image, input_class);
+  if (err.code) {
+    return Error(err.code,
+                 err.subcode,
+                 err.message);
+  }
+
+  for (;;) {
+    uint8_t* data;
+    int size;
+
+    err = encoder->plugin->get_compressed_data(encoder->encoder, &data, &size, nullptr);
+    if (err.code) {
+      return Error(err.code, err.subcode, err.message);
+    }
+
+    bool found_config = fill_av1C_configuration_from_stream(&config, data, size);
+    (void) found_config;
+
+    if (data == nullptr) {
+      break;
+    }
+
+    codedImage.append(data, size);
+  }
+
+  auto av1C = std::make_shared<Box_av1C>();
+  av1C->set_configuration(config);
+  codedImage.properties.push_back(av1C);
+
+  codedImage.codingConstraints.intra_pred_used = true;
+  codedImage.codingConstraints.all_ref_pics_intra = true; // TODO: change when we use predicted frames
+
+  return codedImage;
+}
+
+
+Error Encoder_AVIF::encode_sequence_frame(const std::shared_ptr<HeifPixelImage>& image,
+                                    heif_encoder* encoder,
+                                    const heif_sequence_encoding_options& options,
+                                    heif_image_input_class input_class,
+                                    uint32_t framerate_num, uint32_t framerate_denom,
+                                    uintptr_t frame_number)
+{
+  // Box_av1C::configuration config;
+
+  // Fill preliminary av1C in case we cannot parse the sequence_header() correctly in the code below.
+  // TODO: maybe we can remove this later.
+  fill_av1C_configuration(&m_config, image);
+
+  heif_image c_api_image;
+  c_api_image.image = image;
+
+  if (!m_encoder_active) {
+    heif_error err = encoder->plugin->start_sequence_encoding(encoder->encoder,
+                                                              &c_api_image,
+                                                              input_class,
+                                                              framerate_num, framerate_denom,
+                                                              &options);
+    if (err.code) {
+      return {
+        err.code,
+        err.subcode,
+        err.message
+      };
+    }
+
+    //m_hvcC = std::make_shared<Box_hvcC>();
+    m_encoder_active = true;
+  }
+
+
+  heif_error err = encoder->plugin->encode_sequence_frame(encoder->encoder, &c_api_image, frame_number);
+  if (err.code) {
+    return Error(err.code,
+                 err.subcode,
+                 err.message);
+  }
+
+  m_all_refs_intra = (options.gop_structure == heif_sequence_gop_structure_intra_only);
+
+  return get_data(encoder);
+}
+
+
+Error Encoder_AVIF::get_data(heif_encoder* encoder)
+{
+  CodedImageData codedImage;
+
+  for (;;) {
+    uint8_t* data;
+    int size;
+
+    uintptr_t out_frame_number;
+    int is_keyframe = 0;
+    struct heif_error err = encoder->plugin->get_compressed_data2(encoder->encoder, &data, &size, &out_frame_number, &is_keyframe, nullptr);
+    if (err.code) {
+      return Error(err.code, err.subcode, err.message);
+    }
+
+    if (data == nullptr) {
+      break;
+    }
+
+    uint8_t obu_type = (data[0]>>3) & 0x0F;
+
+    // printf("got OBU type=%d size=%d framenr=%d\n", obu_type, size, out_frame_number);
+
+    bool found_config = fill_av1C_configuration_from_stream(&m_config, data, size);
+    (void) found_config;
+
+    codedImage.append(data, size);
+    codedImage.frame_nr = out_frame_number;
+
+    if (encoder->plugin->plugin_api_version >= 4 &&
+        encoder->plugin->does_indicate_keyframes) {
+      codedImage.is_sync_frame = is_keyframe;
+    }
+
+    // If we got an image, stop collecting data packets.
+    if (obu_type == heif_av1_obu_type_frame) {
+      break;
+    }
+  }
+
+  if (m_end_of_sequence_reached && !m_av1C_sent) {
+    auto av1C = std::make_shared<Box_av1C>();
+    av1C->set_configuration(m_config);
+    codedImage.properties.push_back(av1C);
+    m_av1C_sent = true;
+  }
+
+  codedImage.codingConstraints.intra_pred_used = true;
+  codedImage.codingConstraints.all_ref_pics_intra = m_all_refs_intra;
+
+  m_current_output_data = std::move(codedImage);
+
+  return {};
+}
+
+
+Error Encoder_AVIF::encode_sequence_flush(heif_encoder* encoder)
+{
+  encoder->plugin->end_sequence_encoding(encoder->encoder);
+  m_encoder_active = false;
+  m_end_of_sequence_reached = true;
+
+  return get_data(encoder);
+}
+
+
+std::optional<Encoder::CodedImageData> Encoder_AVIF::encode_sequence_get_data()
+{
+  return std::move(m_current_output_data);
+}
+
+
+std::shared_ptr<Box_VisualSampleEntry> Encoder_AVIF::get_sample_description_box(const CodedImageData& data) const
+{
+  auto av01 = std::make_shared<Box_av01>();
+  av01->get_VisualSampleEntry().compressorname = "AVIF";
+
+  for (auto prop : data.properties) {
+    if (prop->get_short_type() == fourcc("av1C")) {
+      av01->append_child_box(prop);
+      return av01;
+    }
+  }
+
+  // box not available yet
+  return nullptr;
+}
diff --git a/libheif/codecs/avif_enc.h b/libheif/codecs/avif_enc.h
new file mode 100644
index 0000000000..f704a4f8ca
--- /dev/null
+++ b/libheif/codecs/avif_enc.h
@@ -0,0 +1,75 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef HEIF_ENCODER_AVIF_H
+#define HEIF_ENCODER_AVIF_H
+
+#include "libheif/heif.h"
+#include "box.h"
+#include "error.h"
+#include "file.h"
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "avif_boxes.h"
+#include "codecs/encoder.h"
+
+
+class Encoder_AVIF : public Encoder {
+public:
+  Result<CodedImageData> encode(const std::shared_ptr<HeifPixelImage>& image,
+                                heif_encoder* encoder,
+                                const heif_encoding_options& options,
+                                heif_image_input_class input_class) override;
+
+  bool encode_sequence_started() const override { return m_encoder_active; }
+
+  Error encode_sequence_frame(const std::shared_ptr<HeifPixelImage>& image,
+                                      heif_encoder* encoder,
+                                      const heif_sequence_encoding_options& options,
+                                      heif_image_input_class input_class,
+                                      uint32_t framerate_num, uint32_t framerate_denom,
+                                      uintptr_t frame_number) override;
+
+  Error encode_sequence_flush(heif_encoder* encoder) override;
+
+  std::optional<CodedImageData> encode_sequence_get_data() override;
+
+
+  std::shared_ptr<Box_VisualSampleEntry> get_sample_description_box(const CodedImageData&) const override;
+
+private:
+  bool m_encoder_active = false;
+  bool m_end_of_sequence_reached = false;
+
+  Box_av1C::configuration m_config;
+  bool m_av1C_sent = false;
+
+  std::optional<CodedImageData> m_current_output_data;
+
+  bool m_all_refs_intra = false;
+  Error get_data(heif_encoder* encoder);
+};
+
+
+#endif
diff --git a/libheif/codecs/decoder.cc b/libheif/codecs/decoder.cc
new file mode 100644
index 0000000000..4a734d4301
--- /dev/null
+++ b/libheif/codecs/decoder.cc
@@ -0,0 +1,485 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "codecs/decoder.h"
+
+#include <utility>
+#include "error.h"
+#include "context.h"
+#include "plugin_registry.h"
+#include "api_structs.h"
+
+#include "codecs/hevc_dec.h"
+#include "codecs/avif_dec.h"
+#include "codecs/avc_dec.h"
+#include "codecs/vvc_dec.h"
+#include "codecs/jpeg_dec.h"
+#include "codecs/jpeg2000_dec.h"
+#include "avc_boxes.h"
+#include "avif_boxes.h"
+#include "hevc_boxes.h"
+#include "vvc_boxes.h"
+#include "jpeg_boxes.h"
+#include "jpeg2000_boxes.h"
+
+#if WITH_UNCOMPRESSED_CODEC
+#include "codecs/uncompressed/unc_dec.h"
+#include "codecs/uncompressed/unc_boxes.h"
+#endif
+
+void DataExtent::set_from_image_item(std::shared_ptr<HeifFile> file, heif_item_id item)
+{
+  m_file = std::move(file);
+  m_item_id = item;
+  m_source = Source::Image;
+}
+
+
+void DataExtent::set_file_range(std::shared_ptr<HeifFile> file, uint64_t offset, uint32_t size)
+{
+  m_file = std::move(file);
+  m_source = Source::FileRange;
+  m_offset = offset;
+  m_size = size;
+}
+
+
+Result<std::vector<uint8_t>*> DataExtent::read_data() const
+{
+  if (!m_raw.empty()) {
+    return &m_raw;
+  }
+  else if (m_source == Source::Image) {
+    assert(m_file);
+
+    // image
+    Error err = m_file->append_data_from_iloc(m_item_id, m_raw);
+    if (err) {
+      return err;
+    }
+  }
+  else {
+    // file range
+    Error err = m_file->append_data_from_file_range(m_raw, m_offset, m_size);
+    if (err) {
+      return err;
+    }
+  }
+
+  return &m_raw;
+}
+
+
+Result<std::vector<uint8_t>> DataExtent::read_data(uint64_t offset, uint64_t size) const
+{
+  std::vector<uint8_t> data;
+
+  if (!m_raw.empty()) {
+    data.insert(data.begin(), m_raw.begin() + offset, m_raw.begin() + offset + size);
+    return data;
+  }
+  else if (m_source == Source::Image) {
+    // TODO: cache data
+
+    // image
+    Error err = m_file->append_data_from_iloc(m_item_id, data, offset, size);
+    if (err) {
+      return err;
+    }
+    return data;
+  }
+  else {
+    // file range
+    Error err = m_file->append_data_from_file_range(data, m_offset, m_size);
+    if (err) {
+      return err;
+    }
+
+    return data;
+  }
+}
+
+
+std::shared_ptr<Decoder> Decoder::alloc_for_infe_type(const ImageItem* item)
+{
+  uint32_t format_4cc = item->get_infe_type();
+
+  switch (format_4cc) {
+    case fourcc("hvc1"): {
+      auto hvcC = item->get_property<Box_hvcC>();
+      return std::make_shared<Decoder_HEVC>(hvcC);
+    }
+    case fourcc("av01"): {
+      auto av1C = item->get_property<Box_av1C>();
+      return std::make_shared<Decoder_AVIF>(av1C);
+    }
+    case fourcc("avc1"): {
+      auto avcC = item->get_property<Box_avcC>();
+      return std::make_shared<Decoder_AVC>(avcC);
+    }
+    case fourcc("j2k1"): {
+      auto j2kH = item->get_property<Box_j2kH>();
+      return std::make_shared<Decoder_JPEG2000>(j2kH);
+    }
+    case fourcc("vvc1"): {
+      auto vvcC = item->get_property<Box_vvcC>();
+      return std::make_shared<Decoder_VVC>(vvcC);
+    }
+    case fourcc("jpeg"): {
+      auto jpgC = item->get_property<Box_jpgC>();
+      return std::make_shared<Decoder_JPEG>(jpgC);
+    }
+#if WITH_UNCOMPRESSED_CODEC
+    case fourcc("unci"): {
+      auto uncC = item->get_property<Box_uncC>();
+      auto cmpd = item->get_property<Box_cmpd>();
+      auto ispe = item->get_property<Box_ispe>();
+      auto decoder = std::make_shared<Decoder_uncompressed>(uncC, cmpd, ispe);
+      decoder->set_cpat(item->get_property<Box_cpat>());
+      decoder->set_cmpC(item->get_property<Box_cmpC>());
+      decoder->set_icef(item->get_property<Box_icef>());
+      decoder->set_cloc(item->get_property<Box_cloc>());
+      decoder->set_splz(item->get_all_properties<Box_splz>());
+      decoder->set_sbpm(item->get_all_properties<Box_sbpm>());
+      decoder->set_snuc(item->get_all_properties<Box_snuc>());
+      return decoder;
+    }
+#endif
+    case fourcc("mski"): {
+      return nullptr; // do we need a decoder for this?
+    }
+    default:
+      return nullptr;
+  }
+}
+
+
+std::shared_ptr<Decoder> Decoder::alloc_for_sequence_sample_description_box(std::shared_ptr<const Box_VisualSampleEntry> sample_description_box)
+{
+  std::string compressor = sample_description_box->get_VisualSampleEntry_const().compressorname;
+  uint32_t sampleType = sample_description_box->get_short_type();
+
+  switch (sampleType) {
+    case fourcc("hvc1"): {
+      auto hvcC = sample_description_box->get_child_box<Box_hvcC>();
+      return std::make_shared<Decoder_HEVC>(hvcC);
+    }
+
+    case fourcc("av01"): {
+      auto av1C = sample_description_box->get_child_box<Box_av1C>();
+      return std::make_shared<Decoder_AVIF>(av1C);
+    }
+
+    case fourcc("vvc1"): {
+      auto vvcC = sample_description_box->get_child_box<Box_vvcC>();
+      return std::make_shared<Decoder_VVC>(vvcC);
+    }
+
+    case fourcc("avc1"): {
+      auto avcC = sample_description_box->get_child_box<Box_avcC>();
+      return std::make_shared<Decoder_AVC>(avcC);
+    }
+
+#if WITH_UNCOMPRESSED_CODEC
+    case fourcc("uncv"): {
+      auto uncC = sample_description_box->get_child_box<Box_uncC>();
+      auto cmpd = sample_description_box->get_child_box<Box_cmpd>();
+      auto ispe = std::make_shared<Box_ispe>();
+      ispe->set_size(sample_description_box->get_VisualSampleEntry_const().width,
+                     sample_description_box->get_VisualSampleEntry_const().height);
+      auto decoder = std::make_shared<Decoder_uncompressed>(uncC, cmpd, ispe);
+      decoder->set_cpat(sample_description_box->get_child_box<Box_cpat>());
+      decoder->set_cmpC(sample_description_box->get_child_box<Box_cmpC>());
+      decoder->set_icef(sample_description_box->get_child_box<Box_icef>());
+      decoder->set_cloc(sample_description_box->get_child_box<Box_cloc>());
+      decoder->set_splz(sample_description_box->get_child_boxes<Box_splz>());
+      decoder->set_sbpm(sample_description_box->get_child_boxes<Box_sbpm>());
+      decoder->set_snuc(sample_description_box->get_child_boxes<Box_snuc>());
+      return decoder;
+    }
+#endif
+
+    case fourcc("j2ki"): {
+      auto j2kH = sample_description_box->get_child_box<Box_j2kH>();
+      return std::make_shared<Decoder_JPEG2000>(j2kH);
+    }
+
+    case fourcc("mjpg"): {
+      auto jpgC = sample_description_box->get_child_box<Box_jpgC>();
+      return std::make_shared<Decoder_JPEG>(jpgC);
+    }
+
+    default:
+      return nullptr;
+  }
+}
+
+
+Result<std::vector<uint8_t>> Decoder::get_compressed_data(bool with_configuration_NALs) const
+{
+  // --- get the compressed image data
+
+  if (with_configuration_NALs) {
+    // data from configuration blocks
+
+    Result<std::vector<uint8_t>> confData = read_bitstream_configuration_data();
+    if (!confData) {
+      return confData.error();
+    }
+
+    std::vector<uint8_t> data = *confData;
+
+    // append image data
+
+    auto dataResult = m_data_extent.read_data();
+    if (!dataResult) {
+      return dataResult.error();
+    }
+
+    data.insert(data.end(), (*dataResult)->begin(), (*dataResult)->end());
+
+    return data;
+  }
+  else {
+    auto dataResult = m_data_extent.read_data();
+    if (!dataResult) {
+      return dataResult.error();
+    }
+
+    return {*(*dataResult)};
+  }
+}
+
+
+Decoder::~Decoder()
+{
+  if (m_decoder) {
+    assert(m_decoder_plugin);
+    m_decoder_plugin->free_decoder(m_decoder);
+  }
+
+  //std::unique_ptr<void, void (*)(void*)> decoderSmartPtr(m_decoder, m_decoder_plugin->free_decoder);
+}
+
+
+Error Decoder::require_decoder_plugin(const heif_decoding_options& options)
+{
+  if (!m_decoder_plugin) {
+    if (options.decoder_id && !has_decoder(get_compression_format(), options.decoder_id)) {
+      return {
+        heif_error_Plugin_loading_error,
+        heif_suberror_Unspecified,
+        "No decoder with that ID found."
+      };
+    }
+
+    m_decoder_plugin = get_decoder(get_compression_format(), options.decoder_id);
+    if (!m_decoder_plugin) {
+      return Error(heif_error_Plugin_loading_error, heif_suberror_No_matching_decoder_installed);
+    }
+
+    if (m_decoder_plugin->plugin_api_version < 5) {
+      return Error{
+        heif_error_Plugin_loading_error, heif_suberror_No_matching_decoder_installed,
+        "Decoder plugin needs to be at least version 5."
+      };
+    }
+  }
+
+  return {};
+}
+
+
+Error Decoder::decode_sequence_frame_from_compressed_data(bool upload_configuration_NALs,
+                                                          const heif_decoding_options& options,
+                                                          uintptr_t user_data,
+                                                          const heif_security_limits* limits)
+{
+  auto pluginErr = require_decoder_plugin(options);
+  if (pluginErr) {
+    return pluginErr;
+  }
+
+  // --- decode image with the plugin
+
+  heif_error err;
+
+  if (!m_decoder) {
+    if (m_decoder_plugin->new_decoder == nullptr) {
+      return Error(heif_error_Plugin_loading_error, heif_suberror_No_matching_decoder_installed,
+                   "Cannot decode with a dummy decoder plugin.");
+    }
+
+    if (m_decoder_plugin->plugin_api_version >= 5) {
+      heif_decoder_plugin_options plugin_options;
+      plugin_options.format = get_compression_format();
+      plugin_options.num_threads = options.num_codec_threads;
+      plugin_options.strict_decoding = options.strict_decoding;
+
+      err = m_decoder_plugin->new_decoder2(&m_decoder, &plugin_options);
+      if (err.code != heif_error_Ok) {
+        return Error(err.code, err.subcode, err.message);
+      }
+    }
+    else {
+      err = m_decoder_plugin->new_decoder(&m_decoder);
+      if (err.code != heif_error_Ok) {
+        return Error(err.code, err.subcode, err.message);
+      }
+
+      // automatically delete decoder plugin when we leave the scope
+      //std::unique_ptr<void, void (*)(void*)> decoderSmartPtr(m_decoder, m_decoder_plugin->free_decoder);
+
+      if (m_decoder_plugin->plugin_api_version >= 2) {
+        if (m_decoder_plugin->set_strict_decoding) {
+          m_decoder_plugin->set_strict_decoding(m_decoder, options.strict_decoding);
+        }
+      }
+    }
+  }
+
+  auto dataResult = get_compressed_data(upload_configuration_NALs);
+  if (!dataResult) {
+    return dataResult.error();
+  }
+
+  // Check that we are pushing at least some data into the decoder.
+  // Some decoders (e.g. aom) do not complain when the input data is empty and we might
+  // get stuck in an endless decoding loop, waiting for the decompressed image.
+
+  if (dataResult->size() == 0) {
+    return Error{
+      heif_error_Invalid_input,
+      heif_suberror_Unspecified,
+      "Input with empty data extent."
+    };
+  }
+
+  //std::cout << "Decoder::decode_sequence_frame_from_compressed_data push " << dataResult->size() << "\n";
+  if (m_decoder_plugin->plugin_api_version >= 5 && m_decoder_plugin->push_data2) {
+    err = m_decoder_plugin->push_data2(m_decoder, dataResult->data(), dataResult->size(), user_data);
+  }
+  else {
+    err = m_decoder_plugin->push_data(m_decoder, dataResult->data(), dataResult->size());
+  }
+  if (err.code != heif_error_Ok) {
+    return Error(err.code, err.subcode, err.message);
+  }
+
+  return {};
+}
+
+Error Decoder::flush_decoder()
+{
+  assert(m_decoder_plugin);
+
+  if (m_decoder_plugin->plugin_api_version >= 5) {
+    heif_error err = m_decoder_plugin->flush_data(m_decoder);
+    return Error::from_heif_error(err);
+  }
+
+  return {};
+}
+
+Result<std::shared_ptr<HeifPixelImage> > Decoder::get_decoded_frame(const heif_decoding_options& options,
+                                                                    uintptr_t* out_user_data,
+                                                                    const heif_security_limits* limits)
+{
+  auto pluginErr = require_decoder_plugin(options);
+  if (pluginErr) {
+    return pluginErr;
+  }
+
+  heif_image* decoded_img = nullptr;
+
+  heif_error err;
+
+  if (m_decoder_plugin->plugin_api_version >= 5 &&
+      m_decoder_plugin->decode_next_image2 != nullptr) {
+
+    err = m_decoder_plugin->decode_next_image2(m_decoder, &decoded_img, out_user_data, limits);
+    if (err.code != heif_error_Ok) {
+      return Error::from_heif_error(err);
+    }
+  }
+  else if (m_decoder_plugin->plugin_api_version >= 4 &&
+           m_decoder_plugin->decode_next_image != nullptr) {
+
+    err = m_decoder_plugin->decode_next_image(m_decoder, &decoded_img, limits);
+    if (err.code != heif_error_Ok) {
+      return Error::from_heif_error(err);
+    }
+  }
+  else {
+    err = m_decoder_plugin->decode_image(m_decoder, &decoded_img);
+    if (err.code != heif_error_Ok) {
+      return Error::from_heif_error(err);
+    }
+  }
+
+  if (!decoded_img) {
+    return {nullptr};
+  }
+
+  // -- cleanup
+
+  std::shared_ptr<HeifPixelImage> img = std::move(decoded_img->image);
+  heif_image_release(decoded_img);
+
+  return img;
+}
+
+
+Result<std::shared_ptr<HeifPixelImage>>
+Decoder::decode_single_frame_from_compressed_data(const heif_decoding_options& options,
+                                                  const heif_security_limits* limits)
+{
+  Error decodeError = decode_sequence_frame_from_compressed_data(true, options, 0, limits);
+  if (decodeError) {
+    return decodeError;
+  }
+
+  flush_decoder();
+
+  // We might have to try several times to get an image out of the decoder.
+  // However, we stop after a maximum number of tries because the decoder might not
+  // give any image when the input data is incomplete.
+  const int max_decoding_tries = 50; // hardcoded value, should be large enough
+
+  for (int i = 0; i < max_decoding_tries; i++) {
+    Result<std::shared_ptr<HeifPixelImage>> imgResult;
+    imgResult = get_decoded_frame(options, nullptr, limits);
+    if (imgResult.error()) {
+      return imgResult.error();
+    }
+
+    if (*imgResult != nullptr) {
+      return imgResult;
+    }
+  }
+
+  // We did not receive and image from the decoder. We give up.
+
+  return Error{
+    heif_error_Decoder_plugin_error,
+    heif_suberror_Unspecified,
+    "Decoding the input data did not give a decompressed image."
+  };
+}
diff --git a/libheif/codecs/decoder.h b/libheif/codecs/decoder.h
new file mode 100644
index 0000000000..ea351d6b21
--- /dev/null
+++ b/libheif/codecs/decoder.h
@@ -0,0 +1,128 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef HEIF_DECODER_H
+#define HEIF_DECODER_H
+
+#include "libheif/heif.h"
+#include "box.h"
+#include "error.h"
+#include "file.h"
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+#include "image-items/hevc.h"
+
+
+// Specifies the input data for decoding.
+// For images, this points to the iloc extents.
+// For sequences, this points to the track data.
+struct DataExtent
+{
+  std::shared_ptr<HeifFile> m_file;
+  enum class Source : uint8_t { Raw, Image, FileRange } m_source = Source::Raw;
+
+  // --- raw data
+  mutable std::vector<uint8_t> m_raw; // also for cached data
+
+  // --- image
+  heif_item_id m_item_id = 0;
+
+  // --- file range
+  uint64_t m_offset = 0;
+  uint32_t m_size = 0;
+
+  void set_from_image_item(std::shared_ptr<HeifFile> file, heif_item_id item);
+
+  void set_file_range(std::shared_ptr<HeifFile> file, uint64_t offset, uint32_t size);
+
+  Result<std::vector<uint8_t>*> read_data() const;
+
+  Result<std::vector<uint8_t>> read_data(uint64_t offset, uint64_t size) const;
+};
+
+
+class Decoder
+{
+public:
+  static std::shared_ptr<Decoder> alloc_for_infe_type(const ImageItem* item);
+
+  static std::shared_ptr<Decoder> alloc_for_sequence_sample_description_box(std::shared_ptr<const class Box_VisualSampleEntry> sample_description_box);
+
+
+  virtual ~Decoder();
+
+  virtual heif_compression_format get_compression_format() const = 0;
+
+  void set_data_extent(DataExtent extent) { m_data_extent = std::move(extent); }
+
+  const DataExtent& get_data_extent() const { return m_data_extent; }
+
+  // --- information about the image format
+
+  [[nodiscard]] virtual int get_luma_bits_per_pixel() const = 0;
+
+  [[nodiscard]] virtual int get_chroma_bits_per_pixel() const = 0;
+
+  [[nodiscard]] virtual Error get_coded_image_colorspace(heif_colorspace*, heif_chroma*) const = 0;
+
+  // --- raw data access
+
+  // Returns a stream of packets. Each packet is starts with a 4-byte size (MSB first).
+  [[nodiscard]] virtual Result<std::vector<uint8_t>> read_bitstream_configuration_data() const = 0;
+
+  Result<std::vector<uint8_t>> get_compressed_data(bool with_configuration_NALs) const;
+
+  // --- decoding
+
+  // Decode a stream image that contains exactly one image. Decoder input is flushed and
+  // it always should return an image.
+  virtual Result<std::shared_ptr<HeifPixelImage>>
+  decode_single_frame_from_compressed_data(const heif_decoding_options& options,
+                                           const heif_security_limits* limits);
+
+  // Push data for one frame into decoder.
+  virtual Error
+  decode_sequence_frame_from_compressed_data(bool upload_configuration_NALs,
+                                             const heif_decoding_options& options,
+                                             uintptr_t user_data,
+                                             const heif_security_limits* limits);
+
+  virtual Error flush_decoder();
+
+  // Get a decoded frame from the decoder.
+  // It may return NULL when there is buffering in the codec.
+  virtual Result<std::shared_ptr<HeifPixelImage> > get_decoded_frame(const heif_decoding_options& options,
+                                                                     uintptr_t* out_user_data,
+                                                                     const heif_security_limits* limits);
+
+private:
+  DataExtent m_data_extent;
+
+  const heif_decoder_plugin* m_decoder_plugin = nullptr;
+  void* m_decoder = nullptr;
+
+  // get the decoder plugin if it is not set already
+  Error require_decoder_plugin(const heif_decoding_options& options);
+};
+
+#endif
diff --git a/libheif/codecs/encoder.cc b/libheif/codecs/encoder.cc
new file mode 100644
index 0000000000..257e3fe841
--- /dev/null
+++ b/libheif/codecs/encoder.cc
@@ -0,0 +1,168 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "codecs/encoder.h"
+
+#include "error.h"
+#include "context.h"
+#include "plugin_registry.h"
+#include "api_structs.h"
+#include "color-conversion/colorconversion.h"
+
+
+void Encoder::CodedImageData::append(const uint8_t* data, size_t size)
+{
+  bitstream.insert(bitstream.end(), data, data + size);
+}
+
+
+void Encoder::CodedImageData::append_with_4bytes_size(const uint8_t* data, size_t size)
+{
+  assert(size <= 0xFFFFFFFF);
+
+  uint8_t size_field[4];
+  size_field[0] = (uint8_t) ((size >> 24) & 0xFF);
+  size_field[1] = (uint8_t) ((size >> 16) & 0xFF);
+  size_field[2] = (uint8_t) ((size >> 8) & 0xFF);
+  size_field[3] = (uint8_t) ((size >> 0) & 0xFF);
+
+  bitstream.insert(bitstream.end(), size_field, size_field + 4);
+  bitstream.insert(bitstream.end(), data, data + size);
+}
+
+
+
+static nclx_profile compute_target_nclx_profile(const std::shared_ptr<HeifPixelImage>& image, const heif_color_profile_nclx* output_nclx_profile)
+{
+  nclx_profile target_nclx_profile;
+
+  // If there is an output NCLX specified, use that.
+  if (output_nclx_profile) {
+    target_nclx_profile.set_from_heif_color_profile_nclx(output_nclx_profile);
+  }
+    // Otherwise, if there is an input NCLX, keep that.
+  else if (image->has_nclx_color_profile()) {
+    target_nclx_profile = image->get_color_profile_nclx();
+  }
+    // Otherwise, just use the defaults (set below)
+  else {
+    target_nclx_profile.set_undefined();
+  }
+
+  target_nclx_profile.replace_undefined_values_with_sRGB_defaults();
+
+  return target_nclx_profile;
+}
+
+
+static bool nclx_profile_matches_spec(heif_colorspace colorspace,
+                                      std::optional<nclx_profile> image_nclx,
+                                      const heif_color_profile_nclx* spec_nclx)
+{
+  if (colorspace != heif_colorspace_YCbCr) {
+    return true;
+  }
+
+  // No target specification -> always matches
+  if (!spec_nclx) {
+    return true;
+  }
+
+  if (!image_nclx) {
+    static nclx_profile default_nclx;
+    default_nclx.set_sRGB_defaults();
+
+    // if no input nclx is specified, compare against default one
+    image_nclx = default_nclx;
+  }
+
+  if (image_nclx->get_full_range_flag() != (spec_nclx->full_range_flag == 0 ? false : true)) {
+    return false;
+  }
+
+  if (image_nclx->get_matrix_coefficients() != spec_nclx->matrix_coefficients) {
+    return false;
+  }
+
+  // TODO: are the colour primaries relevant for matrix-coefficients != 12,13 ?
+  //       If not, we should skip this test for anything else than matrix-coefficients != 12,13.
+  if (image_nclx->get_colour_primaries() != spec_nclx->color_primaries) {
+    return false;
+  }
+
+  return true;
+}
+
+
+extern void fill_default_color_conversion_options_ext(heif_color_conversion_options_ext& options);
+
+Result<std::shared_ptr<HeifPixelImage>> Encoder::convert_colorspace_for_encoding(const std::shared_ptr<HeifPixelImage>& image,
+                                                                                 heif_encoder* encoder,
+                                                                                 const heif_color_profile_nclx* user_requested_output_nclx,
+                                                                                 const heif_color_conversion_options* color_conversion_options,
+                                                                                 const heif_security_limits* security_limits)
+{
+  const heif_color_profile_nclx* output_nclx_profile;
+
+  if (const auto* nclx = get_forced_output_nclx()) {
+    output_nclx_profile = nclx;
+  } else {
+    output_nclx_profile = user_requested_output_nclx;
+  }
+
+
+  heif_colorspace colorspace = image->get_colorspace();
+  heif_chroma chroma = image->get_chroma_format();
+
+  if (encoder->plugin->plugin_api_version >= 2) {
+    encoder->plugin->query_input_colorspace2(encoder->encoder, &colorspace, &chroma);
+  }
+  else {
+    encoder->plugin->query_input_colorspace(&colorspace, &chroma);
+  }
+
+
+  // If output format forces an NCLX, use that. Otherwise use user selected NCLX.
+
+  nclx_profile target_nclx_profile = compute_target_nclx_profile(image, output_nclx_profile);
+
+  // --- convert colorspace
+
+  std::shared_ptr<HeifPixelImage> output_image;
+
+  const std::optional<nclx_profile> image_nclx = image->get_color_profile_nclx();
+
+  if (colorspace == image->get_colorspace() &&
+      chroma == image->get_chroma_format() &&
+      nclx_profile_matches_spec(colorspace, image_nclx, output_nclx_profile)) {
+    return image;
+  }
+
+
+  // @TODO: use color profile when converting
+  int output_bpp = 0; // same as input
+
+  //auto target_nclx = std::make_shared<color_profile_nclx>();
+  //target_nclx->set_from_heif_color_profile_nclx(target_heif_nclx);
+
+  return convert_colorspace(image, colorspace, chroma, target_nclx_profile,
+                            output_bpp, *color_conversion_options, nullptr,
+                            security_limits);
+}
diff --git a/libheif/codecs/encoder.h b/libheif/codecs/encoder.h
new file mode 100644
index 0000000000..ba51d0e0eb
--- /dev/null
+++ b/libheif/codecs/encoder.h
@@ -0,0 +1,93 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef HEIF_ENCODER_H
+#define HEIF_ENCODER_H
+
+#include "libheif/heif.h"
+#include "error.h"
+#include "libheif/heif_plugin.h"
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+#include "sequences/seq_boxes.h"
+
+class HeifPixelImage;
+
+class Box;
+
+
+class Encoder {
+public:
+  virtual ~Encoder() = default;
+
+  struct CodedImageData {
+    std::vector<std::shared_ptr<Box>> properties;
+    std::vector<uint8_t> bitstream;
+    CodingConstraints codingConstraints;
+
+    // If 0, the encoded size is unknown.
+    uint32_t encoded_image_width = 0;
+    uint32_t encoded_image_height = 0;
+
+    bool is_sync_frame = true; // TODO: set in encoder
+    uintptr_t frame_nr = 0;
+
+    void append(const uint8_t* data, size_t size);
+
+    void append_with_4bytes_size(const uint8_t* data, size_t size);
+  };
+
+  // If the output format requires a specific nclx (like JPEG), return this. Otherwise, return NULL.
+  virtual const heif_color_profile_nclx* get_forced_output_nclx() const { return nullptr; }
+
+  Result<std::shared_ptr<HeifPixelImage>> convert_colorspace_for_encoding(const std::shared_ptr<HeifPixelImage>& image,
+                                                                          heif_encoder* encoder,
+                                                                          const heif_color_profile_nclx* user_requested_output_nclx,
+                                                                          const heif_color_conversion_options* color_conversion_options,
+                                                                          const heif_security_limits* security_limits);
+
+  virtual Result<CodedImageData> encode(const std::shared_ptr<HeifPixelImage>& image,
+                                        heif_encoder* encoder,
+                                        const heif_encoding_options& options,
+                                        heif_image_input_class input_class) { return {}; }
+
+  // --- encode sequence
+
+  virtual bool encode_sequence_started() const { return false; }
+
+  virtual Error encode_sequence_frame(const std::shared_ptr<HeifPixelImage>& image,
+                                      heif_encoder* encoder,
+                                      const heif_sequence_encoding_options& options,
+                                      heif_image_input_class input_class,
+                                      uint32_t framerate_num, uint32_t framerate_denom,
+                                      uintptr_t frame_number) { return {}; }
+
+  virtual Error encode_sequence_flush(heif_encoder* encoder) { return {}; }
+
+  virtual std::optional<CodedImageData> encode_sequence_get_data() { return std::nullopt; }
+
+  virtual std::shared_ptr<Box_VisualSampleEntry> get_sample_description_box(const CodedImageData&) const { return {}; }
+};
+
+
+#endif
diff --git a/libheif/codecs/hevc_boxes.cc b/libheif/codecs/hevc_boxes.cc
new file mode 100644
index 0000000000..2a4e8bb260
--- /dev/null
+++ b/libheif/codecs/hevc_boxes.cc
@@ -0,0 +1,712 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "hevc_boxes.h"
+#include "bitstream.h"
+#include "error.h"
+#include "file.h"
+#include "hevc_dec.h"
+
+#include <cassert>
+#include <cmath>
+#include <cstring>
+#include <iomanip>
+#include <string>
+#include <utility>
+#include <algorithm>
+#include "api_structs.h"
+
+
+Error HEVCDecoderConfigurationRecord::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  uint8_t byte;
+
+  configuration_version = range.read8();
+  byte = range.read8();
+  general_profile_space = (byte >> 6) & 3;
+  general_tier_flag = (byte >> 5) & 1;
+  general_profile_idc = (byte & 0x1F);
+
+  general_profile_compatibility_flags = range.read32();
+
+  for (int i = 0; i < 6; i++) {
+    byte = range.read8();
+
+    for (int b = 0; b < 8; b++) {
+      general_constraint_indicator_flags[i * 8 + b] = (byte >> (7 - b)) & 1;
+    }
+  }
+
+  general_level_idc = range.read8();
+  min_spatial_segmentation_idc = range.read16() & 0x0FFF;
+  parallelism_type = range.read8() & 0x03;
+  chroma_format = range.read8() & 0x03;
+  bit_depth_luma = static_cast<uint8_t>((range.read8() & 0x07) + 8);
+  bit_depth_chroma = static_cast<uint8_t>((range.read8() & 0x07) + 8);
+  avg_frame_rate = range.read16();
+
+  byte = range.read8();
+  constant_frame_rate = (byte >> 6) & 0x03;
+  num_temporal_layers = (byte >> 3) & 0x07;
+  temporal_id_nested = (byte >> 2) & 1;
+
+  m_length_size = static_cast<uint8_t>((byte & 0x03) + 1);
+
+  int nArrays = range.read8();
+
+  for (int i = 0; i < nArrays && !range.error(); i++) {
+    byte = range.read8();
+
+    NalArray array;
+
+    array.m_array_completeness = (byte >> 6) & 1;
+    array.m_NAL_unit_type = (byte & 0x3F);
+
+    int nUnits = range.read16();
+    for (int u = 0; u < nUnits && !range.error(); u++) {
+
+      std::vector<uint8_t> nal_unit;
+      int size = range.read16();
+      if (!size) {
+        // Ignore empty NAL units.
+        continue;
+      }
+
+      if (range.prepare_read(size)) {
+        nal_unit.resize(size);
+        bool success = range.get_istream()->read((char*) nal_unit.data(), size);
+        if (!success) {
+          return Error{heif_error_Invalid_input, heif_suberror_End_of_data, "error while reading hvcC box"};
+        }
+      }
+
+      array.m_nal_units.push_back(std::move(nal_unit));
+    }
+
+    m_nal_array.push_back(std::move(array));
+  }
+
+  range.skip_to_end_of_box();
+
+  return range.get_error();
+}
+
+
+Error HEVCDecoderConfigurationRecord::write(StreamWriter& writer) const
+{
+  writer.write8(configuration_version);
+
+  writer.write8((uint8_t) (((general_profile_space & 3) << 6) |
+                           ((general_tier_flag & 1) << 5) |
+                           (general_profile_idc & 0x1F)));
+
+  writer.write32(general_profile_compatibility_flags);
+
+  for (int i = 0; i < 6; i++) {
+    uint8_t byte = 0;
+
+    for (int b = 0; b < 8; b++) {
+      if (general_constraint_indicator_flags[i * 8 + b]) {
+        byte |= 1;
+      }
+
+      byte = (uint8_t) (byte << 1);
+    }
+
+    writer.write8(byte);
+  }
+
+  writer.write8(general_level_idc);
+  writer.write16((min_spatial_segmentation_idc & 0x0FFF) | 0xF000);
+  writer.write8(parallelism_type | 0xFC);
+  writer.write8(chroma_format | 0xFC);
+  writer.write8((uint8_t) ((bit_depth_luma - 8) | 0xF8));
+  writer.write8((uint8_t) ((bit_depth_chroma - 8) | 0xF8));
+  writer.write16(avg_frame_rate);
+
+  writer.write8((uint8_t) (((constant_frame_rate & 0x03) << 6) |
+                           ((num_temporal_layers & 0x07) << 3) |
+                           ((temporal_id_nested & 1) << 2) |
+                           ((m_length_size - 1) & 0x03)));
+
+  size_t nArrays = m_nal_array.size();
+  // There cannot be an overflow because the nal-type is less than 8-bit.
+  assert(nArrays <= 0xFF);
+
+  writer.write8(static_cast<uint8_t>(nArrays));
+
+  for (const HEVCDecoderConfigurationRecord::NalArray& array : m_nal_array) {
+
+    writer.write8((uint8_t) (((array.m_array_completeness & 1) << 6) |
+                             (array.m_NAL_unit_type & 0x3F)));
+
+    size_t nUnits = array.m_nal_units.size();
+    if (nUnits > 0xFFFF) {
+      return Error{heif_error_Invalid_input, heif_suberror_Unspecified, "Too many NAL units in hvcC"};
+    }
+
+    writer.write16(static_cast<uint16_t>(nUnits));
+
+    for (const std::vector<uint8_t>& nal_unit : array.m_nal_units) {
+      if (nal_unit.size() > 0xFFFF) {
+        return Error{heif_error_Invalid_input, heif_suberror_Unspecified, "hvcC NAL unit exceeds maximum size (64kB)"};
+      }
+
+      writer.write16(static_cast<uint16_t>(nal_unit.size()));
+      writer.write(nal_unit);
+    }
+  }
+
+  return Error::Ok;
+}
+
+
+bool HEVCDecoderConfigurationRecord::get_general_profile_compatibility_flag(int idx) const
+{
+  return general_profile_compatibility_flags & (UINT32_C(0x80000000) >> idx);
+}
+
+
+bool HEVCDecoderConfigurationRecord::is_profile_compatibile(Profile profile) const
+{
+  return (general_profile_idc == profile ||
+          get_general_profile_compatibility_flag(profile));
+}
+
+
+Error Box_hvcC::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  return m_configuration.parse(range, limits);
+}
+
+
+std::string Box_hvcC::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
+
+  const auto& c = m_configuration; // abbreviation
+
+  sstr << indent << "configuration_version: " << ((int) c.configuration_version) << "\n"
+       << indent << "general_profile_space: " << ((int) c.general_profile_space) << "\n"
+       << indent << "general_tier_flag: " << c.general_tier_flag << "\n"
+       << indent << "general_profile_idc: " << ((int) c.general_profile_idc) << "\n";
+
+  sstr << indent << "general_profile_compatibility_flags: ";
+  for (int i = 0; i < 32; i++) {
+    sstr << ((c.general_profile_compatibility_flags >> (31 - i)) & 1);
+    if ((i % 8) == 7) sstr << ' ';
+    else if ((i % 4) == 3) sstr << '.';
+  }
+  sstr << "\n";
+
+  sstr << indent << "general_constraint_indicator_flags: ";
+  int cnt = 0;
+  for (int i = 0; i < HEVCDecoderConfigurationRecord::NUM_CONSTRAINT_INDICATOR_FLAGS; i++) {
+    bool b = c.general_constraint_indicator_flags[i];
+
+    sstr << (b ? 1 : 0);
+    cnt++;
+    if ((cnt % 8) == 0)
+      sstr << ' ';
+  }
+  sstr << "\n";
+
+  sstr << indent << "general_level_idc: " << ((int) c.general_level_idc) << "\n"
+       << indent << "min_spatial_segmentation_idc: " << c.min_spatial_segmentation_idc << "\n"
+       << indent << "parallelism_type: " << ((int) c.parallelism_type) << "\n"
+       << indent << "chroma_format: ";
+
+  switch (c.chroma_format) {
+    case 0:
+      sstr << "monochrome";
+      break;
+    case 1:
+      sstr << "4:2:0";
+      break;
+    case 2:
+      sstr << "4:2:2";
+      break;
+    case 3:
+      sstr << "4:4:4";
+      break;
+    default:
+      sstr << ((int) c.chroma_format);
+      break;
+  }
+
+  sstr << "\n"
+       << indent << "bit_depth_luma: " << ((int) c.bit_depth_luma) << "\n"
+       << indent << "bit_depth_chroma: " << ((int) c.bit_depth_chroma) << "\n"
+       << indent << "avg_frame_rate: " << c.avg_frame_rate << "\n"
+       << indent << "constant_frame_rate: " << ((int) c.constant_frame_rate) << "\n"
+       << indent << "num_temporal_layers: " << ((int) c.num_temporal_layers) << "\n"
+       << indent << "temporal_id_nested: " << ((int) c.temporal_id_nested) << "\n"
+       << indent << "length_size: " << ((int) c.m_length_size) << "\n";
+
+  for (const auto& array : c.m_nal_array) {
+    sstr << indent << "<array>\n";
+
+    indent++;
+    sstr << indent << "array_completeness: " << ((int) array.m_array_completeness) << "\n"
+         << indent << "NAL_unit_type: " << ((int) array.m_NAL_unit_type) << "\n";
+
+    for (const auto& unit : array.m_nal_units) {
+      //sstr << "  unit with " << unit.size() << " bytes of data\n";
+      sstr << indent;
+      for (uint8_t b : unit) {
+        sstr << std::setfill('0') << std::setw(2) << std::hex << ((int) b) << " ";
+      }
+      sstr << "\n";
+      sstr << std::dec;
+    }
+
+    indent--;
+  }
+
+  return sstr.str();
+}
+
+
+bool Box_hvcC::get_header_nals(std::vector<uint8_t>* dest) const
+{
+  // Concatenate all header NALs, each prefixed by a 4-byte size.
+
+  for (const auto& array : m_configuration.m_nal_array) {
+    for (const auto& unit : array.m_nal_units) {
+
+      // Write 4-byte NALs size
+
+      dest->push_back((unit.size() >> 24) & 0xFF);
+      dest->push_back((unit.size() >> 16) & 0xFF);
+      dest->push_back((unit.size() >> 8) & 0xFF);
+      dest->push_back((unit.size() >> 0) & 0xFF);
+
+      // Copy NAL data
+
+      dest->insert(dest->end(), unit.begin(), unit.end());
+    }
+  }
+
+  return true;
+}
+
+void Box_hvcC::append_nal_data(const uint8_t* data, size_t size)
+{
+  std::vector<uint8_t> nal;
+  nal.resize(size);
+  memcpy(nal.data(), data, size);
+
+  append_nal_data(nal);
+}
+
+void Box_hvcC::append_nal_data(const std::vector<uint8_t>& nal)
+{
+  for (auto& nal_array : m_configuration.m_nal_array) {
+    if (nal_array.m_NAL_unit_type == uint8_t(nal[0] >> 1)) {
+
+      // kvazaar may send the same headers multiple times. Filter out the identical copies.
+
+      for (auto& nal_unit : nal_array.m_nal_units) {
+
+        // Note: sometimes kvazaar even sends the same packet twice, but with an extra zero byte.
+        //       We detect this by comparing only the common length. This is correct since each NAL
+        //       packet must be complete and thus, if a packet is longer than another complete packet,
+        //       its extra data must be superfluous.
+        //
+        // Example:
+        //| | | <array>
+        //| | | | array_completeness: 1
+        //| | | | NAL_unit_type: 34
+        //| | | | 44 01 c1 71 82 99 20 00
+        //| | | | 44 01 c1 71 82 99 20
+
+        // Check whether packets have similar content.
+
+        const size_t common_length = std::min(nal_unit.size(), nal.size());
+        bool similar = true;
+        for (size_t i = 0; i < common_length; i++) {
+          if (nal_unit[i] != nal[i]) {
+            similar = false;
+            break;
+          }
+        }
+
+        if (similar) {
+          // If they are similar, keep the smaller one.
+
+          if (nal_unit.size() > nal.size()) {
+            nal_unit = std::move(nal);
+          }
+
+          // Exit. Do not add a copy of the packet.
+
+          return;
+        }
+      }
+
+      nal_array.m_nal_units.push_back(std::move(nal));
+
+      return;
+    }
+  }
+
+  // This is a new NAL type. Add a new NAL array.
+
+  HEVCDecoderConfigurationRecord::NalArray array;
+  array.m_array_completeness = 1;
+  array.m_NAL_unit_type = uint8_t(nal[0] >> 1);
+  array.m_nal_units.push_back(std::move(nal));
+
+  m_configuration.m_nal_array.push_back(array);
+}
+
+
+Error Box_hvcC::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  const auto& c = m_configuration; // abbreviation
+
+  Error err = c.write(writer);
+  if (err) {
+    return err;
+  }
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+
+static double read_depth_rep_info_element(BitReader& reader)
+{
+  uint8_t sign_flag = reader.get_bits8(1);
+  int exponent = reader.get_bits(7);
+  auto mantissa_len = static_cast<uint8_t>(reader.get_bits8(5) + 1);
+  if (mantissa_len < 1 || mantissa_len > 32) {
+    // TODO err
+  }
+
+  if (exponent == 127) {
+    // TODO value unspecified
+  }
+
+  uint32_t mantissa = reader.get_bits32(mantissa_len);
+  double value;
+
+  //printf("sign:%d exponent:%d mantissa_len:%d mantissa:%d\n",sign_flag,exponent,mantissa_len,mantissa);
+
+  // TODO: this seems to be wrong. 'exponent' is never negative. How to read it correctly?
+  if (exponent > 0) {
+    value = pow(2.0, exponent - 31) * (1.0 + mantissa / pow(2.0, mantissa_len));
+  }
+  else {
+    value = pow(2.0, -(30 + mantissa_len)) * mantissa;
+  }
+
+  if (sign_flag) {
+    value = -value;
+  }
+
+  return value;
+}
+
+
+static Result<std::shared_ptr<SEIMessage>> read_depth_representation_info(BitReader& reader)
+{
+  auto msg = std::make_shared<SEIMessage_depth_representation_info>();
+
+
+  // default values
+
+  msg->version = 1;
+
+  msg->disparity_reference_view = 0;
+  msg->depth_nonlinear_representation_model_size = 0;
+  msg->depth_nonlinear_representation_model = nullptr;
+
+
+  // read header
+
+  msg->has_z_near = (uint8_t) reader.get_bits(1);
+  msg->has_z_far = (uint8_t) reader.get_bits(1);
+  msg->has_d_min = (uint8_t) reader.get_bits(1);
+  msg->has_d_max = (uint8_t) reader.get_bits(1);
+
+  int rep_type;
+  if (!reader.get_uvlc(&rep_type)) {
+    return Error{heif_error_Invalid_input, heif_suberror_Invalid_parameter_value, "invalid depth representation type in input"};
+  }
+
+  if (rep_type < 0 || rep_type > 3) {
+    return Error{heif_error_Invalid_input, heif_suberror_Invalid_parameter_value, "input depth representation type out of range"};
+  }
+
+  msg->depth_representation_type = (enum heif_depth_representation_type) rep_type;
+
+  //printf("flags: %d %d %d %d\n",msg->has_z_near,msg->has_z_far,msg->has_d_min,msg->has_d_max);
+  //printf("type: %d\n",rep_type);
+
+  if (msg->has_d_min || msg->has_d_max) {
+    int ref_view;
+    if (!reader.get_uvlc(&ref_view)) {
+      return Error{heif_error_Invalid_input, heif_suberror_Invalid_parameter_value, "invalid disparity_reference_view in input"};
+    }
+    msg->disparity_reference_view = ref_view;
+
+    //printf("ref_view: %d\n",msg->disparity_reference_view);
+  }
+
+  if (msg->has_z_near) msg->z_near = read_depth_rep_info_element(reader);
+  if (msg->has_z_far) msg->z_far = read_depth_rep_info_element(reader);
+  if (msg->has_d_min) msg->d_min = read_depth_rep_info_element(reader);
+  if (msg->has_d_max) msg->d_max = read_depth_rep_info_element(reader);
+
+  /*
+  printf("z_near: %f\n",msg->z_near);
+  printf("z_far: %f\n",msg->z_far);
+  printf("dmin: %f\n",msg->d_min);
+  printf("dmax: %f\n",msg->d_max);
+  */
+
+  if (msg->depth_representation_type == heif_depth_representation_type_nonuniform_disparity) {
+    // TODO: load non-uniform response curve
+  }
+
+  return {msg};
+}
+
+
+// aux subtypes: 00 00 00 11 / 00 00 00 0d / 4e 01 / b1 09 / 35 1e 78 c8 01 03 c5 d0 20
+
+Error decode_hevc_aux_sei_messages(const std::vector<uint8_t>& data,
+                                   std::vector<std::shared_ptr<SEIMessage>>& msgs)
+{
+  // TODO: we probably do not need a full BitReader just for the array size.
+  // Read this and the NAL size directly on the array data.
+
+  BitReader reader(data.data(), (int) data.size());
+  if (reader.get_bits_remaining() < 32) {
+    return {heif_error_Invalid_input,
+            heif_suberror_End_of_data,
+            "HEVC SEI NAL too short"};
+  }
+
+  uint32_t len = reader.get_bits32(32);
+
+  if (len > data.size() - 4) {
+    // ERROR: read past end of data
+  }
+
+  while (reader.get_current_byte_index() < (int) len) {
+    int currPos = reader.get_current_byte_index();
+
+    BitReader sei_reader(data.data() + currPos, (int) data.size() - currPos);
+
+    if (sei_reader.get_bits_remaining() < 32+8) {
+      return {heif_error_Invalid_input,
+              heif_suberror_End_of_data,
+              "HEVC SEI NAL too short"};
+    }
+
+    uint32_t nal_size = sei_reader.get_bits32(32);
+    (void) nal_size;
+
+    auto nal_type = static_cast<uint8_t>(sei_reader.get_bits8(8) >> 1);
+    sei_reader.skip_bits(8);
+
+    // SEI
+
+    if (nal_type == 39 ||
+        nal_type == 40) {
+
+      if (sei_reader.get_bits_remaining() < 16) {
+        return {heif_error_Invalid_input,
+                heif_suberror_End_of_data,
+                "HEVC SEI NAL too short"};
+      }
+
+      // TODO: loading of multi-byte sei headers
+      uint8_t payload_id = sei_reader.get_bits8(8);
+      uint8_t payload_size = sei_reader.get_bits8(8);
+      (void) payload_size;
+
+      if (payload_id == 177) {
+        // depth_representation_info
+        Result<std::shared_ptr<SEIMessage>> seiResult = read_depth_representation_info(sei_reader);
+        if (!seiResult) {
+          return seiResult.error();
+        }
+
+        msgs.push_back(*seiResult);
+      }
+    }
+
+    break; // TODO: read next SEI
+  }
+
+
+  return Error::Ok;
+}
+
+
+// Used for AVC, HEVC, and VVC.
+std::vector<uint8_t> remove_start_code_emulation(const uint8_t* sps, size_t size)
+{
+  std::vector<uint8_t> out_data;
+
+  for (size_t i = 0; i < size; i++) {
+    if (i + 2 < size &&
+        sps[i] == 0 &&
+        sps[i + 1] == 0 &&
+        sps[i + 2] == 3) {
+      out_data.push_back(0);
+      out_data.push_back(0);
+      i += 2;
+    }
+    else {
+      out_data.push_back(sps[i]);
+    }
+  }
+
+  return out_data;
+}
+
+
+Error parse_sps_for_hvcC_configuration(const uint8_t* sps, size_t size,
+                                       HEVCDecoderConfigurationRecord* config,
+                                       int* width, int* height)
+{
+  // remove start-code emulation bytes from SPS header stream
+
+  std::vector<uint8_t> sps_no_emul = remove_start_code_emulation(sps, size);
+
+  sps = sps_no_emul.data();
+  size = sps_no_emul.size();
+
+
+  BitReader reader(sps, (int) size);
+
+  // skip NAL header
+  reader.skip_bits(2 * 8);
+
+  // skip VPS ID
+  reader.skip_bits(4);
+
+  uint8_t nMaxSubLayersMinus1 = reader.get_bits8(3);
+
+  config->temporal_id_nested = reader.get_bits8(1);
+
+  // --- profile_tier_level ---
+
+  config->general_profile_space = reader.get_bits8(2);
+  config->general_tier_flag = reader.get_bits8(1);
+  config->general_profile_idc = reader.get_bits8(5);
+  config->general_profile_compatibility_flags = reader.get_bits32(32);
+
+  reader.skip_bits(16); // skip reserved bits
+  reader.skip_bits(16); // skip reserved bits
+  reader.skip_bits(16); // skip reserved bits
+
+  config->general_level_idc = reader.get_bits8(8);
+
+  std::vector<bool> layer_profile_present(nMaxSubLayersMinus1);
+  std::vector<bool> layer_level_present(nMaxSubLayersMinus1);
+
+  for (int i = 0; i < nMaxSubLayersMinus1; i++) {
+    layer_profile_present[i] = reader.get_bits(1);
+    layer_level_present[i] = reader.get_bits(1);
+  }
+
+  if (nMaxSubLayersMinus1 > 0) {
+    for (int i = nMaxSubLayersMinus1; i < 8; i++) {
+      reader.skip_bits(2);
+    }
+  }
+
+  for (int i = 0; i < nMaxSubLayersMinus1; i++) {
+    if (layer_profile_present[i]) {
+      reader.skip_bits(2 + 1 + 5);
+      reader.skip_bits(32);
+      reader.skip_bits(16);
+    }
+
+    if (layer_level_present[i]) {
+      reader.skip_bits(8);
+    }
+  }
+
+
+  // --- SPS continued ---
+
+  int dummy, value;
+  reader.get_uvlc(&dummy); // skip seq_parameter_seq_id
+
+  reader.get_uvlc(&value);
+  config->chroma_format = (uint8_t) value;
+
+  if (config->chroma_format == 3) {
+    reader.skip_bits(1);
+  }
+
+  reader.get_uvlc(width);
+  reader.get_uvlc(height);
+
+  bool conformance_window = reader.get_bits(1);
+  if (conformance_window) {
+    int left, right, top, bottom;
+    reader.get_uvlc(&left);
+    reader.get_uvlc(&right);
+    reader.get_uvlc(&top);
+    reader.get_uvlc(&bottom);
+
+    //printf("conformance borders: %d %d %d %d\n",left,right,top,bottom);
+
+    int subH = 1, subV = 1;
+    if (config->chroma_format == 1) {
+      subV = 2;
+      subH = 2;
+    }
+    if (config->chroma_format == 2) { subH = 2; }
+
+    *width -= subH * (left + right);
+    *height -= subV * (top + bottom);
+  }
+
+  reader.get_uvlc(&value);
+  config->bit_depth_luma = (uint8_t) (value + 8);
+
+  reader.get_uvlc(&value);
+  config->bit_depth_chroma = (uint8_t) (value + 8);
+
+
+
+  // --- init static configuration fields ---
+
+  config->configuration_version = 1;
+  config->min_spatial_segmentation_idc = 0; // TODO: get this value from the VUI, 0 should be safe
+  config->parallelism_type = 0; // TODO, 0 should be safe
+  config->avg_frame_rate = 0; // makes no sense for HEIF (TODO)
+  config->constant_frame_rate = 0; // makes no sense for HEIF (TODO)
+  config->num_temporal_layers = 1; // makes no sense for HEIF
+
+  return Error::Ok;
+}
diff --git a/libheif/codecs/hevc_boxes.h b/libheif/codecs/hevc_boxes.h
new file mode 100644
index 0000000000..80eacb101e
--- /dev/null
+++ b/libheif/codecs/hevc_boxes.h
@@ -0,0 +1,169 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef HEIF_HEVC_BOXES_H
+#define HEIF_HEVC_BOXES_H
+
+#include "libheif/heif.h"
+#include "box.h"
+#include "error.h"
+
+#include <memory>
+#include <string>
+#include <vector>
+#include "image-items/image_item.h"
+#include "sequences/seq_boxes.h"
+
+
+struct HEVCDecoderConfigurationRecord
+{
+  uint8_t configuration_version;
+  uint8_t general_profile_space;
+  bool general_tier_flag;
+  uint8_t general_profile_idc;
+  uint32_t general_profile_compatibility_flags;
+
+  static const int NUM_CONSTRAINT_INDICATOR_FLAGS = 48;
+  std::bitset<NUM_CONSTRAINT_INDICATOR_FLAGS> general_constraint_indicator_flags;
+
+  uint8_t general_level_idc;
+
+  uint16_t min_spatial_segmentation_idc;
+  uint8_t parallelism_type;
+  uint8_t chroma_format;
+  uint8_t bit_depth_luma;
+  uint8_t bit_depth_chroma;
+  uint16_t avg_frame_rate;
+
+  uint8_t constant_frame_rate;
+  uint8_t num_temporal_layers;
+  uint8_t temporal_id_nested;
+  uint8_t m_length_size = 4; // default: 4 bytes for NAL unit lengths
+
+  struct NalArray
+  {
+    uint8_t m_array_completeness;
+    uint8_t m_NAL_unit_type;
+
+    std::vector<std::vector<uint8_t> > m_nal_units;
+  };
+
+  enum Profile {
+    Profile_Main = 1,
+    Profile_Main10 = 2,
+    Profile_MainStillPicture = 3,
+    Profile_RExt = 4,
+    Profile_HighThroughput = 5,
+    Profile_ScreenCoding = 9,
+    Profile_HighTHroughputScreenCoding = 11
+  };
+
+  std::vector<NalArray> m_nal_array;
+
+  Error parse(BitstreamRange& range, const heif_security_limits* limits);
+
+  Error write(StreamWriter& writer) const;
+
+  bool get_general_profile_compatibility_flag(int idx) const;
+
+  bool is_profile_compatibile(Profile) const;
+};
+
+
+class Box_hvcC : public Box
+{
+// allow access to protected parse() method
+friend class Box_mini;
+
+public:
+  Box_hvcC()
+  {
+    set_short_type(fourcc("hvcC"));
+  }
+
+  bool is_essential() const override { return true; }
+
+
+  std::string dump(Indent&) const override;
+
+  const char* debug_box_name() const override { return "HEVC Configuration Item"; }
+
+  bool get_header_nals(std::vector<uint8_t>* dest) const;
+
+  void set_configuration(const HEVCDecoderConfigurationRecord& config) { m_configuration = config; }
+
+  const HEVCDecoderConfigurationRecord& get_configuration() const { return m_configuration; }
+
+  HEVCDecoderConfigurationRecord& get_configuration() { return m_configuration; }
+
+  // Add a header NAL to the hvcC. The data is the raw NAL data without any start-code or NAL size field.
+  //
+  // Note: we expect that all header NALs are added to the hvcC and
+  // there are no additional header NALs in the bitstream.
+  void append_nal_data(const std::vector<uint8_t>& nal);
+
+  void append_nal_data(const uint8_t* data, size_t size);
+
+  Error write(StreamWriter& writer) const override;
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits* limits) override;
+
+private:
+  HEVCDecoderConfigurationRecord m_configuration;
+};
+
+
+class Box_hvc1 : public Box_VisualSampleEntry
+{
+public:
+  Box_hvc1()
+  {
+    set_short_type(fourcc("hvc1"));
+  }
+};
+
+
+
+class SEIMessage
+{
+public:
+  virtual ~SEIMessage() = default;
+};
+
+
+class SEIMessage_depth_representation_info : public SEIMessage,
+                                             public heif_depth_representation_info
+{
+public:
+};
+
+
+Error decode_hevc_aux_sei_messages(const std::vector<uint8_t>& data,
+                                   std::vector<std::shared_ptr<SEIMessage>>& msgs);
+
+// Used for AVC, HEVC, and VVC.
+std::vector<uint8_t> remove_start_code_emulation(const uint8_t* sps, size_t size);
+
+Error parse_sps_for_hvcC_configuration(const uint8_t* sps, size_t size,
+                                       HEVCDecoderConfigurationRecord* inout_config,
+                                       int* width, int* height);
+
+#endif
diff --git a/libheif/codecs/hevc_dec.cc b/libheif/codecs/hevc_dec.cc
new file mode 100644
index 0000000000..a8a24bb7cd
--- /dev/null
+++ b/libheif/codecs/hevc_dec.cc
@@ -0,0 +1,65 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "hevc_dec.h"
+#include "hevc_boxes.h"
+#include "error.h"
+#include "context.h"
+
+#include <string>
+
+
+Result<std::vector<uint8_t>> Decoder_HEVC::read_bitstream_configuration_data() const
+{
+  std::vector<uint8_t> data;
+  if (!m_hvcC->get_header_nals(&data)) {
+    return Error{heif_error_Invalid_input,
+                 heif_suberror_No_item_data};
+  }
+
+  return data;
+}
+
+
+int Decoder_HEVC::get_luma_bits_per_pixel() const
+{
+  return m_hvcC->get_configuration().bit_depth_luma;
+}
+
+
+int Decoder_HEVC::get_chroma_bits_per_pixel() const
+{
+  return m_hvcC->get_configuration().bit_depth_chroma;
+}
+
+
+Error Decoder_HEVC::get_coded_image_colorspace(heif_colorspace* out_colorspace, heif_chroma* out_chroma) const
+{
+  *out_chroma = (heif_chroma) (m_hvcC->get_configuration().chroma_format);
+
+  if (*out_chroma == heif_chroma_monochrome) {
+    *out_colorspace = heif_colorspace_monochrome;
+  }
+  else {
+    *out_colorspace = heif_colorspace_YCbCr;
+  }
+
+  return Error::Ok;
+}
diff --git a/libheif/heif_hevc.h b/libheif/codecs/hevc_dec.h
similarity index 51%
rename from libheif/heif_hevc.h
rename to libheif/codecs/hevc_dec.h
index d860e2952d..ac4e67e0f0 100644
--- a/libheif/heif_hevc.h
+++ b/libheif/codecs/hevc_dec.h
@@ -1,6 +1,6 @@
 /*
  * HEIF codec.
- * Copyright (c) 2017 struktur AG, Dirk Farin <farin@struktur.de>
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
  *
  * This file is part of libheif.
  *
@@ -18,41 +18,37 @@
  * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef HEIF_HEVC_H
-#define HEIF_HEVC_H
+#ifndef HEIF_HEVC_DEC_H
+#define HEIF_HEVC_DEC_H
 
-#include "heif.h"
+#include "libheif/heif.h"
 #include "box.h"
 #include "error.h"
 
 #include <memory>
 #include <vector>
+#include <codecs/decoder.h>
 
+class Box_hvcC;
 
-namespace heif {
 
-  class SEIMessage
-  {
-  public:
-    virtual ~SEIMessage() = default;
-  };
+class Decoder_HEVC : public Decoder
+{
+public:
+  explicit Decoder_HEVC(const std::shared_ptr<const Box_hvcC>& hvcC) : m_hvcC(hvcC) {}
 
+  heif_compression_format get_compression_format() const override { return heif_compression_HEVC; }
 
-  class SEIMessage_depth_representation_info : public SEIMessage,
-                                               public heif_depth_representation_info
-  {
-  public:
-  };
+  int get_luma_bits_per_pixel() const override;
 
+  int get_chroma_bits_per_pixel() const override;
 
-  Error decode_hevc_aux_sei_messages(const std::vector<uint8_t>& data,
-                                     std::vector<std::shared_ptr<SEIMessage>>& msgs);
+  Error get_coded_image_colorspace(heif_colorspace*, heif_chroma*) const override;
 
+  Result<std::vector<uint8_t>> read_bitstream_configuration_data() const override;
 
-  Error parse_sps_for_hvcC_configuration(const uint8_t* sps, size_t size,
-                                         Box_hvcC::configuration* inout_config,
-                                         int* width, int* height);
-
-}
+private:
+  const std::shared_ptr<const Box_hvcC> m_hvcC;
+};
 
 #endif
diff --git a/libheif/codecs/hevc_enc.cc b/libheif/codecs/hevc_enc.cc
new file mode 100644
index 0000000000..e06c282af6
--- /dev/null
+++ b/libheif/codecs/hevc_enc.cc
@@ -0,0 +1,309 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "hevc_enc.h"
+#include "hevc_boxes.h"
+#include "error.h"
+#include "context.h"
+#include "api_structs.h"
+
+#include <string>
+
+#include "plugins/nalu_utils.h"
+
+
+// TODO: can we use the new sequences interface for this to avoid duplicate code.
+Result<Encoder::CodedImageData> Encoder_HEVC::encode(const std::shared_ptr<HeifPixelImage>& image,
+                                                     heif_encoder* encoder,
+                                                     const heif_encoding_options& options,
+                                                     heif_image_input_class input_class)
+{
+  CodedImageData codedImage;
+
+  auto hvcC = std::make_shared<Box_hvcC>();
+
+  heif_image c_api_image;
+  c_api_image.image = image;
+
+  heif_error err = encoder->plugin->encode_image(encoder->encoder, &c_api_image, input_class);
+  if (err.code) {
+    return Error(err.code,
+                 err.subcode,
+                 err.message);
+  }
+
+  int encoded_width = 0;
+  int encoded_height = 0;
+
+  for (;;) {
+    uint8_t* data;
+    int size;
+
+    err = encoder->plugin->get_compressed_data(encoder->encoder, &data, &size, nullptr);
+    if (err.code) {
+      return Error(err.code, err.subcode, err.message);
+    }
+
+    if (data == nullptr) {
+      break;
+    }
+
+
+    if ((data[0] >> 1) == HEVC_NAL_UNIT_SPS_NUT) {
+      parse_sps_for_hvcC_configuration(data, size, &hvcC->get_configuration(), &encoded_width, &encoded_height);
+
+      codedImage.encoded_image_width = encoded_width;
+      codedImage.encoded_image_height = encoded_height;
+    }
+
+    switch (data[0] >> 1) {
+      case HEVC_NAL_UNIT_VPS_NUT:
+      case HEVC_NAL_UNIT_SPS_NUT:
+      case HEVC_NAL_UNIT_PPS_NUT:
+        hvcC->append_nal_data(data, size);
+        break;
+
+      default:
+        codedImage.append_with_4bytes_size(data, size);
+    }
+  }
+
+  if (!encoded_width || !encoded_height) {
+    return Error(heif_error_Encoder_plugin_error,
+                 heif_suberror_Invalid_image_size);
+  }
+
+  codedImage.properties.push_back(hvcC);
+
+
+  // Make sure that the encoder plugin works correctly and the encoded image has the correct size.
+
+  if (encoder->plugin->plugin_api_version >= 3 &&
+      encoder->plugin->query_encoded_size != nullptr) {
+    uint32_t check_encoded_width = image->get_width(), check_encoded_height = image->get_height();
+
+    encoder->plugin->query_encoded_size(encoder->encoder,
+                                        image->get_width(), image->get_height(),
+                                        &check_encoded_width,
+                                        &check_encoded_height);
+
+    assert((int)check_encoded_width == encoded_width);
+    assert((int)check_encoded_height == encoded_height);
+  }
+
+  codedImage.codingConstraints.intra_pred_used = true;
+  codedImage.codingConstraints.all_ref_pics_intra = true; // TODO: change when we use predicted frames
+
+  return codedImage;
+}
+
+
+Error Encoder_HEVC::encode_sequence_frame(const std::shared_ptr<HeifPixelImage>& image,
+                                          heif_encoder* encoder,
+                                          const heif_sequence_encoding_options& options,
+                                          heif_image_input_class input_class,
+                                          uint32_t framerate_num, uint32_t framerate_denom,
+                                          uintptr_t frame_number)
+{
+  heif_image c_api_image;
+  c_api_image.image = image;
+
+  if (!m_encoder_active) {
+    heif_error err = encoder->plugin->start_sequence_encoding(encoder->encoder, &c_api_image,
+                                                              input_class,
+                                                              framerate_num, framerate_denom,
+                                                              &options);
+    if (err.code) {
+      return {
+        err.code,
+        err.subcode,
+        err.message
+      };
+    }
+
+    m_hvcC = std::make_shared<Box_hvcC>();
+    m_encoder_active = true;
+  }
+
+  Error dataErr = get_data(encoder);
+  if (dataErr) {
+    return dataErr;
+  }
+
+  heif_error err = encoder->plugin->encode_sequence_frame(encoder->encoder, &c_api_image, frame_number);
+  if (err.code) {
+    return {
+      err.code,
+      err.subcode,
+      err.message
+    };
+  }
+
+  return get_data(encoder);
+}
+
+
+Error Encoder_HEVC::encode_sequence_flush(heif_encoder* encoder)
+{
+  encoder->plugin->end_sequence_encoding(encoder->encoder);
+  m_encoder_active = false;
+  m_end_of_sequence_reached = true;
+
+  return get_data(encoder);
+}
+
+
+std::optional<Encoder::CodedImageData> Encoder_HEVC::encode_sequence_get_data()
+{
+  return std::move(m_current_output_data);
+}
+
+Error Encoder_HEVC::get_data(heif_encoder* encoder)
+{
+  //CodedImageData codedImage;
+
+  bool got_some_data = false;
+
+  for (;;) {
+    uint8_t* data;
+    int size;
+
+    uintptr_t frameNr=0;
+    int more_frame_packets = 1;
+    struct heif_error err = encoder->plugin->get_compressed_data2(encoder->encoder, &data, &size, &frameNr, nullptr, &more_frame_packets);
+    if (err.code) {
+      return Error(err.code, err.subcode, err.message);
+    }
+
+    if (data == nullptr) {
+      break;
+    }
+
+    got_some_data = true;
+
+    const uint8_t nal_type = (data[0] >> 1);
+    const bool is_sync = (nal_type == 19 || nal_type == 20 || nal_type == 21);
+    const bool is_image_data = (nal_type >= 0 && nal_type <= HEVC_NAL_UNIT_MAX_VCL);
+
+    // std::cout << "received frameNr=" << frameNr << " nal_type:" << ((int)nal_type) << " size: " << size << "\n";
+
+    if (nal_type == HEVC_NAL_UNIT_SPS_NUT && m_hvcC) {
+      parse_sps_for_hvcC_configuration(data, size,
+                                       &m_hvcC->get_configuration(),
+                                       &m_encoded_image_width, &m_encoded_image_height);
+    }
+
+    switch (nal_type) {
+      case HEVC_NAL_UNIT_VPS_NUT:
+        if (m_hvcC && !m_hvcC_has_VPS) m_hvcC->append_nal_data(data, size);
+        m_hvcC_has_VPS = true;
+        break;
+
+      case HEVC_NAL_UNIT_SPS_NUT:
+        if (m_hvcC && !m_hvcC_has_SPS) m_hvcC->append_nal_data(data, size);
+        m_hvcC_has_SPS = true;
+        break;
+
+      case HEVC_NAL_UNIT_PPS_NUT:
+        if (m_hvcC && !m_hvcC_has_PPS) m_hvcC->append_nal_data(data, size);
+        m_hvcC_has_PPS = true;
+        break;
+
+      default:
+        if (!m_current_output_data) {
+          m_current_output_data = CodedImageData{};
+        }
+        m_current_output_data->append_with_4bytes_size(data, size);
+
+        if (is_image_data) {
+          m_current_output_data->is_sync_frame = is_sync;
+          m_current_output_data->frame_nr = frameNr;
+        }
+    }
+
+    if (!more_frame_packets) {
+      break;
+    }
+  }
+
+  if (!got_some_data) {
+    return {};
+  }
+
+  if (!m_encoded_image_width || !m_encoded_image_height) {
+    return Error(heif_error_Encoder_plugin_error,
+                 heif_suberror_Invalid_image_size);
+  }
+
+
+  // --- return hvcC when all headers are included and it was not returned yet
+  //     TODO: it's maybe better to return this at the end so that we are sure to have all headers
+  //           and also complete codingConstraints.
+
+  if (!m_current_output_data->bitstream.empty() &&
+      m_hvcC_has_VPS && m_hvcC_has_SPS && m_hvcC_has_PPS && !m_hvcC_sent) {
+  //if (/*m_end_of_sequence_reached &&*/ m_hvcC && !m_hvcC_sent) {
+    m_current_output_data->properties.push_back(m_hvcC);
+    m_hvcC = nullptr;
+    m_hvcC_sent = true;
+  }
+
+  m_current_output_data->encoded_image_width = m_encoded_image_width;
+  m_current_output_data->encoded_image_height = m_encoded_image_height;
+
+
+  // Make sure that the encoder plugin works correctly and the encoded image has the correct size.
+#if 0
+  if (encoder->plugin->plugin_api_version >= 3 &&
+      encoder->plugin->query_encoded_size != nullptr) {
+    uint32_t check_encoded_width = image->get_width(), check_encoded_height = image->get_height();
+
+    encoder->plugin->query_encoded_size(encoder->encoder,
+                                        image->get_width(), image->get_height(),
+                                        &check_encoded_width,
+                                        &check_encoded_height);
+
+    assert((int)check_encoded_width == encoded_width);
+    assert((int)check_encoded_height == encoded_height);
+      }
+#endif
+
+  m_current_output_data->codingConstraints.intra_pred_used = true;
+  m_current_output_data->codingConstraints.all_ref_pics_intra = true; // TODO: change when we use predicted frames
+
+  return {};
+}
+
+
+std::shared_ptr<Box_VisualSampleEntry> Encoder_HEVC::get_sample_description_box(const CodedImageData& data) const
+{
+  auto hvc1 = std::make_shared<Box_hvc1>();
+  hvc1->get_VisualSampleEntry().compressorname = "HEVC";
+
+  for (auto prop : data.properties) {
+    if (prop->get_short_type() == fourcc("hvcC")) {
+      hvc1->append_child_box(prop);
+      return hvc1;
+    }
+  }
+
+  // box not yet available
+  return nullptr;
+}
diff --git a/libheif/codecs/hevc_enc.h b/libheif/codecs/hevc_enc.h
new file mode 100644
index 0000000000..20c7cfaa15
--- /dev/null
+++ b/libheif/codecs/hevc_enc.h
@@ -0,0 +1,78 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef HEIF_ENCODER_HEVC_H
+#define HEIF_ENCODER_HEVC_H
+
+#include "libheif/heif.h"
+#include "box.h"
+#include "error.h"
+#include "file.h"
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+#include "codecs/encoder.h"
+
+
+class Encoder_HEVC : public Encoder {
+public:
+  Result<CodedImageData> encode(const std::shared_ptr<HeifPixelImage>& image,
+                                heif_encoder* encoder,
+                                const heif_encoding_options& options,
+                                heif_image_input_class input_class) override;
+
+  bool encode_sequence_started() const override { return m_encoder_active; }
+
+  Error encode_sequence_frame(const std::shared_ptr<HeifPixelImage>& image,
+                              heif_encoder* encoder,
+                              const heif_sequence_encoding_options& options,
+                              heif_image_input_class input_class,
+                              uint32_t framerate_num, uint32_t framerate_denom,
+                              uintptr_t frame_number) override;
+
+  Error encode_sequence_flush(heif_encoder* encoder) override;
+
+  std::optional<CodedImageData> encode_sequence_get_data() override;
+
+  std::shared_ptr<Box_VisualSampleEntry> get_sample_description_box(const CodedImageData&) const override;
+
+private:
+  bool m_encoder_active = false;
+  bool m_end_of_sequence_reached = false;
+
+  // Whether the hvcC is complete and was returned in an encode_sequence_get_data() call.
+  bool m_hvcC_has_VPS = false;
+  bool m_hvcC_has_SPS = false;
+  bool m_hvcC_has_PPS = false;
+  std::shared_ptr<class Box_hvcC> m_hvcC;
+  bool m_hvcC_sent = false;
+
+  int m_encoded_image_width = 0;
+  int m_encoded_image_height = 0;
+
+  std::optional<CodedImageData> m_current_output_data;
+
+  Error get_data(heif_encoder*);
+};
+
+
+#endif
diff --git a/libheif/codecs/jpeg2000_boxes.cc b/libheif/codecs/jpeg2000_boxes.cc
new file mode 100644
index 0000000000..d09ae507ee
--- /dev/null
+++ b/libheif/codecs/jpeg2000_boxes.cc
@@ -0,0 +1,518 @@
+/*
+ * HEIF JPEG 2000 codec.
+ * Copyright (c) 2023 Brad Hards <bradh@frogmouth.net>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "jpeg2000_boxes.h"
+#include "api_structs.h"
+#include <cstdint>
+#include <iostream>
+#include <cstdio>
+
+static const uint16_t JPEG2000_CAP_MARKER = 0xFF50;
+static const uint16_t JPEG2000_SIZ_MARKER = 0xFF51;
+static const uint16_t JPEG2000_SOC_MARKER = 0xFF4F;
+
+
+Error Box_cdef::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  uint16_t channel_count = range.read16();
+
+  if (limits->max_components && channel_count > limits->max_components) {
+    std::stringstream sstr;
+    sstr << "cdef box wants to define " << channel_count << " JPEG-2000 channels, but the security limit is set to "
+         << limits->max_components << " components";
+    return {heif_error_Invalid_input,
+            heif_suberror_Security_limit_exceeded,
+            sstr.str()};
+  }
+
+  if (channel_count > range.get_remaining_bytes() / 6) {
+    std::stringstream sstr;
+    sstr << "cdef box wants to define " << channel_count << " JPEG-2000 channels, but file only contains "
+         << range.get_remaining_bytes() / 6 << " components";
+    return {heif_error_Invalid_input,
+            heif_suberror_End_of_data,
+            sstr.str()};
+  }
+
+  m_channels.resize(channel_count);
+
+  for (uint16_t i = 0; i < channel_count && !range.error() && !range.eof(); i++) {
+    Channel channel;
+    channel.channel_index = range.read16();
+    channel.channel_type = range.read16();
+    channel.channel_association = range.read16();
+    m_channels[i] = channel;
+  }
+
+  return range.get_error();
+}
+
+std::string Box_cdef::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
+
+  for (const auto& channel : m_channels) {
+    sstr << indent << "channel_index: " << channel.channel_index
+         << ", channel_type: " << channel.channel_type
+         << ", channel_association: " << channel.channel_association << "\n";
+  }
+
+  return sstr.str();
+}
+
+
+Error Box_cdef::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  writer.write16((uint16_t) m_channels.size());
+  for (const auto& channel : m_channels) {
+    writer.write16(channel.channel_index);
+    writer.write16(channel.channel_type);
+    writer.write16(channel.channel_association);
+  }
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+
+void Box_cdef::set_channels(heif_colorspace colorspace)
+{
+  // TODO - Check for the presence of a cmap box which specifies channel indices.
+
+  const uint16_t TYPE_COLOR = 0;
+  const uint16_t ASOC_GREY = 1;
+  const uint16_t ASOC_RED = 1;
+  const uint16_t ASOC_GREEN = 2;
+  const uint16_t ASOC_BLUE = 3;
+  const uint16_t ASOC_Y = 1;
+  const uint16_t ASOC_Cb = 2;
+  const uint16_t ASOC_Cr = 3;
+
+  switch (colorspace) {
+    case heif_colorspace_RGB:
+      m_channels.push_back({0, TYPE_COLOR, ASOC_RED});
+      m_channels.push_back({1, TYPE_COLOR, ASOC_GREEN});
+      m_channels.push_back({2, TYPE_COLOR, ASOC_BLUE});
+      break;
+
+    case heif_colorspace_YCbCr:
+      m_channels.push_back({0, TYPE_COLOR, ASOC_Y});
+      m_channels.push_back({1, TYPE_COLOR, ASOC_Cb});
+      m_channels.push_back({2, TYPE_COLOR, ASOC_Cr});
+      break;
+
+    case heif_colorspace_monochrome:
+      m_channels.push_back({0, TYPE_COLOR, ASOC_GREY});
+      break;
+
+    default:
+      //TODO - Handle remaining cases.
+      break;
+  }
+}
+
+Error Box_cmap::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  while (!range.eof() && !range.error()) {
+    Component component;
+    component.component_index = range.read16();
+    component.mapping_type = range.read8();
+    component.palette_colour = range.read8();
+    m_components.push_back(component);
+  }
+
+  return range.get_error();
+}
+
+
+std::string Box_cmap::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
+
+  for (const auto& component : m_components) {
+    sstr << indent << "component_index: " << component.component_index
+         << ", mapping_type: " << (int) (component.mapping_type)
+         << ", palette_colour: " << (int) (component.palette_colour) << "\n";
+  }
+
+  return sstr.str();
+}
+
+
+Error Box_cmap::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  for (const auto& component : m_components) {
+    writer.write16(component.component_index);
+    writer.write8(component.mapping_type);
+    writer.write8(component.palette_colour);
+  }
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+
+Error Box_pclr::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  uint16_t num_entries = range.read16();
+  uint8_t num_palette_columns = range.read8();
+  for (uint8_t i = 0; i < num_palette_columns; i++) {
+    uint8_t bit_depth = range.read8();
+    if (bit_depth & 0x80) {
+      return Error(heif_error_Unsupported_feature,
+                   heif_suberror_Unsupported_data_version,
+                   "pclr with signed data is not supported");
+    }
+    if (bit_depth > 16) {
+      return Error(heif_error_Unsupported_feature,
+                   heif_suberror_Unsupported_data_version,
+                   "pclr more than 16 bits per channel is not supported");
+    }
+    m_bitDepths.push_back(bit_depth);
+  }
+  for (uint16_t j = 0; j < num_entries; j++) {
+    PaletteEntry entry;
+    for (unsigned long int i = 0; i < entry.columns.size(); i++) {
+      if (m_bitDepths[i] <= 8) {
+        entry.columns.push_back(range.read8());
+      }
+      else {
+        entry.columns.push_back(range.read16());
+      }
+    }
+    m_entries.push_back(entry);
+  }
+
+  return range.get_error();
+}
+
+
+std::string Box_pclr::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
+
+  sstr << indent << "NE: " << m_entries.size();
+  sstr << ", NPC: " << (int) get_num_columns();
+  sstr << ", B: ";
+  for (uint8_t b : m_bitDepths) {
+    sstr << (int) b << ", ";
+  }
+  // TODO: maybe dump entries too?
+  sstr << "\n";
+
+  return sstr.str();
+}
+
+
+Error Box_pclr::write(StreamWriter& writer) const
+{
+  if (get_num_columns() == 0) {
+    // skip
+    return Error::Ok;
+  }
+
+  size_t box_start = reserve_box_header_space(writer);
+
+  writer.write16(get_num_entries());
+  writer.write8(get_num_columns());
+  for (uint8_t b : m_bitDepths) {
+    writer.write8(b);
+  }
+  for (PaletteEntry entry : m_entries) {
+    for (unsigned long int i = 0; i < entry.columns.size(); i++) {
+      if (m_bitDepths[i] <= 8) {
+        writer.write8((uint8_t) (entry.columns[i]));
+      }
+      else {
+        writer.write16(entry.columns[i]);
+      }
+    }
+  }
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+void Box_pclr::set_columns(uint8_t num_columns, uint8_t bit_depth)
+{
+  m_bitDepths.clear();
+  m_entries.clear();
+  for (int i = 0; i < num_columns; i++) {
+    m_bitDepths.push_back(bit_depth);
+  }
+}
+
+Error Box_j2kL::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  uint16_t layer_count = range.read16();
+
+  if (layer_count > range.get_remaining_bytes() / (2+1+2)) {
+    std::stringstream sstr;
+    sstr << "j2kL box wants to define " << layer_count << "JPEG-2000 layers, but the box only contains "
+         << range.get_remaining_bytes() / (2 + 1 + 2) << " layers entries";
+    return {heif_error_Invalid_input,
+            heif_suberror_End_of_data,
+            sstr.str()};
+  }
+
+  m_layers.resize(layer_count);
+
+  for (int i = 0; i < layer_count && !range.error() && !range.eof(); i++) {
+    Layer layer;
+    layer.layer_id = range.read16();
+    layer.discard_levels = range.read8();
+    layer.decode_layers = range.read16();
+    m_layers[i] = layer;
+  }
+
+  if (range.get_error()) {
+    m_layers.clear();
+  }
+
+  return range.get_error();
+}
+
+std::string Box_j2kL::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
+
+  for (const auto& layer : m_layers) {
+    sstr << indent << "layer_id: " << layer.layer_id
+         << ", discard_levels: " << (int) (layer.discard_levels)
+         << ", decode_layers: " << layer.decode_layers << "\n";
+  }
+
+  return sstr.str();
+}
+
+
+Error Box_j2kL::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  writer.write16((uint16_t) m_layers.size());
+  for (const auto& layer : m_layers) {
+    writer.write16(layer.layer_id);
+    writer.write8(layer.discard_levels);
+    writer.write16(layer.decode_layers);
+  }
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+
+Error Box_j2kH::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  return read_children(range, READ_CHILDREN_ALL, limits);
+}
+
+std::string Box_j2kH::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
+
+  sstr << dump_children(indent);
+
+  return sstr.str();
+}
+
+
+Error JPEG2000MainHeader::parseHeader(const std::vector<uint8_t>& compressedImageData)
+{
+  // TODO: it is very inefficient to store the whole image data when we only need the header
+
+  headerData = compressedImageData;
+  return doParse();
+}
+
+Error JPEG2000MainHeader::doParse()
+{
+  cursor = 0;
+  Error err = parse_SOC_segment();
+  if (err) {
+    return err;
+  }
+  err = parse_SIZ_segment();
+  if (err) {
+    return err;
+  }
+  if (cursor < headerData.size() - MARKER_LEN) {
+    uint16_t marker = read16();
+    if (marker == JPEG2000_CAP_MARKER) {
+      return parse_CAP_segment_body();
+    }
+    return Error::Ok;
+  }
+  // we should have at least COD and QCD, so this is probably broken.
+  return Error(heif_error_Invalid_input,
+               heif_suberror_Invalid_J2K_codestream,
+               std::string("Missing required header marker(s)"));
+}
+
+Error JPEG2000MainHeader::parse_SOC_segment()
+{
+  const size_t REQUIRED_BYTES = MARKER_LEN;
+  if ((headerData.size() < REQUIRED_BYTES) || (cursor > (headerData.size() - REQUIRED_BYTES))) {
+    return Error(heif_error_Invalid_input,
+                 heif_suberror_Invalid_J2K_codestream);
+  }
+  uint16_t marker = read16();
+  if (marker == JPEG2000_SOC_MARKER) {
+    return Error::Ok;
+  }
+  return Error(heif_error_Invalid_input,
+               heif_suberror_Invalid_J2K_codestream,
+               std::string("Missing required SOC Marker"));
+}
+
+Error JPEG2000MainHeader::parse_SIZ_segment()
+{
+  size_t REQUIRED_BYTES = MARKER_LEN + 38 + 3 * 1;
+  if ((headerData.size() < REQUIRED_BYTES) || (cursor > (headerData.size() - REQUIRED_BYTES))) {
+    return Error(heif_error_Invalid_input,
+                 heif_suberror_Invalid_J2K_codestream);
+  }
+
+  uint16_t marker = read16();
+  if (marker != JPEG2000_SIZ_MARKER) {
+    return Error(heif_error_Invalid_input,
+                 heif_suberror_Invalid_J2K_codestream,
+                 std::string("Missing required SIZ Marker"));
+  }
+  uint16_t lsiz = read16();
+  if ((lsiz < 41) || (lsiz > 49190)) {
+    return Error(heif_error_Invalid_input,
+                 heif_suberror_Invalid_J2K_codestream,
+                 std::string("Out of range Lsiz value"));
+  }
+  siz.decoder_capabilities = read16();
+  siz.reference_grid_width = read32();
+  siz.reference_grid_height = read32();
+  siz.image_horizontal_offset = read32();
+  siz.image_vertical_offset = read32();
+  siz.tile_width = read32();
+  siz.tile_height = read32();
+  siz.tile_offset_x = read32();
+  siz.tile_offset_y = read32();
+  uint16_t csiz = read16();
+  if ((csiz < 1) || (csiz > 16384)) {
+    return Error(heif_error_Invalid_input,
+                 heif_suberror_Invalid_J2K_codestream,
+                 std::string("Out of range Csiz value"));
+  }
+  if (cursor > headerData.size() - (3 * csiz)) {
+    return Error(heif_error_Invalid_input,
+                 heif_suberror_Invalid_J2K_codestream);
+  }
+  // TODO: consider checking for Lsiz consistent with Csiz
+  for (uint16_t c = 0; c < csiz; c++) {
+    JPEG2000_SIZ_segment::component comp;
+    uint8_t ssiz = read8();
+    comp.is_signed = (ssiz & 0x80);
+    comp.precision = uint8_t((ssiz & 0x7F) + 1);
+    comp.h_separation = read8();
+    comp.v_separation = read8();
+    siz.components.push_back(comp);
+  }
+  return Error::Ok;
+}
+
+Error JPEG2000MainHeader::parse_CAP_segment_body()
+{
+  if (cursor > headerData.size() - 8) {
+    return Error(heif_error_Invalid_input,
+                 heif_suberror_Invalid_J2K_codestream);
+  }
+  uint16_t lcap = read16();
+  if ((lcap < 8) || (lcap > 70)) {
+    return Error(heif_error_Invalid_input,
+                 heif_suberror_Invalid_J2K_codestream,
+                 std::string("Out of range Lcap value"));
+  }
+  uint32_t pcap = read32();
+  for (uint8_t i = 2; i <= 32; i++) {
+    if (pcap & (1 << (32 - i))) {
+      switch (i) {
+        case JPEG2000_Extension_Capability_HT::IDENT:
+          parse_Ccap15();
+          break;
+        default:
+          std::cout << "unhandled extended capabilities value: " << (int)i << std::endl;
+          read16();
+      }
+    }
+  }
+  return Error::Ok;
+}
+
+void JPEG2000MainHeader::parse_Ccap15()
+{
+  uint16_t val = read16();
+  JPEG2000_Extension_Capability_HT ccap;
+  // We could parse more here, but we don't need that yet.
+  ccap.setValue(val);
+  cap.push_back(ccap);
+}
+
+heif_chroma JPEG2000MainHeader::get_chroma_format() const
+{
+  // Y-plane must be full resolution
+  if (siz.components[0].h_separation != 1 || siz.components[0].v_separation != 1) {
+    return heif_chroma_undefined;
+  }
+
+  if (siz.components.size() == 1) {
+    return heif_chroma_monochrome;
+  }
+  else if (siz.components.size() == 3) {
+    // TODO: we should map channels through `cdef` ?
+
+    // both chroma components must have the same sampling
+    if (siz.components[1].h_separation != siz.components[2].h_separation ||
+        siz.components[1].v_separation != siz.components[2].v_separation) {
+      return heif_chroma_undefined;
+    }
+
+    if (siz.components[1].h_separation == 2 && siz.components[1].v_separation==2) {
+      return heif_chroma_420;
+    }
+    if (siz.components[1].h_separation == 2 && siz.components[1].v_separation==1) {
+      return heif_chroma_422;
+    }
+    if (siz.components[1].h_separation == 1 && siz.components[1].v_separation==1) {
+      return heif_chroma_444;
+    }
+  }
+
+  return heif_chroma_undefined;
+}
diff --git a/libheif/codecs/jpeg2000_boxes.h b/libheif/codecs/jpeg2000_boxes.h
new file mode 100644
index 0000000000..c313a85c1a
--- /dev/null
+++ b/libheif/codecs/jpeg2000_boxes.h
@@ -0,0 +1,529 @@
+/*
+ * HEIF JPEG 2000 codec.
+ * Copyright (c) 2023 Brad Hards <bradh@frogmouth.net>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_JPEG2000_BOXES_H
+#define LIBHEIF_JPEG2000_BOXES_H
+
+#include "box.h"
+#include "file.h"
+#include "context.h"
+#include <cstdint>
+#include <string>
+#include <vector>
+#include <memory>
+#include <utility>
+
+/**
+ * JPEG 2000 Channel Definition box.
+ *
+ * This is defined in ITU-800 / IEC 15444-1.
+ *
+ * The Channel Definition box provides the type and ordering of the components
+ * within the codestream. The mapping between actual components from the
+ * codestream to channels is specified in the Component Mapping box. If the
+ * header does not contain a Component Mapping box, then a reader shall map
+ * component
+ * @code{i} to channel @code{i}, for all components in the codestream.
+ *
+ * This box contains an array of channel descriptions. For each description,
+ * three values are specified: the index of the channel described by that
+ * association, the type of that channel, and the association of that channel
+ * with particular colours. This box may specify multiple descriptions for a
+ * single channel. If a multiple component transform is specified within the
+ * codestream, the image must be in an RGB colourspace and the red, green and
+ * blue colours as channels 0, 1 and 2 in the codestream, respectively.
+ *
+ * This box is required within the JPEG 2000 header item property (`j2kH`).
+ */
+class Box_cdef : public Box {
+public:
+    Box_cdef() { set_short_type(fourcc("cdef")); }
+
+    std::string dump(Indent &) const override;
+
+    Error write(StreamWriter &writer) const override;
+
+    struct Channel {
+        /**
+        * Channel index (`Cn`).
+        *
+        * This field specifies the index of the channel for this description.
+        * The value of this field represents the index of the channel as
+        * defined within the Component Mapping box (or the actual component
+        * from the codestream if the file does not contain a Component Mapping
+        * box).
+        */
+        uint16_t channel_index;
+        /**
+        * Channel type (`Typ`).
+        *
+        * Each channel type value shall be equal to 0 (colour), 1 (alpha)
+        * or 2 (pre-multiplied alpha).
+        *
+        * At most one channel type value shall be equal to 1 or 2 (i.e. a
+        * single alpha channel), and the corresponding association field
+        * value shall be 0.
+        */
+        uint16_t channel_type;
+        /**
+        * Channel association (`Asoc`).
+        *
+        * If the channel type value is 0 (colour), then the channel association
+        * value shall be in the range [1, 2<sup>16</sup> -2].
+        * Interpretation of this depends on the colourspace.
+        */
+        uint16_t channel_association;
+    };
+
+    /**
+    * Get the channels in this channel definition box.
+    *
+    * @return the channels as a read-only vector.
+    */
+    const std::vector<Channel> &get_channels() const { return m_channels; }
+
+    /**
+    * Add a channel to this channel definition box.
+    *
+    * @param channel the channel to add
+    */
+    void add_channel(Channel channel) { m_channels.push_back(channel); }
+
+    void set_channels(heif_colorspace colorspace);
+
+protected:
+    Error parse(BitstreamRange &range, const heif_security_limits* limits) override;
+
+private:
+    std::vector<Channel> m_channels;
+};
+
+/**
+ * JPEG 2000 Component Mapping box.
+ *
+ * The Component Mapping box defines how image channels are identified from the
+ * actual components decoded from the codestream. This abstraction allows a
+ * single structure (the Channel Definition box) to specify the colour or type
+ * of both palettised images and non-palettised images. This box contains an
+ * array of CMP<sup>i</sup>, MTYP<sup>i</sup> and PCOL<sup>i</sup> fields. Each
+ * group of these fields represents the definition of one channel in the image.
+ * The channels are numbered in order starting with zero, and the number of
+ * channels specified in the Component Mapping box is determined by the length
+ * of the box.
+ *
+ * There shall be at most one Component Mapping box inside a JP2 Header box.
+ * If the JP2 Header box contains a Palette box, then the JP2 Header box
+ * shall also contain a Component Mapping box. If the JP2 Header box does
+ * not contain a Component Mapping box, the components shall be mapped
+ * directly to channels, such that component @code{i} is mapped to channel
+ * @code {i}.
+ */
+class Box_cmap : public Box
+{
+public:
+    Box_cmap() { set_short_type(fourcc("cmap")); }
+
+    std::string dump(Indent &) const override;
+
+    Error write(StreamWriter &writer) const override;
+
+    struct Component
+    {
+        uint16_t component_index;
+        uint8_t mapping_type;
+        uint8_t palette_colour;
+    };
+
+    /**
+    * Get the components in this component mapping box.
+    *
+    * @return the components as a read-only vector.
+    */
+    const std::vector<Component> &get_components() const { return m_components; }
+
+    /**
+    * Add a component to this component mapping box.
+    *
+    * @param component the component to add
+    */
+    void add_component(Component component) { m_components.push_back(component); }
+
+protected:
+    Error parse(BitstreamRange &range, const heif_security_limits* limits) override;
+
+private:
+      std::vector<Component> m_components;
+};
+
+
+/**
+ * JPEG 2000 Palette box.
+ *
+ * This box defines the palette to be used to create multiple components
+ * from a single component.
+ */
+class Box_pclr : public Box
+{
+public:
+    Box_pclr()
+    {
+        set_short_type(fourcc("pclr"));
+    }
+
+    std::string dump(Indent &) const override;
+
+    Error write(StreamWriter &writer) const override;
+
+    struct PaletteEntry
+    {
+        // JPEG 2000 supports 38 bits and signed/unsigned, but we only
+        // do up to 16 bit unsigned.
+        std::vector<uint16_t> columns;
+    };
+
+    /**
+     * Get the entries in this palette box.
+     *
+     * @return the entries as a read-only vector.
+     */
+    const std::vector<PaletteEntry>& get_entries() const
+    {
+        return m_entries;
+    }
+
+    /**
+     * Get the bit depths for the columns in this palette box.
+     *
+     * @return the bit depths as a read-only vector.
+     */
+    const std::vector<uint8_t>& get_bit_depths() const
+    {
+        return m_bitDepths;
+    }
+
+    const uint8_t get_num_entries() const
+    {
+        return (uint8_t)(m_entries.size());
+    }
+
+    const uint8_t get_num_columns() const
+    {
+        return (uint8_t)(m_bitDepths.size());
+    }
+
+    void add_entry(const PaletteEntry entry)
+    {
+        m_entries.push_back(entry);
+    }
+
+    /**
+     * Set columns for the palette mapping.
+     *
+     * Each column has the same bit depth.
+     *
+     * This will reset any existing columns and entries.
+     *
+     * @param num_columns the number of columns (e.g. 3 for RGB)
+     * @param bit_depth the bit depth for each column (e.g. 8 for 24-bit RGB)
+     */
+    void set_columns(uint8_t num_columns, uint8_t bit_depth);
+
+protected:
+    Error parse(BitstreamRange &range, const heif_security_limits* limits) override;
+
+private:
+    std::vector<uint8_t> m_bitDepths;
+    std::vector<PaletteEntry> m_entries;
+};
+
+
+/**
+ * JPEG 2000 layers box.
+ *
+ * The JPEG 2000 layers box declares a list of quality and resolution layers
+ * for a JPEG 2000 codestream.
+ *
+ * @note the JPEG 2000 codestream can contain layers not listed in the JPEG 2000
+ * layers box.
+ */
+class Box_j2kL : public FullBox
+{
+public:
+    Box_j2kL() { set_short_type(fourcc("j2kL")); }
+
+    std::string dump(Indent &) const override;
+
+    Error write(StreamWriter &writer) const override;
+
+    struct Layer {
+        /**
+        * Unique identifier for the layer.
+        */
+        uint16_t layer_id;
+        /**
+        * Number of resolution levels of the codestream that can be discarded.
+        */
+        uint8_t discard_levels;
+        /**
+        * Minimum number of quality layers of the codestream to be decoded.
+        */
+        uint16_t decode_layers;
+    };
+
+    /**
+    * Get the layers in this layer box.
+    *
+    * @return the layers as a read-only vector.
+    */
+    const std::vector<Layer> &get_layers() const { return m_layers; }
+
+    /**
+    * Add a layer to the layers box.
+    *
+    * @param layer the layer to add
+    */
+    void add_layer(Layer layer) { m_layers.push_back(layer); }
+
+protected:
+    Error parse(BitstreamRange &range, const heif_security_limits* limits) override;
+
+private:
+    std::vector<Layer> m_layers;
+};
+
+class Box_j2kH : public Box
+{
+public:
+    Box_j2kH() { set_short_type(fourcc("j2kH")); }
+
+    bool is_essential() const override { return true; }
+
+    std::string dump(Indent &) const override;
+
+    // Default write behaviour for a container is to write children
+
+protected:
+    Error parse(BitstreamRange &range, const heif_security_limits* limits) override;
+};
+
+class Jpeg2000ImageCodec
+{
+public:
+
+//   static Error decode_jpeg2000_image(const HeifContext* context,
+//                                      heif_item_id ID,
+//                                      std::shared_ptr<HeifPixelImage>& img,
+//                                      const std::vector<uint8_t>& uncompressed_data);
+
+  static Error encode_jpeg2000_image(const std::shared_ptr<HeifFile>& heif_file,
+                                     const std::shared_ptr<HeifPixelImage>& src_image,
+                                     void* encoder_struct,
+                                     const struct heif_encoding_options& options,
+                                     std::shared_ptr<ImageItem>& out_image);
+};
+
+struct JPEG2000_SIZ_segment
+{
+    /**
+     * Decoder capabilities bitmap (Rsiz).
+     */
+    uint16_t decoder_capabilities = 0;
+    /**
+     * Width of the reference grid (Xsiz).
+     */
+    uint32_t reference_grid_width = 0;
+    /**
+     * Height of the reference grid (Ysiz).
+     */
+    uint32_t reference_grid_height = 0;
+    /**
+     * Horizontal offset from reference grid origin to image left side (XOsiz).
+     */
+    uint32_t image_horizontal_offset = 0;
+    /**
+     * Vertical offset from reference grid origin to image top size (YOsiz).
+     */
+    uint32_t image_vertical_offset = 0;
+    /**
+     * Width of one reference tile with respect to the reference grid (XTsiz).
+     */
+    uint32_t tile_width = 0;
+    /**
+     * Height of one reference tile with respect to the reference grid (YTsiz).
+     */
+    uint32_t tile_height = 0;
+    /**
+     * Horizontal offset from the origin of the reference grid to left side of first tile (XTOsiz).
+     */
+    uint32_t tile_offset_x = 0;
+    /**
+     * Vertical offset from the origin of the reference grid to top side of first tile (YTOsiz).
+     */
+    uint32_t tile_offset_y = 0;
+
+    struct component
+    {
+        uint8_t h_separation, v_separation;
+        uint8_t precision;
+        bool is_signed;
+    };
+
+    std::vector<component> components;
+};
+
+class JPEG2000_Extension_Capability {
+public:
+    JPEG2000_Extension_Capability(const uint8_t i) : ident(i) {}
+
+    uint8_t getIdent() const {
+        return ident;
+    }
+
+    uint16_t getValue() const {
+        return value;
+    }
+
+    void setValue(uint16_t val) {
+        value = val;
+    }
+
+private:
+    const uint8_t ident;
+    uint16_t value = 0;
+};
+
+class JPEG2000_Extension_Capability_HT : public JPEG2000_Extension_Capability
+{
+public:
+    static const int IDENT = 15;
+    JPEG2000_Extension_Capability_HT(): JPEG2000_Extension_Capability(IDENT)
+    {};
+};
+
+class JPEG2000_CAP_segment
+{
+public:
+    void push_back(JPEG2000_Extension_Capability ccap) {
+        extensions.push_back(ccap);
+    }
+    bool hasHighThroughputExtension() const {
+        for (auto &extension : extensions) {
+            if (extension.getIdent() == 15) {
+                return true;
+            }
+        }
+        return false;
+    }
+private:
+    std::vector<JPEG2000_Extension_Capability> extensions;
+
+};
+
+struct JPEG2000MainHeader
+{
+public:
+    JPEG2000MainHeader() = default;
+
+    Error parseHeader(const std::vector<uint8_t>& compressedImageData);
+
+    // Use parseHeader instead - these are mainly for unit testing
+    Error doParse();
+    void setHeaderData(std::vector<uint8_t> data)
+    {
+        headerData = std::move(data);
+    }
+
+    heif_chroma get_chroma_format() const;
+
+    int get_precision(uint32_t index) const
+    {
+        if (index >= siz.components.size()) {
+            return -1;
+        }
+        // TODO: this is a quick hack. It is more complicated for JPEG2000 because these can be any kind of colorspace (e.g. RGB).
+        return siz.components[index].precision;
+    }
+
+    bool hasHighThroughputExtension() {
+        return cap.hasHighThroughputExtension();
+    }
+
+    uint32_t getXSize() const
+    {
+        return siz.reference_grid_width;
+    }
+
+    uint32_t getYSize() const
+    {
+        return siz.reference_grid_height;
+    }
+
+    const JPEG2000_SIZ_segment get_SIZ()
+    {
+        return siz;
+    }
+
+private:
+    Error parse_SOC_segment();
+    Error parse_SIZ_segment();
+    Error parse_CAP_segment_body();
+    void parse_Ccap15();
+
+    static const int MARKER_LEN = 2;
+
+    JPEG2000_SIZ_segment siz;
+    JPEG2000_CAP_segment cap;
+
+    uint8_t read8()
+    {
+        uint8_t res = headerData[cursor];
+        cursor += 1;
+        return res;
+    }
+
+    uint16_t read16()
+    {
+        uint16_t res = (uint16_t)((headerData[cursor] << 8) | headerData[cursor + 1]);
+        cursor += 2;
+        return res;
+    }
+
+    uint32_t read32()
+    {
+        uint32_t res = (headerData[cursor] << 24) | (headerData[cursor + 1] << 16) | (headerData[cursor + 2] << 8) | headerData[cursor + 3];
+        cursor += 4;
+        return res;
+    }
+
+    std::vector<uint8_t> headerData;
+    size_t cursor = 0;
+};
+
+
+class Box_j2ki : public Box_VisualSampleEntry
+{
+public:
+  Box_j2ki()
+  {
+    set_short_type(fourcc("j2ki"));
+  }
+};
+
+#endif // LIBHEIF_JPEG2000_BOXES_H
diff --git a/libheif/codecs/jpeg2000_dec.cc b/libheif/codecs/jpeg2000_dec.cc
new file mode 100644
index 0000000000..1569c5b7e5
--- /dev/null
+++ b/libheif/codecs/jpeg2000_dec.cc
@@ -0,0 +1,84 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "jpeg2000_dec.h"
+#include "jpeg2000_boxes.h"
+#include "error.h"
+#include "context.h"
+
+#include <string>
+
+
+Result<std::vector<uint8_t>> Decoder_JPEG2000::read_bitstream_configuration_data() const
+{
+  return std::vector<uint8_t>{};
+}
+
+
+int Decoder_JPEG2000::get_luma_bits_per_pixel() const
+{
+  Result<std::vector<uint8_t>> imageDataResult = get_compressed_data(true);
+  if (!imageDataResult) {
+    return -1;
+  }
+
+  JPEG2000MainHeader header;
+  Error err = header.parseHeader(*imageDataResult);
+  if (err) {
+    return -1;
+  }
+  return header.get_precision(0);
+}
+
+
+int Decoder_JPEG2000::get_chroma_bits_per_pixel() const
+{
+  Result<std::vector<uint8_t>> imageDataResult = get_compressed_data(true);
+  if (!imageDataResult) {
+    return -1;
+  }
+
+  JPEG2000MainHeader header;
+  Error err = header.parseHeader(*imageDataResult);
+  if (err) {
+    return -1;
+  }
+  return header.get_precision(1);
+}
+
+
+Error Decoder_JPEG2000::get_coded_image_colorspace(heif_colorspace* out_colorspace, heif_chroma* out_chroma) const
+{
+#if 0
+  *out_chroma = (heif_chroma) (m_hvcC->get_configuration().chroma_format);
+
+  if (*out_chroma == heif_chroma_monochrome) {
+    *out_colorspace = heif_colorspace_monochrome;
+  }
+  else {
+    *out_colorspace = heif_colorspace_YCbCr;
+  }
+#endif
+
+  *out_colorspace = heif_colorspace_YCbCr;
+  *out_chroma = heif_chroma_444;
+
+  return Error::Ok;
+}
diff --git a/libheif/codecs/jpeg2000_dec.h b/libheif/codecs/jpeg2000_dec.h
new file mode 100644
index 0000000000..9cc842d42d
--- /dev/null
+++ b/libheif/codecs/jpeg2000_dec.h
@@ -0,0 +1,56 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef HEIF_JPEG2000_DEC_H
+#define HEIF_JPEG2000_DEC_H
+
+#include "libheif/heif.h"
+#include "box.h"
+#include "error.h"
+#include "file.h"
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+#include "image-items/jpeg2000.h"
+#include <codecs/decoder.h>
+
+
+class Decoder_JPEG2000 : public Decoder
+{
+public:
+  Decoder_JPEG2000(const std::shared_ptr<const Box_j2kH>& j2kH) : m_j2kH(j2kH) {}
+
+  heif_compression_format get_compression_format() const override { return heif_compression_JPEG2000; }
+
+  int get_luma_bits_per_pixel() const override;
+
+  int get_chroma_bits_per_pixel() const override;
+
+  Error get_coded_image_colorspace(heif_colorspace*, heif_chroma*) const override;
+
+  Result<std::vector<uint8_t>> read_bitstream_configuration_data() const override;
+
+private:
+  const std::shared_ptr<const Box_j2kH> m_j2kH;
+};
+
+#endif
diff --git a/libheif/codecs/jpeg2000_enc.cc b/libheif/codecs/jpeg2000_enc.cc
new file mode 100644
index 0000000000..bc1184038f
--- /dev/null
+++ b/libheif/codecs/jpeg2000_enc.cc
@@ -0,0 +1,112 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "jpeg2000_enc.h"
+#include "jpeg2000_boxes.h"
+#include "error.h"
+#include "context.h"
+#include "api_structs.h"
+
+#include <string>
+
+
+Result<Encoder::CodedImageData> Encoder_JPEG2000::encode(const std::shared_ptr<HeifPixelImage>& image,
+                                                         struct heif_encoder* encoder,
+                                                         const struct heif_encoding_options& options,
+                                                         enum heif_image_input_class input_class)
+{
+  Encoder::CodedImageData codedImageData;
+  heif_error err;
+
+  heif_image c_api_image;
+  c_api_image.image = image;
+
+  err = encoder->plugin->encode_image(encoder->encoder, &c_api_image, input_class);\
+  if (err.code != heif_error_Ok) {
+    return Error::from_heif_error(err);
+  }
+
+  // get compressed data
+  for (;;) {
+    uint8_t* data;
+    int size;
+
+    err = encoder->plugin->get_compressed_data(encoder->encoder, &data, &size, nullptr);
+    if (err.code != heif_error_Ok) {
+      return Error::from_heif_error(err);
+    }
+
+    if (data == nullptr) {
+      break;
+    }
+
+    codedImageData.append(data, size);
+  }
+
+  // add 'j2kH' property
+  auto j2kH = std::make_shared<Box_j2kH>();
+
+  // add 'cdef' to 'j2kH'
+  auto cdef = std::make_shared<Box_cdef>();
+  cdef->set_channels(image->get_colorspace());
+  j2kH->append_child_box(cdef);
+
+  codedImageData.properties.push_back(j2kH);
+
+  codedImageData.codingConstraints.intra_pred_used = false;
+  codedImageData.codingConstraints.all_ref_pics_intra = true;
+  codedImageData.codingConstraints.max_ref_per_pic = 0;
+
+  return codedImageData;
+}
+
+
+std::shared_ptr<class Box_VisualSampleEntry> Encoder_JPEG2000::get_sample_description_box(const CodedImageData& data) const
+{
+  auto j2ki = std::make_shared<Box_j2ki>();
+  j2ki->get_VisualSampleEntry().compressorname = "JPEG2000";
+
+  for (auto prop : data.properties) {
+    if (prop->get_short_type() == fourcc("j2kH")) {
+      j2ki->append_child_box(prop);
+      return j2ki;
+    }
+  }
+
+  assert(false); // no hvcC generated
+  return nullptr;
+}
+
+
+std::shared_ptr<class Box_VisualSampleEntry> Encoder_HTJ2K::get_sample_description_box(const CodedImageData& data) const
+{
+  auto j2ki = std::make_shared<Box_j2ki>();
+  j2ki->get_VisualSampleEntry().compressorname = "HTJ2K";
+
+  for (auto prop : data.properties) {
+    if (prop->get_short_type() == fourcc("j2kH")) {
+      j2ki->append_child_box(prop);
+      return j2ki;
+    }
+  }
+
+  assert(false); // no hvcC generated
+  return nullptr;
+}
diff --git a/libheif/codecs/jpeg2000_enc.h b/libheif/codecs/jpeg2000_enc.h
new file mode 100644
index 0000000000..a535bab7fd
--- /dev/null
+++ b/libheif/codecs/jpeg2000_enc.h
@@ -0,0 +1,90 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef HEIF_ENCODER_JPEG2000_H
+#define HEIF_ENCODER_JPEG2000_H
+
+#include "libheif/heif.h"
+#include "box.h"
+#include "error.h"
+#include "file.h"
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+#include "codecs/encoder.h"
+
+
+class Encoder_JPEG2000 : public Encoder {
+public:
+  Result<CodedImageData> encode(const std::shared_ptr<HeifPixelImage>& image,
+                                heif_encoder* encoder,
+                                const heif_encoding_options& options,
+                                heif_image_input_class input_class) override;
+
+  std::shared_ptr<Box_VisualSampleEntry> get_sample_description_box(const CodedImageData&) const override;
+
+  bool encode_sequence_started() const override { return m_codedImageData.has_value(); }
+
+  Error encode_sequence_frame(const std::shared_ptr<HeifPixelImage>& image,
+                                      heif_encoder* encoder,
+                                      const heif_sequence_encoding_options& options,
+                                      heif_image_input_class input_class,
+                                      uint32_t framerate_num, uint32_t framerate_denom,
+                                      uintptr_t frame_number) override
+  {
+    heif_encoding_options dummy_options{};
+
+    auto encodeResult = encode(image, encoder, dummy_options, input_class);
+    if (encodeResult.error()) {
+      return encodeResult.error();
+    }
+
+    m_codedImageData = std::move(*encodeResult);
+
+    m_codedImageData->frame_nr = frame_number;
+    m_codedImageData->is_sync_frame = true;
+
+    return {};
+  }
+
+  Error encode_sequence_flush(heif_encoder* encoder) override
+  {
+    return {};
+  }
+
+  std::optional<CodedImageData> encode_sequence_get_data() override
+  {
+    return std::move(m_codedImageData);
+  }
+
+private:
+  std::optional<CodedImageData> m_codedImageData;
+};
+
+
+class Encoder_HTJ2K : public Encoder_JPEG2000 {
+public:
+  std::shared_ptr<Box_VisualSampleEntry> get_sample_description_box(const CodedImageData&) const override;
+};
+
+
+#endif
diff --git a/libheif/codecs/jpeg_boxes.cc b/libheif/codecs/jpeg_boxes.cc
new file mode 100644
index 0000000000..c718b9eaf9
--- /dev/null
+++ b/libheif/codecs/jpeg_boxes.cc
@@ -0,0 +1,78 @@
+/*
+ * HEIF JPEG codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "jpeg_boxes.h"
+#include <string>
+#include "security_limits.h"
+#include <cstring>
+#include "libheif/heif_experimental.h"
+
+
+// returns 0 if the marker_type was not found
+size_t find_jpeg_marker_start(const std::vector<uint8_t>& data, uint8_t marker_type)
+{
+  for (size_t i = 0; i < data.size() - 1; i++) {
+    if (data[i] == 0xFF && data[i + 1] == marker_type) {
+      return i;
+    }
+  }
+
+  return 0;
+}
+
+
+std::string Box_jpgC::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
+
+  sstr << indent << "num bytes: " << m_data.size() << "\n";
+
+  return sstr.str();
+}
+
+
+Error Box_jpgC::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  writer.write(m_data);
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+
+Error Box_jpgC::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  if (!has_fixed_box_size()) {
+    return Error{heif_error_Unsupported_feature, heif_suberror_Unspecified, "jpgC with unspecified size are not supported"};
+  }
+
+  size_t nBytes = range.get_remaining_bytes();
+  if (limits->max_memory_block_size && nBytes > limits->max_memory_block_size) {
+    return Error{heif_error_Invalid_input, heif_suberror_Unspecified, "jpgC block exceeds maximum size"};
+  }
+
+  m_data.resize(nBytes);
+  range.read(m_data.data(), nBytes);
+  return range.get_error();
+}
diff --git a/libheif/codecs/jpeg_boxes.h b/libheif/codecs/jpeg_boxes.h
new file mode 100644
index 0000000000..2e70427df6
--- /dev/null
+++ b/libheif/codecs/jpeg_boxes.h
@@ -0,0 +1,66 @@
+/*
+ * HEIF JPEG codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_JPEG_BOXES_H
+#define LIBHEIF_JPEG_BOXES_H
+
+#include "box.h"
+#include <string>
+#include <vector>
+#include "image-items/image_item.h"
+#include <memory>
+#include "sequences/seq_boxes.h"
+
+
+class Box_jpgC : public Box
+{
+public:
+  Box_jpgC()
+  {
+    set_short_type(fourcc("jpgC"));
+  }
+
+  const std::vector<uint8_t>& get_data() const { return m_data; }
+
+  void set_data(const std::vector<uint8_t>& data) { m_data = data; }
+
+  std::string dump(Indent&) const override;
+
+  Error write(StreamWriter& writer) const override;
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits* limits) override;
+
+private:
+  std::vector<uint8_t> m_data;
+};
+
+
+class Box_mjpg : public Box_VisualSampleEntry
+{
+public:
+  Box_mjpg()
+  {
+    set_short_type(fourcc("mjpg"));
+  }
+};
+
+
+#endif // LIBHEIF_JPEG_BOXES_H
diff --git a/libheif/codecs/jpeg_dec.cc b/libheif/codecs/jpeg_dec.cc
new file mode 100644
index 0000000000..f43e8184cf
--- /dev/null
+++ b/libheif/codecs/jpeg_dec.cc
@@ -0,0 +1,160 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "jpeg_dec.h"
+#include "jpeg_boxes.h"
+#include "error.h"
+#include "context.h"
+
+#include <string>
+#include <algorithm>
+
+
+Result<std::vector<uint8_t>> Decoder_JPEG::read_bitstream_configuration_data() const
+{
+  if (m_jpgC) {
+    return m_jpgC->get_data();
+  }
+  else {
+    return std::vector<uint8_t>{};
+  }
+}
+
+
+// This checks whether a start code FFCx with nibble 'x' is a SOF marker.
+// E.g. FFC0-FFC3 are, while FFC4 is not.
+static bool isSOF[16] = {true, true, true, true, false, true, true, true,
+                         false, true, true, true, false, true, true, true};
+
+Error Decoder_JPEG::parse_SOF()
+{
+  if (m_config) {
+    return Error::Ok;
+  }
+
+  // image data, usually from 'mdat'
+
+  auto dataResult = get_compressed_data(true);
+  if (!dataResult) {
+    return dataResult.error();
+  }
+
+  const std::vector<uint8_t>& data = *dataResult;
+
+  const Error error_invalidSOF{heif_error_Invalid_input,
+                               heif_suberror_Unspecified,
+                               "Invalid JPEG SOF header"};
+
+  for (size_t i = 0; i + 1 < data.size(); i++) {
+    if (data[i] == 0xFF && (data[i + 1] & 0xF0) == 0xC0 && isSOF[data[i + 1] & 0x0F]) {
+
+      if (i + 9 >= data.size()) {
+        return error_invalidSOF;
+      }
+
+      ConfigInfo info;
+      info.sample_precision = data[i + 4];
+      info.nComponents = data[i + 9];
+
+      if (i + 11 + 3 * info.nComponents >= data.size()) {
+        return error_invalidSOF;
+      }
+
+      for (int c = 0; c < std::min(info.nComponents, uint8_t(3)); c++) {
+        int ss = data[i + 11 + 3 * c];
+        info.h_sampling[c] = (ss >> 4) & 0xF;
+        info.v_sampling[c] = ss & 0xF;
+      }
+
+      if (info.nComponents == 1) {
+        info.chroma = heif_chroma_monochrome;
+      }
+      else if (info.nComponents != 3) {
+        return error_invalidSOF;
+      }
+      else {
+        if (info.h_sampling[1] != info.h_sampling[2] ||
+            info.v_sampling[1] != info.v_sampling[2]) {
+          return error_invalidSOF;
+        }
+
+        if (info.h_sampling[0] == 2 && info.v_sampling[0] == 2 &&
+            info.h_sampling[1] == 1 && info.v_sampling[1] == 1) {
+          info.chroma = heif_chroma_420;
+        }
+        else if (info.h_sampling[0] == 2 && info.v_sampling[0] == 1 &&
+                 info.h_sampling[1] == 1 && info.v_sampling[1] == 1) {
+          info.chroma = heif_chroma_422;
+        }
+        else if (info.h_sampling[0] == 1 && info.v_sampling[0] == 1 &&
+                 info.h_sampling[1] == 1 && info.v_sampling[1] == 1) {
+          info.chroma = heif_chroma_444;
+        }
+        else {
+          return error_invalidSOF;
+        }
+      }
+
+      m_config = info;
+
+      return Error::Ok;
+    }
+  }
+
+  return error_invalidSOF;
+}
+
+
+int Decoder_JPEG::get_luma_bits_per_pixel() const
+{
+  Error err = const_cast<Decoder_JPEG*>(this)->parse_SOF();
+  if (err) {
+    return -1;
+  }
+  else {
+    return m_config->sample_precision;
+  }
+}
+
+
+int Decoder_JPEG::get_chroma_bits_per_pixel() const
+{
+  return get_luma_bits_per_pixel();
+}
+
+
+Error Decoder_JPEG::get_coded_image_colorspace(heif_colorspace* out_colorspace, heif_chroma* out_chroma) const
+{
+  Error err = const_cast<Decoder_JPEG*>(this)->parse_SOF();
+  if (err) {
+    return err;
+  }
+
+  *out_chroma = m_config->chroma;
+
+  if (*out_chroma == heif_chroma_monochrome) {
+    *out_colorspace = heif_colorspace_monochrome;
+  }
+  else {
+    *out_colorspace = heif_colorspace_YCbCr;
+  }
+
+  return Error::Ok;
+}
diff --git a/libheif/codecs/jpeg_dec.h b/libheif/codecs/jpeg_dec.h
new file mode 100644
index 0000000000..4de18eb58e
--- /dev/null
+++ b/libheif/codecs/jpeg_dec.h
@@ -0,0 +1,68 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef HEIF_JPEG_DEC_H
+#define HEIF_JPEG_DEC_H
+
+#include "libheif/heif.h"
+#include "box.h"
+#include "error.h"
+#include "codecs/decoder.h"
+
+#include <memory>
+#include <vector>
+#include <optional>
+
+class Box_jpgC;
+
+
+class Decoder_JPEG : public Decoder
+{
+public:
+  explicit Decoder_JPEG(const std::shared_ptr<const Box_jpgC>& jpgC) : m_jpgC(jpgC) {}
+
+  heif_compression_format get_compression_format() const override { return heif_compression_JPEG; }
+
+  int get_luma_bits_per_pixel() const override;
+
+  int get_chroma_bits_per_pixel() const override;
+
+  Error get_coded_image_colorspace(heif_colorspace*, heif_chroma*) const override;
+
+  Result<std::vector<uint8_t>> read_bitstream_configuration_data() const override;
+
+private:
+  const std::shared_ptr<const Box_jpgC> m_jpgC; // Optional jpgC box. May be NULL.
+
+  struct ConfigInfo {
+    uint8_t sample_precision = 0;
+    heif_chroma chroma = heif_chroma_undefined;
+
+    uint8_t nComponents = 0;
+    uint8_t h_sampling[3]{};
+    uint8_t v_sampling[3]{};
+  };
+
+  std::optional<ConfigInfo> m_config;
+
+  Error parse_SOF();
+};
+
+#endif
diff --git a/libheif/codecs/jpeg_enc.cc b/libheif/codecs/jpeg_enc.cc
new file mode 100644
index 0000000000..8b1bd31b05
--- /dev/null
+++ b/libheif/codecs/jpeg_enc.cc
@@ -0,0 +1,134 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "jpeg_enc.h"
+#include "jpeg_boxes.h"
+#include "error.h"
+#include "context.h"
+#include "api_structs.h"
+#include <cstring>
+
+#include <string>
+
+
+static uint8_t JPEG_SOS = 0xDA;
+
+
+const heif_color_profile_nclx* Encoder_JPEG::get_forced_output_nclx() const
+{
+  // JPEG always uses CCIR-601
+
+  static heif_color_profile_nclx target_heif_nclx;
+  target_heif_nclx.version = 1;
+  target_heif_nclx.matrix_coefficients = heif_matrix_coefficients_ITU_R_BT_601_6;
+  target_heif_nclx.color_primaries = heif_color_primaries_ITU_R_BT_601_6;
+  target_heif_nclx.transfer_characteristics = heif_transfer_characteristic_ITU_R_BT_601_6;
+  target_heif_nclx.full_range_flag = true;
+
+  return &target_heif_nclx;
+}
+
+
+Result<Encoder::CodedImageData> Encoder_JPEG::encode(const std::shared_ptr<HeifPixelImage>& image,
+                                                     struct heif_encoder* encoder,
+                                                     const struct heif_encoding_options& options,
+                                                     enum heif_image_input_class input_class)
+{
+  Encoder::CodedImageData codedImage;
+
+
+  heif_image c_api_image;
+  c_api_image.image = image;
+
+  struct heif_error err = encoder->plugin->encode_image(encoder->encoder, &c_api_image, input_class);
+  if (err.code) {
+    return Error(err.code,
+                 err.subcode,
+                 err.message);
+  }
+
+  std::vector<uint8_t> vec;
+
+  for (;;) {
+    uint8_t* data;
+    int size;
+
+    err = encoder->plugin->get_compressed_data(encoder->encoder, &data, &size, nullptr);
+    if (err.code) {
+      return Error(err.code, err.subcode, err.message);
+    }
+
+    if (data == nullptr) {
+      break;
+    }
+
+    size_t oldsize = vec.size();
+    vec.resize(oldsize + size);
+    memcpy(vec.data() + oldsize, data, size);
+  }
+
+#if 0
+  // Optional: split the JPEG data into a jpgC box and the actual image data.
+  // Currently disabled because not supported yet in other decoders.
+  if (false) {
+    size_t pos = find_jpeg_marker_start(vec, JPEG_SOS);
+    if (pos > 0) {
+      std::vector<uint8_t> jpgC_data(vec.begin(), vec.begin() + pos);
+      auto jpgC = std::make_shared<Box_jpgC>();
+      jpgC->set_data(jpgC_data);
+
+      auto ipma_box = m_heif_file->get_ipma_box();
+      int index = m_heif_file->get_ipco_box()->find_or_append_child_box(jpgC);
+      ipma_box->add_property_for_item_ID(image_id, Box_ipma::PropertyAssociation{true, uint16_t(index + 1)});
+
+      std::vector<uint8_t> image_data(vec.begin() + pos, vec.end());
+      vec = std::mo ve(image_data);
+    }
+  }
+#endif
+  (void) JPEG_SOS;
+
+  codedImage.bitstream = std::move(vec);
+
+#if 0
+  // TODO: extract 'jpgC' header data
+#endif
+
+  codedImage.codingConstraints.intra_pred_used = false;
+  codedImage.codingConstraints.all_ref_pics_intra = true;
+  codedImage.codingConstraints.max_ref_per_pic = 0;
+
+  return {codedImage};
+}
+
+
+std::shared_ptr<class Box_VisualSampleEntry> Encoder_JPEG::get_sample_description_box(const CodedImageData& data) const
+{
+  auto mjpg = std::make_shared<Box_mjpg>();
+  mjpg->get_VisualSampleEntry().compressorname = "JPEG";
+
+  for (auto prop : data.properties) {
+    if (prop->get_short_type() == fourcc("jpgC")) {
+      mjpg->append_child_box(prop);
+    }
+  }
+
+  return mjpg;
+}
diff --git a/libheif/codecs/jpeg_enc.h b/libheif/codecs/jpeg_enc.h
new file mode 100644
index 0000000000..ed8b8cdd80
--- /dev/null
+++ b/libheif/codecs/jpeg_enc.h
@@ -0,0 +1,87 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef HEIF_ENCODER_JPEG_H
+#define HEIF_ENCODER_JPEG_H
+
+#include "libheif/heif.h"
+#include "box.h"
+#include "error.h"
+#include "file.h"
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+#include "codecs/encoder.h"
+
+
+class Encoder_JPEG : public Encoder {
+public:
+  const heif_color_profile_nclx* get_forced_output_nclx() const override;
+
+  Result<CodedImageData> encode(const std::shared_ptr<HeifPixelImage>& image,
+                                heif_encoder* encoder,
+                                const heif_encoding_options& options,
+                                enum heif_image_input_class input_class) override;
+
+  std::shared_ptr<Box_VisualSampleEntry> get_sample_description_box(const CodedImageData&) const override;
+
+
+  bool encode_sequence_started() const override { return m_codedImageData.has_value(); }
+
+  Error encode_sequence_frame(const std::shared_ptr<HeifPixelImage>& image,
+                                      heif_encoder* encoder,
+                                      const heif_sequence_encoding_options& options,
+                                      heif_image_input_class input_class,
+                                      uint32_t framerate_num, uint32_t framerate_denom,
+                                      uintptr_t frame_number) override
+  {
+    heif_encoding_options dummy_options{};
+
+    auto encodeResult = encode(image, encoder, dummy_options, input_class);
+    if (encodeResult.error()) {
+      return encodeResult.error();
+    }
+
+    m_codedImageData = std::move(*encodeResult);
+
+    m_codedImageData->frame_nr = frame_number;
+    m_codedImageData->is_sync_frame = true;
+
+    return {};
+  }
+
+  Error encode_sequence_flush(heif_encoder* encoder) override
+  {
+    return {};
+  }
+
+  std::optional<CodedImageData> encode_sequence_get_data() override
+  {
+    return std::move(m_codedImageData);
+  }
+
+private:
+  std::optional<CodedImageData> m_codedImageData;
+};
+
+
+#endif
diff --git a/libheif/codecs/uncompressed/unc_boxes.cc b/libheif/codecs/uncompressed/unc_boxes.cc
new file mode 100644
index 0000000000..075ff1a356
--- /dev/null
+++ b/libheif/codecs/uncompressed/unc_boxes.cc
@@ -0,0 +1,1499 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include <cstdint>
+#include <cstring>
+#include <algorithm>
+#include <map>
+#include <iostream>
+#include <cassert>
+#include <limits>
+
+#include "libheif/heif.h"
+#include "libheif/heif_experimental.h"
+#include "unc_types.h"
+#include "unc_boxes.h"
+
+
+/**
+ * Check for valid component format.
+ *
+ * @param format the format value to check
+ * @return true if the format is a valid value, or false otherwise
+ */
+bool is_valid_component_format(uint8_t format)
+{
+  return format <= component_format_max_valid;
+}
+
+static std::map<heif_uncompressed_component_format, const char*> sNames_uncompressed_component_format{
+    {component_format_unsigned, "unsigned"},
+    {component_format_signed,   "signed"},
+    {component_format_float,    "float"},
+    {component_format_complex,  "complex"}
+};
+
+
+/**
+ * Check for valid interleave mode.
+ *
+ * @param interleave the interleave value to check
+ * @return true if the interleave mode is valid, or false otherwise
+ */
+bool is_valid_interleave_mode(uint8_t interleave)
+{
+  return interleave <= interleave_mode_max_valid;
+}
+
+static std::map<heif_uncompressed_interleave_mode, const char*> sNames_uncompressed_interleave_mode{
+    {interleave_mode_component,      "component"},
+    {interleave_mode_pixel,          "pixel"},
+    {interleave_mode_mixed,          "mixed"},
+    {interleave_mode_row,            "row"},
+    {interleave_mode_tile_component, "tile-component"},
+    {interleave_mode_multi_y,        "multi-y"}
+};
+
+
+/**
+ * Check for valid sampling mode.
+ *
+ * @param sampling the sampling value to check
+ * @return true if the sampling mode is valid, or false otherwise
+ */
+bool is_valid_sampling_mode(uint8_t sampling)
+{
+  return sampling <= sampling_mode_max_valid;
+}
+
+static std::map<heif_uncompressed_sampling_mode, const char*> sNames_uncompressed_sampling_mode{
+    {sampling_mode_no_subsampling, "no subsampling"},
+    {sampling_mode_422,            "4:2:2"},
+    {sampling_mode_420,            "4:2:0"},
+    {sampling_mode_411,            "4:1:1"}
+};
+
+
+bool is_predefined_component_type(uint16_t type)
+{
+  // check whether the component type can be mapped to heif_uncompressed_component_type and we have a name defined for
+  // it in sNames_uncompressed_component_type.
+  return type <= heif_uncompressed_component_type_max_valid;
+}
+
+static std::map<heif_uncompressed_component_type, const char*> sNames_uncompressed_component_type{
+    {heif_uncompressed_component_type_monochrome,   "monochrome"},
+    {heif_uncompressed_component_type_Y,            "Y"},
+    {heif_uncompressed_component_type_Cb,           "Cb"},
+    {heif_uncompressed_component_type_Cr,           "Cr"},
+    {heif_uncompressed_component_type_red,          "red"},
+    {heif_uncompressed_component_type_green,        "green"},
+    {heif_uncompressed_component_type_blue,         "blue"},
+    {heif_uncompressed_component_type_alpha,        "alpha"},
+    {heif_uncompressed_component_type_depth,        "depth"},
+    {heif_uncompressed_component_type_disparity,    "disparity"},
+    {heif_uncompressed_component_type_palette,      "palette"},
+    {heif_uncompressed_component_type_filter_array, "filter-array"},
+    {heif_uncompressed_component_type_padded,       "padded"},
+    {heif_uncompressed_component_type_cyan,         "cyan"},
+    {heif_uncompressed_component_type_magenta,      "magenta"},
+    {heif_uncompressed_component_type_yellow,       "yellow"},
+    {heif_uncompressed_component_type_key_black,    "key (black)"}
+};
+
+template <typename T> const char* get_name(T val, const std::map<T, const char*>& table)
+{
+  auto iter = table.find(val);
+  if (iter == table.end()) {
+    return "unknown";
+  }
+  else {
+    return iter->second;
+  }
+}
+
+void Box_cmpd::set_components(const std::vector<uint16_t>& components)
+{
+  m_components.clear();
+
+  for (const auto& component : components) {
+    m_components.push_back({component, {}});
+  }
+}
+
+
+Error Box_cmpd::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  uint32_t component_count = range.read32();
+
+  if (limits->max_components && component_count > limits->max_components) {
+    std::stringstream sstr;
+    sstr << "cmpd box should contain " << component_count << " components, but security limit is set to "
+         << limits->max_components << " components";
+
+    return {heif_error_Invalid_input,
+            heif_suberror_Security_limit_exceeded,
+            sstr.str()
+    };
+  }
+
+  for (unsigned int i = 0; i < component_count ; i++) {
+    if (range.eof()) {
+      std::stringstream sstr;
+      sstr << "cmpd box should contain " << component_count << " components, but box only contained "
+           << i << " components";
+
+      return {heif_error_Invalid_input,
+              heif_suberror_End_of_data,
+              sstr.str()
+      };
+    }
+
+    Component component;
+    component.component_type = range.read16();
+    if (component.component_type >= 0x8000) {
+      component.component_type_uri = range.read_string();
+    }
+    else {
+      component.component_type_uri = std::string();
+    }
+    m_components.push_back(component);
+  }
+
+  return range.get_error();
+}
+
+std::string Box_cmpd::Component::get_component_type_name(uint16_t component_type)
+{
+  std::stringstream sstr;
+
+  if (is_predefined_component_type(component_type)) {
+    sstr << get_name(heif_uncompressed_component_type(component_type), sNames_uncompressed_component_type) << "\n";
+  }
+  else {
+    sstr << "0x" << std::hex << component_type << std::dec << "\n";
+  }
+
+  return sstr.str();
+}
+
+
+bool Box_cmpd::has_component(heif_uncompressed_component_type type) const
+{
+  return std::any_of(m_components.begin(), m_components.end(),
+                     [type](const auto& cmp) { return cmp.component_type == type; });
+}
+
+
+std::string Box_cmpd::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
+
+  for (const auto& component : m_components) {
+    sstr << indent << "component_type: " << component.get_component_type_name();
+
+    if (component.component_type >= 0x8000) {
+      sstr << indent << "| component_type_uri: " << component.component_type_uri << "\n";
+    }
+  }
+
+  return sstr.str();
+}
+
+Error Box_cmpd::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  writer.write32((uint32_t) m_components.size());
+  for (const auto& component : m_components) {
+    writer.write16(component.component_type);
+    if (component.component_type >= 0x8000) {
+      writer.write(component.component_type_uri);
+    }
+  }
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+Error Box_uncC::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  parse_full_box_header(range);
+
+  m_profile = range.read32();
+
+  if (get_version() == 1) {
+    switch (m_profile) {
+      case fourcc("rgb3"):
+      case fourcc("rgba"):
+      case fourcc("abgr"):
+      case fourcc("2vuy"):
+      case fourcc("yuv2"):
+      case fourcc("yvyu"):
+      case fourcc("vyuy"):
+      case fourcc("yuv1"):
+      case fourcc("v308"):
+      case fourcc("v408"):
+      case fourcc("y210"):
+      case fourcc("v410"):
+      case fourcc("v210"):
+      case fourcc("i420"):
+      case fourcc("nv12"):
+      case fourcc("nv21"):
+      case fourcc("yu22"):
+      case fourcc("yv22"):
+      case fourcc("yv20"):
+        break;
+      default:
+        return Error{heif_error_Invalid_input, heif_suberror_Invalid_parameter_value, "Unknown uncC v1 profile"};
+    }
+  } else if (get_version() == 0) {
+
+    uint32_t component_count = range.read32();
+
+    if (limits->max_components && component_count > limits->max_components) {
+      std::stringstream sstr;
+      sstr << "Number of image components (" << component_count << ") exceeds security limit ("
+           << limits->max_components << ")";
+
+      return {heif_error_Invalid_input,
+              heif_suberror_Security_limit_exceeded,
+              sstr.str()};
+    }
+
+    for (uint32_t i = 0; i < component_count && !range.error() && !range.eof(); i++) {
+      Component component;
+      component.component_index = range.read16();
+      component.component_bit_depth = uint16_t(range.read8() + 1);
+      component.component_format = range.read8();
+      component.component_align_size = range.read8();
+      m_components.push_back(component);
+
+      if (!is_valid_component_format(component.component_format)) {
+        return {heif_error_Invalid_input, heif_suberror_Invalid_parameter_value, "Invalid component format"};
+      }
+    }
+
+    m_sampling_type = range.read8();
+    if (!is_valid_sampling_mode(m_sampling_type)) {
+      return {heif_error_Invalid_input, heif_suberror_Invalid_parameter_value, "Invalid sampling mode"};
+    }
+
+    m_interleave_type = range.read8();
+    if (!is_valid_interleave_mode(m_interleave_type)) {
+      return {heif_error_Invalid_input, heif_suberror_Invalid_parameter_value, "Invalid interleave mode"};
+    }
+
+    m_block_size = range.read8();
+
+    uint8_t flags = range.read8();
+    m_components_little_endian = !!(flags & 0x80);
+    m_block_pad_lsb = !!(flags & 0x40);
+    m_block_little_endian = !!(flags & 0x20);
+    m_block_reversed = !!(flags & 0x10);
+    m_pad_unknown = !!(flags & 0x08);
+
+    m_pixel_size = range.read32();
+
+    m_row_align_size = range.read32();
+
+    m_tile_align_size = range.read32();
+
+    uint32_t num_tile_cols_minus_one = range.read32();
+    uint32_t num_tile_rows_minus_one = range.read32();
+
+    if (limits->max_number_of_tiles &&
+        static_cast<uint64_t>(num_tile_cols_minus_one) + 1 > limits->max_number_of_tiles / (static_cast<uint64_t>(num_tile_rows_minus_one) + 1)) {
+      std::stringstream sstr;
+      sstr << "Tiling size "
+           << ((uint64_t)num_tile_cols_minus_one + 1) << " x " << ((uint64_t)num_tile_rows_minus_one + 1)
+           << " exceeds the maximum allowed number " << limits->max_number_of_tiles << " set as security limit";
+      return {heif_error_Memory_allocation_error,
+              heif_suberror_Security_limit_exceeded,
+              sstr.str()};
+    }
+
+    m_num_tile_cols = num_tile_cols_minus_one + 1;
+    m_num_tile_rows = num_tile_rows_minus_one + 1;
+  }
+
+  return range.get_error();
+}
+
+
+
+std::string Box_uncC::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
+
+  sstr << indent << "profile: " << m_profile;
+  if (m_profile != 0) {
+    sstr << " (" << fourcc_to_string(m_profile) << ")";
+  }
+  sstr << "\n";
+  if (get_version() == 0) {
+    for (const auto& component : m_components) {
+      sstr << indent << "component_index: " << component.component_index << "\n";
+      indent++;
+      sstr << indent << "component_bit_depth: " << (int) component.component_bit_depth << "\n";
+      sstr << indent << "component_format: " << get_name(heif_uncompressed_component_format(component.component_format), sNames_uncompressed_component_format) << "\n";
+      sstr << indent << "component_align_size: " << (int) component.component_align_size << "\n";
+      indent--;
+    }
+
+    sstr << indent << "sampling_type: " << get_name(heif_uncompressed_sampling_mode(m_sampling_type), sNames_uncompressed_sampling_mode) << "\n";
+
+    sstr << indent << "interleave_type: " << get_name(heif_uncompressed_interleave_mode(m_interleave_type), sNames_uncompressed_interleave_mode) << "\n";
+
+    sstr << indent << "block_size: " << (int) m_block_size << "\n";
+
+    sstr << indent << "components_little_endian: " << m_components_little_endian << "\n";
+    sstr << indent << "block_pad_lsb: " << m_block_pad_lsb << "\n";
+    sstr << indent << "block_little_endian: " << m_block_little_endian << "\n";
+    sstr << indent << "block_reversed: " << m_block_reversed << "\n";
+    sstr << indent << "pad_unknown: " << m_pad_unknown << "\n";
+
+    sstr << indent << "pixel_size: " << m_pixel_size << "\n";
+
+    sstr << indent << "row_align_size: " << m_row_align_size << "\n";
+
+    sstr << indent << "tile_align_size: " << m_tile_align_size << "\n";
+
+    sstr << indent << "num_tile_cols: " << m_num_tile_cols << "\n";
+
+    sstr << indent << "num_tile_rows: " << m_num_tile_rows << "\n";
+  }
+  return sstr.str();
+}
+
+
+Error Box_uncC::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+  writer.write32(m_profile);
+  if (get_version() == 1) {
+  }
+  else if (get_version() == 0) {
+    writer.write32((uint32_t)m_components.size());
+    for (const auto &component : m_components) {
+      if (component.component_bit_depth < 1 || component.component_bit_depth > 256) {
+        return {heif_error_Invalid_input, heif_suberror_Invalid_parameter_value, "component bit-depth out of range [1..256]"};
+      }
+
+      if (component.component_index > 0xFFFF) {
+        return {heif_error_Invalid_input, heif_suberror_Invalid_parameter_value, "component index must be 16 bit"};
+      }
+      writer.write16(static_cast<uint16_t>(component.component_index));
+      writer.write8(uint8_t(component.component_bit_depth - 1));
+      writer.write8(component.component_format);
+      writer.write8(component.component_align_size);
+    }
+    writer.write8(m_sampling_type);
+    writer.write8(m_interleave_type);
+    writer.write8(m_block_size);
+    uint8_t flags = 0;
+    flags |= (m_components_little_endian ? 0x80 : 0);
+    flags |= (m_block_pad_lsb ? 0x40 : 0);
+    flags |= (m_block_little_endian ? 0x20 : 0);
+    flags |= (m_block_reversed ? 0x10 : 0);
+    flags |= (m_pad_unknown ? 0x08 : 0);
+    writer.write8(flags);
+    writer.write32(m_pixel_size);
+    writer.write32(m_row_align_size);
+    writer.write32(m_tile_align_size);
+    writer.write32(m_num_tile_cols - 1);
+    writer.write32(m_num_tile_rows - 1);
+  }
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+
+void fill_uncC_and_cmpd_from_profile(const std::shared_ptr<Box_uncC>& uncC,
+                                     std::shared_ptr<Box_cmpd>& cmpd)
+{
+  if (uncC->get_version() != 1 || cmpd) {
+    return;
+  }
+
+  // Return cached synthetic cmpd if we already created one.
+  if (auto synthetic = uncC->get_synthetic_cmpd()) {
+    cmpd = synthetic;
+    return;
+  }
+
+  uint32_t profile = uncC->get_profile();
+  cmpd = std::make_shared<Box_cmpd>();
+
+  // Profiles from ISO/IEC 23001-17 Table 5.
+  // Format: {profile, [{component_type, bit_depth_minus_1}, ...], sampling_type, interleave_type}
+  // The implicit cmpd is the unique component_types in order of first appearance.
+  // The uncC component_index refers into that cmpd.
+
+  if (profile == fourcc("rgb3")) {
+    // {'rgb3', [{4,7},{5,7},{6,7}], 0, 1}
+    uncC->add_component({0, 8, component_format_unsigned, 0});
+    uncC->add_component({1, 8, component_format_unsigned, 0});
+    uncC->add_component({2, 8, component_format_unsigned, 0});
+    cmpd->add_component({heif_uncompressed_component_type_red});
+    cmpd->add_component({heif_uncompressed_component_type_green});
+    cmpd->add_component({heif_uncompressed_component_type_blue});
+    uncC->set_sampling_type(sampling_mode_no_subsampling);
+    uncC->set_interleave_type(interleave_mode_pixel);
+  }
+  else if (profile == fourcc("rgba")) {
+    // {'rgba', [{4,7},{5,7},{6,7},{7,7}], 0, 1}
+    uncC->add_component({0, 8, component_format_unsigned, 0});
+    uncC->add_component({1, 8, component_format_unsigned, 0});
+    uncC->add_component({2, 8, component_format_unsigned, 0});
+    uncC->add_component({3, 8, component_format_unsigned, 0});
+    cmpd->add_component({heif_uncompressed_component_type_red});
+    cmpd->add_component({heif_uncompressed_component_type_green});
+    cmpd->add_component({heif_uncompressed_component_type_blue});
+    cmpd->add_component({heif_uncompressed_component_type_alpha});
+    uncC->set_sampling_type(sampling_mode_no_subsampling);
+    uncC->set_interleave_type(interleave_mode_pixel);
+  }
+  else if (profile == fourcc("abgr")) {
+    // {'abgr', [{7,7},{6,7},{5,7},{4,7}], 0, 1}
+    uncC->add_component({0, 8, component_format_unsigned, 0});
+    uncC->add_component({1, 8, component_format_unsigned, 0});
+    uncC->add_component({2, 8, component_format_unsigned, 0});
+    uncC->add_component({3, 8, component_format_unsigned, 0});
+    cmpd->add_component({heif_uncompressed_component_type_alpha});
+    cmpd->add_component({heif_uncompressed_component_type_blue});
+    cmpd->add_component({heif_uncompressed_component_type_green});
+    cmpd->add_component({heif_uncompressed_component_type_red});
+    uncC->set_sampling_type(sampling_mode_no_subsampling);
+    uncC->set_interleave_type(interleave_mode_pixel);
+  }
+  else if (profile == fourcc("2vuy")) {
+    // {'2vuy', [{2,7},{1,7},{3,7},{1,7}], 1, 5}  Cb Y0 Cr Y1
+    // cmpd: Cb(0) Y(1) Cr(2)
+    uncC->add_component({0, 8, component_format_unsigned, 0});
+    uncC->add_component({1, 8, component_format_unsigned, 0});
+    uncC->add_component({2, 8, component_format_unsigned, 0});
+    uncC->add_component({1, 8, component_format_unsigned, 0});
+    cmpd->add_component({heif_uncompressed_component_type_Cb});
+    cmpd->add_component({heif_uncompressed_component_type_Y});
+    cmpd->add_component({heif_uncompressed_component_type_Cr});
+    uncC->set_sampling_type(sampling_mode_422);
+    uncC->set_interleave_type(interleave_mode_multi_y);
+  }
+  else if (profile == fourcc("yuv2")) {
+    // {'yuv2', [{1,7},{2,7},{1,7},{3,7}], 1, 5}  Y0 Cb Y1 Cr
+    // cmpd: Y(0) Cb(1) Cr(2)
+    uncC->add_component({0, 8, component_format_unsigned, 0});
+    uncC->add_component({1, 8, component_format_unsigned, 0});
+    uncC->add_component({0, 8, component_format_unsigned, 0});
+    uncC->add_component({2, 8, component_format_unsigned, 0});
+    cmpd->add_component({heif_uncompressed_component_type_Y});
+    cmpd->add_component({heif_uncompressed_component_type_Cb});
+    cmpd->add_component({heif_uncompressed_component_type_Cr});
+    uncC->set_sampling_type(sampling_mode_422);
+    uncC->set_interleave_type(interleave_mode_multi_y);
+  }
+  else if (profile == fourcc("yvyu")) {
+    // {'yvyu', [{1,7},{3,7},{1,7},{2,7}], 1, 5}  Y0 Cr Y1 Cb
+    // cmpd: Y(0) Cr(1) Cb(2)
+    uncC->add_component({0, 8, component_format_unsigned, 0});
+    uncC->add_component({1, 8, component_format_unsigned, 0});
+    uncC->add_component({0, 8, component_format_unsigned, 0});
+    uncC->add_component({2, 8, component_format_unsigned, 0});
+    cmpd->add_component({heif_uncompressed_component_type_Y});
+    cmpd->add_component({heif_uncompressed_component_type_Cr});
+    cmpd->add_component({heif_uncompressed_component_type_Cb});
+    uncC->set_sampling_type(sampling_mode_422);
+    uncC->set_interleave_type(interleave_mode_multi_y);
+  }
+  else if (profile == fourcc("vyuy")) {
+    // {'vyuy', [{3,7},{1,7},{2,7},{1,7}], 1, 5}  Cr Y0 Cb Y1
+    // cmpd: Cr(0) Y(1) Cb(2)
+    uncC->add_component({0, 8, component_format_unsigned, 0});
+    uncC->add_component({1, 8, component_format_unsigned, 0});
+    uncC->add_component({2, 8, component_format_unsigned, 0});
+    uncC->add_component({1, 8, component_format_unsigned, 0});
+    cmpd->add_component({heif_uncompressed_component_type_Cr});
+    cmpd->add_component({heif_uncompressed_component_type_Y});
+    cmpd->add_component({heif_uncompressed_component_type_Cb});
+    uncC->set_sampling_type(sampling_mode_422);
+    uncC->set_interleave_type(interleave_mode_multi_y);
+  }
+  else if (profile == fourcc("yuv1")) {
+    // {'yuv1', [{1,7},{1,7},{2,7},{1,7},{1,7},{3,7}], 3, 5}  Y0 Y1 Cb Y2 Y3 Cr
+    // cmpd: Y(0) Cb(1) Cr(2)
+    uncC->add_component({0, 8, component_format_unsigned, 0});
+    uncC->add_component({0, 8, component_format_unsigned, 0});
+    uncC->add_component({1, 8, component_format_unsigned, 0});
+    uncC->add_component({0, 8, component_format_unsigned, 0});
+    uncC->add_component({0, 8, component_format_unsigned, 0});
+    uncC->add_component({2, 8, component_format_unsigned, 0});
+    cmpd->add_component({heif_uncompressed_component_type_Y});
+    cmpd->add_component({heif_uncompressed_component_type_Cb});
+    cmpd->add_component({heif_uncompressed_component_type_Cr});
+    uncC->set_sampling_type(sampling_mode_411);
+    uncC->set_interleave_type(interleave_mode_multi_y);
+  }
+  else if (profile == fourcc("v308")) {
+    // {'v308', [{3,7},{1,7},{2,7}], 0, 1}  Cr Y Cb
+    // cmpd: Cr(0) Y(1) Cb(2)
+    uncC->add_component({0, 8, component_format_unsigned, 0});
+    uncC->add_component({1, 8, component_format_unsigned, 0});
+    uncC->add_component({2, 8, component_format_unsigned, 0});
+    cmpd->add_component({heif_uncompressed_component_type_Cr});
+    cmpd->add_component({heif_uncompressed_component_type_Y});
+    cmpd->add_component({heif_uncompressed_component_type_Cb});
+    uncC->set_sampling_type(sampling_mode_no_subsampling);
+    uncC->set_interleave_type(interleave_mode_pixel);
+  }
+  else if (profile == fourcc("v408")) {
+    // {'v408', [{2,7},{1,7},{3,7},{7,7}], 0, 1}  Cb Y Cr A
+    // cmpd: Cb(0) Y(1) Cr(2) alpha(3)
+    uncC->add_component({0, 8, component_format_unsigned, 0});
+    uncC->add_component({1, 8, component_format_unsigned, 0});
+    uncC->add_component({2, 8, component_format_unsigned, 0});
+    uncC->add_component({3, 8, component_format_unsigned, 0});
+    cmpd->add_component({heif_uncompressed_component_type_Cb});
+    cmpd->add_component({heif_uncompressed_component_type_Y});
+    cmpd->add_component({heif_uncompressed_component_type_Cr});
+    cmpd->add_component({heif_uncompressed_component_type_alpha});
+    uncC->set_sampling_type(sampling_mode_no_subsampling);
+    uncC->set_interleave_type(interleave_mode_pixel);
+  }
+  else if (profile == fourcc("y210")) {
+    // {'y210', [{1,9},{2,9},{1,9},{3,9}], 1, 5}  Y0 Cb Y1 Cr
+    // block_size=2, block_little_endian=1, block_pad_lsb=1
+    // cmpd: Y(0) Cb(1) Cr(2)
+    uncC->add_component({0, 10, component_format_unsigned, 0});
+    uncC->add_component({1, 10, component_format_unsigned, 0});
+    uncC->add_component({0, 10, component_format_unsigned, 0});
+    uncC->add_component({2, 10, component_format_unsigned, 0});
+    cmpd->add_component({heif_uncompressed_component_type_Y});
+    cmpd->add_component({heif_uncompressed_component_type_Cb});
+    cmpd->add_component({heif_uncompressed_component_type_Cr});
+    uncC->set_sampling_type(sampling_mode_422);
+    uncC->set_interleave_type(interleave_mode_multi_y);
+    uncC->set_block_size(2);
+    uncC->set_block_little_endian(true);
+    uncC->set_block_pad_lsb(true);
+  }
+  else if (profile == fourcc("v410")) {
+    // {'v410', [{2,9},{1,9},{3,9}], 0, 1}  Cb Y Cr
+    // block_size=4, block_little_endian=1, block_pad_lsb=1, block_reversed=1
+    // cmpd: Cb(0) Y(1) Cr(2)
+    uncC->add_component({0, 10, component_format_unsigned, 0});
+    uncC->add_component({1, 10, component_format_unsigned, 0});
+    uncC->add_component({2, 10, component_format_unsigned, 0});
+    cmpd->add_component({heif_uncompressed_component_type_Cb});
+    cmpd->add_component({heif_uncompressed_component_type_Y});
+    cmpd->add_component({heif_uncompressed_component_type_Cr});
+    uncC->set_sampling_type(sampling_mode_no_subsampling);
+    uncC->set_interleave_type(interleave_mode_pixel);
+    uncC->set_block_size(4);
+    uncC->set_block_little_endian(true);
+    uncC->set_block_pad_lsb(true);
+    uncC->set_block_reversed(true);
+  }
+  else if (profile == fourcc("v210")) {
+    // {'v210', [{2,9},{1,9},{3,9},{1,9}], 1, 5}  Cb Y0 Cr Y1
+    // block_size=4, block_little_endian=1, block_reversed=1
+    // cmpd: Cb(0) Y(1) Cr(2)
+    uncC->add_component({0, 10, component_format_unsigned, 0});
+    uncC->add_component({1, 10, component_format_unsigned, 0});
+    uncC->add_component({2, 10, component_format_unsigned, 0});
+    uncC->add_component({1, 10, component_format_unsigned, 0});
+    cmpd->add_component({heif_uncompressed_component_type_Cb});
+    cmpd->add_component({heif_uncompressed_component_type_Y});
+    cmpd->add_component({heif_uncompressed_component_type_Cr});
+    uncC->set_sampling_type(sampling_mode_422);
+    uncC->set_interleave_type(interleave_mode_multi_y);
+    uncC->set_block_size(4);
+    uncC->set_block_little_endian(true);
+    uncC->set_block_reversed(true);
+  }
+  else if (profile == fourcc("i420")) {
+    // {'i420', [{1,7},{2,7},{3,7}], 2, 0}  planar YCbCr
+    // cmpd: Y(0) Cb(1) Cr(2)
+    uncC->add_component({0, 8, component_format_unsigned, 0});
+    uncC->add_component({1, 8, component_format_unsigned, 0});
+    uncC->add_component({2, 8, component_format_unsigned, 0});
+    cmpd->add_component({heif_uncompressed_component_type_Y});
+    cmpd->add_component({heif_uncompressed_component_type_Cb});
+    cmpd->add_component({heif_uncompressed_component_type_Cr});
+    uncC->set_sampling_type(sampling_mode_420);
+    uncC->set_interleave_type(interleave_mode_component);
+  }
+  else if (profile == fourcc("nv12")) {
+    // {'nv12', [{1,7},{2,7},{3,7}], 2, 2}  semi-planar YCbCr
+    // cmpd: Y(0) Cb(1) Cr(2)
+    uncC->add_component({0, 8, component_format_unsigned, 0});
+    uncC->add_component({1, 8, component_format_unsigned, 0});
+    uncC->add_component({2, 8, component_format_unsigned, 0});
+    cmpd->add_component({heif_uncompressed_component_type_Y});
+    cmpd->add_component({heif_uncompressed_component_type_Cb});
+    cmpd->add_component({heif_uncompressed_component_type_Cr});
+    uncC->set_sampling_type(sampling_mode_420);
+    uncC->set_interleave_type(interleave_mode_mixed);
+  }
+  else if (profile == fourcc("nv21")) {
+    // {'nv21', [{1,7},{3,7},{2,7}], 2, 2}  semi-planar YCrCb
+    // cmpd: Y(0) Cr(1) Cb(2)
+    uncC->add_component({0, 8, component_format_unsigned, 0});
+    uncC->add_component({1, 8, component_format_unsigned, 0});
+    uncC->add_component({2, 8, component_format_unsigned, 0});
+    cmpd->add_component({heif_uncompressed_component_type_Y});
+    cmpd->add_component({heif_uncompressed_component_type_Cr});
+    cmpd->add_component({heif_uncompressed_component_type_Cb});
+    uncC->set_sampling_type(sampling_mode_420);
+    uncC->set_interleave_type(interleave_mode_mixed);
+  }
+  else if (profile == fourcc("yu22")) {
+    // {'yu22', [{1,7},{2,7},{3,7}], 1, 0}  planar YCbCr
+    // cmpd: Y(0) Cb(1) Cr(2)
+    uncC->add_component({0, 8, component_format_unsigned, 0});
+    uncC->add_component({1, 8, component_format_unsigned, 0});
+    uncC->add_component({2, 8, component_format_unsigned, 0});
+    cmpd->add_component({heif_uncompressed_component_type_Y});
+    cmpd->add_component({heif_uncompressed_component_type_Cb});
+    cmpd->add_component({heif_uncompressed_component_type_Cr});
+    uncC->set_sampling_type(sampling_mode_422);
+    uncC->set_interleave_type(interleave_mode_component);
+  }
+  else if (profile == fourcc("yv22")) {
+    // {'yv22', [{1,7},{3,7},{2,7}], 1, 0}  planar YCrCb
+    // cmpd: Y(0) Cr(1) Cb(2)
+    uncC->add_component({0, 8, component_format_unsigned, 0});
+    uncC->add_component({1, 8, component_format_unsigned, 0});
+    uncC->add_component({2, 8, component_format_unsigned, 0});
+    cmpd->add_component({heif_uncompressed_component_type_Y});
+    cmpd->add_component({heif_uncompressed_component_type_Cr});
+    cmpd->add_component({heif_uncompressed_component_type_Cb});
+    uncC->set_sampling_type(sampling_mode_422);
+    uncC->set_interleave_type(interleave_mode_component);
+  }
+  else if (profile == fourcc("yv20")) {
+    // {'yv20', [{1,7},{3,7},{2,7}], 2, 0}  planar YCrCb
+    // cmpd: Y(0) Cr(1) Cb(2)
+    uncC->add_component({0, 8, component_format_unsigned, 0});
+    uncC->add_component({1, 8, component_format_unsigned, 0});
+    uncC->add_component({2, 8, component_format_unsigned, 0});
+    cmpd->add_component({heif_uncompressed_component_type_Y});
+    cmpd->add_component({heif_uncompressed_component_type_Cr});
+    cmpd->add_component({heif_uncompressed_component_type_Cb});
+    uncC->set_sampling_type(sampling_mode_420);
+    uncC->set_interleave_type(interleave_mode_component);
+  }
+  else {
+    cmpd.reset();
+    return;
+  }
+
+  uncC->set_synthetic_cmpd(cmpd);
+}
+
+
+Error Box_cmpC::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  parse_full_box_header(range);
+
+  if (get_version() != 0) {
+    return unsupported_version_error("cmpC");
+  }
+
+  m_compression_type = range.read32();
+
+  uint8_t unit_type = range.read8();
+  if (unit_type > heif_cmpC_compressed_unit_type_image_pixel) {
+    return {heif_error_Invalid_input,
+            heif_suberror_Unsupported_parameter,
+            "Unsupported cmpC compressed unit type"};
+  };
+
+  m_compressed_unit_type = static_cast<heif_cmpC_compressed_unit_type>(unit_type);
+
+  return range.get_error();
+}
+
+
+std::string Box_cmpC::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
+  sstr << indent << "compression_type: " << fourcc_to_string(m_compression_type) << "\n";
+  sstr << indent << "compressed_entity_type: " << (int)m_compressed_unit_type << "\n";
+  return sstr.str();
+}
+
+Error Box_cmpC::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  writer.write32(m_compression_type);
+  writer.write8(m_compressed_unit_type);
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+
+static uint8_t unit_offset_bits_table[] = {0, 16, 24, 32, 64 };
+static uint8_t unit_size_bits_table[] = {8, 16, 24, 32, 64 };
+
+Error Box_icef::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  parse_full_box_header(range);
+
+  if (get_version() != 0) {
+    return unsupported_version_error("icef");
+  }
+  uint8_t codes = range.read8();
+  uint8_t unit_offset_code = (codes & 0b11100000) >> 5;
+  uint8_t unit_size_code = (codes & 0b00011100) >> 2;
+  uint32_t num_compressed_units = range.read32();
+  uint64_t implied_offset = 0;
+
+  if (unit_offset_code > 4) {
+    return {heif_error_Usage_error, heif_suberror_Unsupported_parameter, "Unsupported icef unit offset code"};
+  }
+
+  if (unit_size_code > 4) {
+    return {heif_error_Usage_error, heif_suberror_Unsupported_parameter, "Unsupported icef unit size code"};
+  }
+
+  // --- precompute fields lengths
+
+  uint8_t unit_offset_bits = unit_offset_bits_table[unit_offset_code];
+  uint8_t unit_size_bits = unit_size_bits_table[unit_size_code];
+
+  // --- check if box is large enough for all the data
+
+  uint64_t data_size_bytes = static_cast<uint64_t>(num_compressed_units) * (unit_offset_bits + unit_size_bits) / 8;
+  if (data_size_bytes > range.get_remaining_bytes()) {
+    uint64_t contained_units = range.get_remaining_bytes() / ((unit_offset_bits + unit_size_bits) * 8);
+    std::stringstream sstr;
+    sstr << "icef box declares " << num_compressed_units << " units, but only " << contained_units
+         << " were contained in the file";
+    return {heif_error_Invalid_input,
+            heif_suberror_End_of_data,
+            sstr.str()};
+  }
+
+  // TODO: should we impose some security limit?
+
+  // --- read box content
+
+  m_unit_infos.resize(num_compressed_units);
+
+  for (uint32_t r = 0; r < num_compressed_units; r++) {
+    struct CompressedUnitInfo unitInfo;
+    if (unit_offset_code == 0) {
+      unitInfo.unit_offset = implied_offset;
+    } else {
+      unitInfo.unit_offset = range.read_uint(unit_offset_bits);
+    }
+
+    unitInfo.unit_size = range.read_uint(unit_size_bits);
+
+    if (unitInfo.unit_size >= UINT64_MAX - implied_offset) {
+      return {heif_error_Invalid_input,
+              heif_suberror_Invalid_parameter_value,
+              "cumulative offsets too large for 64 bit file size"};
+    }
+
+    implied_offset += unitInfo.unit_size;
+
+    if (range.get_error() != Error::Ok) {
+      return range.get_error();
+    }
+
+    m_unit_infos[r] = unitInfo;
+  }
+
+  return range.get_error();
+}
+
+
+std::string Box_icef::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
+  sstr << indent << "num_compressed_units: " << m_unit_infos.size() << "\n";
+  for (CompressedUnitInfo unit_info: m_unit_infos) {
+    sstr << indent << "unit_offset: " << unit_info.unit_offset << ", unit_size: " << unit_info.unit_size << "\n";
+  }
+  return sstr.str();
+}
+
+Error Box_icef::write(StreamWriter& writer) const
+{
+  // check that all units have a non-zero size
+
+  for (const CompressedUnitInfo& unit_info: m_unit_infos) {
+    if (unit_info.unit_size == 0) {
+      return {
+        heif_error_Usage_error,
+        heif_suberror_Unspecified,
+        "tiled 'unci' image has an undefined tile."
+      };
+    }
+  }
+
+  size_t box_start = reserve_box_header_space(writer);
+
+  uint8_t unit_offset_code = 1;
+  uint8_t unit_size_code = 0;
+  uint64_t implied_offset = 0;
+  bool can_use_implied_offsets = true;
+  for (const CompressedUnitInfo& unit_info: m_unit_infos) {
+    if (unit_info.unit_offset != implied_offset) {
+      can_use_implied_offsets = false;
+    }
+    if (unit_info.unit_size > (std::numeric_limits<uint64_t>::max() - implied_offset)) {
+      can_use_implied_offsets = false;
+    } else {
+      implied_offset += unit_info.unit_size;
+    }
+    uint8_t required_offset_code = get_required_offset_code(unit_info.unit_offset);
+    if (required_offset_code > unit_offset_code) {
+      unit_offset_code = required_offset_code;
+    }
+    uint8_t required_size_code = get_required_size_code(unit_info.unit_size);
+    if (required_size_code > unit_size_code) {
+      unit_size_code = required_size_code;
+    }
+  }
+  if (can_use_implied_offsets) {
+    unit_offset_code = 0;
+  }
+  uint8_t code_bits = (uint8_t)((unit_offset_code << 5) | (unit_size_code << 2));
+  writer.write8(code_bits);
+  writer.write32((uint32_t)m_unit_infos.size());
+  for (CompressedUnitInfo unit_info: m_unit_infos) {
+    if (unit_offset_code == 0) {
+      // nothing
+    } else if (unit_offset_code == 1) {
+      writer.write16((uint16_t)unit_info.unit_offset);
+    } else if (unit_offset_code == 2) {
+      writer.write24((uint32_t)unit_info.unit_offset);
+    } else if (unit_offset_code == 3) {
+      writer.write32((uint32_t)unit_info.unit_offset);
+    } else {
+      writer.write64(unit_info.unit_offset);
+    }
+    if (unit_size_code == 0) {
+      writer.write8((uint8_t)unit_info.unit_size);
+    } else if (unit_size_code == 1) {
+      writer.write16((uint16_t)unit_info.unit_size);
+    } else if (unit_size_code == 2) {
+      writer.write24((uint32_t)unit_info.unit_size);
+    } else if (unit_size_code == 3) {
+      writer.write32((uint32_t)unit_info.unit_size);
+    } else {
+      writer.write64(unit_info.unit_size);
+    }
+  }
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+static uint64_t MAX_OFFSET_UNIT_CODE_1 = std::numeric_limits<uint16_t>::max();
+static uint64_t MAX_OFFSET_UNIT_CODE_2 = (1ULL << 24) - 1;
+static uint64_t MAX_OFFSET_UNIT_CODE_3 = std::numeric_limits<uint32_t>::max();
+
+const uint8_t Box_icef::get_required_offset_code(uint64_t offset) const
+{
+  if (offset <= MAX_OFFSET_UNIT_CODE_1) {
+    return 1;
+  }
+  if (offset <= MAX_OFFSET_UNIT_CODE_2) {
+    return 2;
+  }
+  if (offset <= MAX_OFFSET_UNIT_CODE_3) {
+    return 3;
+  }
+  return 4;
+}
+
+static uint64_t MAX_SIZE_UNIT_CODE_0 = std::numeric_limits<uint8_t>::max();
+static uint64_t MAX_SIZE_UNIT_CODE_1 = std::numeric_limits<uint16_t>::max();
+static uint64_t MAX_SIZE_UNIT_CODE_2 = (1ULL << 24) - 1;
+static uint64_t MAX_SIZE_UNIT_CODE_3 = std::numeric_limits<uint32_t>::max();
+
+const uint8_t Box_icef::get_required_size_code(uint64_t size) const
+{
+  if (size <= MAX_SIZE_UNIT_CODE_0) {
+    return 0;
+  }
+  if (size <= MAX_SIZE_UNIT_CODE_1) {
+    return 1;
+  }
+  if (size <= MAX_SIZE_UNIT_CODE_2) {
+    return 2;
+  }
+  if (size <= MAX_SIZE_UNIT_CODE_3) {
+    return 3;
+  }
+  return 4;
+}
+
+
+Error Box_cpat::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  parse_full_box_header(range);
+
+  if (get_version() != 0) {
+    return unsupported_version_error("cpat");
+  }
+
+  m_pattern.pattern_width = range.read16();
+  m_pattern.pattern_height = range.read16();
+
+  if (m_pattern.pattern_width == 0 || m_pattern.pattern_height == 0) {
+    return {heif_error_Invalid_input,
+            heif_suberror_Invalid_parameter_value,
+            "Zero Bayer pattern size."};
+  }
+
+  auto max_bayer_pattern_size = limits->max_bayer_pattern_pixels;
+  if (max_bayer_pattern_size && m_pattern.pattern_height > max_bayer_pattern_size / m_pattern.pattern_width) {
+    return {heif_error_Invalid_input,
+            heif_suberror_Security_limit_exceeded,
+            "Maximum Bayer pattern size exceeded."};
+  }
+
+  size_t num_pixels = size_t{m_pattern.pattern_width} * m_pattern.pattern_height;
+  m_pattern.pixels.resize(num_pixels);
+
+  for (size_t i = 0; i < num_pixels; i++) {
+    heif_bayer_pattern_pixel pixel{};
+    pixel.component_index = static_cast<uint16_t>(range.read32());
+    pixel.component_gain = range.read_float32();
+    m_pattern.pixels[i] = pixel;
+  }
+
+  return range.get_error();
+}
+
+
+std::string Box_cpat::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+
+  sstr << FullBox::dump(indent);
+  sstr << indent << "pattern_width: " << get_pattern_width() << "\n";
+  sstr << indent << "pattern_height: " << get_pattern_height() << "\n";
+
+  for (const auto& pixel : m_pattern.pixels) {
+    sstr << indent << "component index: " << pixel.component_index << ", gain: " << pixel.component_gain << "\n";
+  }
+  return sstr.str();
+}
+
+
+Error Box_cpat::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  if (m_pattern.pattern_width * size_t{m_pattern.pattern_height} != m_pattern.pixels.size()) {
+    return {heif_error_Usage_error,
+            heif_suberror_Invalid_parameter_value,
+            "incorrect number of pattern components"};
+  }
+
+  writer.write16(m_pattern.pattern_width);
+  writer.write16(m_pattern.pattern_height);
+
+  for (const auto& pixel : m_pattern.pixels) {
+    writer.write32(pixel.component_index);
+    writer.write_float32(pixel.component_gain);
+  }
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+
+Error Box_splz::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  parse_full_box_header(range);
+
+  if (get_version() != 0) {
+    return unsupported_version_error("splz");
+  }
+
+  uint32_t component_count = range.read32();
+  if (limits->max_components && component_count > limits->max_components) {
+    return {heif_error_Invalid_input,
+            heif_suberror_Security_limit_exceeded,
+            "Number of components in splz box exceeds the security limits."};
+  }
+
+  m_pattern.component_indices.resize(component_count);
+  for (uint32_t i = 0; i < component_count; i++) {
+    m_pattern.component_indices[i] = range.read32();
+  }
+
+  m_pattern.pattern_width = range.read16();
+  m_pattern.pattern_height = range.read16();
+
+  if (m_pattern.pattern_width == 0 || m_pattern.pattern_height == 0) {
+    return {heif_error_Invalid_input,
+            heif_suberror_Invalid_parameter_value,
+            "Zero polarization pattern size."};
+  }
+
+  auto max_pattern_size = limits->max_bayer_pattern_pixels;
+  if (max_pattern_size && m_pattern.pattern_height > max_pattern_size / m_pattern.pattern_width) {
+    return {heif_error_Invalid_input,
+            heif_suberror_Security_limit_exceeded,
+            "Maximum polarization pattern size exceeded."};
+  }
+
+  size_t num_pixels = size_t{m_pattern.pattern_width} * m_pattern.pattern_height;
+  m_pattern.polarization_angles.resize(num_pixels);
+
+  for (size_t i = 0; i < num_pixels; i++) {
+    m_pattern.polarization_angles[i] = range.read_float32();
+  }
+
+  return range.get_error();
+}
+
+
+std::string Box_splz::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+
+  sstr << FullBox::dump(indent);
+
+  sstr << indent << "component_count: " << m_pattern.component_indices.size() << "\n";
+  for (size_t i = 0; i < m_pattern.component_indices.size(); i++) {
+    sstr << indent << "  component_index[" << i << "]: " << m_pattern.component_indices[i] << "\n";
+  }
+
+  sstr << indent << "pattern_width: " << m_pattern.pattern_width << "\n";
+  sstr << indent << "pattern_height: " << m_pattern.pattern_height << "\n";
+
+  for (uint16_t y = 0; y < m_pattern.pattern_height; y++) {
+    for (uint16_t x = 0; x < m_pattern.pattern_width; x++) {
+      float angle = m_pattern.polarization_angles[y * m_pattern.pattern_width + x];
+      if (heif_polarization_angle_is_no_filter(angle)) {
+        sstr << indent << "  [" << x << "," << y << "]: no filter\n";
+      }
+      else {
+        sstr << indent << "  [" << x << "," << y << "]: " << angle << " degrees\n";
+      }
+    }
+  }
+
+  return sstr.str();
+}
+
+
+Error Box_splz::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  if (m_pattern.pattern_width * size_t{m_pattern.pattern_height} != m_pattern.polarization_angles.size()) {
+    return {heif_error_Usage_error,
+            heif_suberror_Invalid_parameter_value,
+            "incorrect number of polarization pattern angles"};
+  }
+
+  writer.write32(static_cast<uint32_t>(m_pattern.component_indices.size()));
+  for (uint32_t idx : m_pattern.component_indices) {
+    writer.write32(idx);
+  }
+
+  writer.write16(m_pattern.pattern_width);
+  writer.write16(m_pattern.pattern_height);
+
+  for (float angle : m_pattern.polarization_angles) {
+    writer.write_float32(angle);
+  }
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+
+Error Box_sbpm::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  parse_full_box_header(range);
+
+  if (get_version() != 0) {
+    return unsupported_version_error("sbpm");
+  }
+
+  uint32_t component_count = range.read32();
+
+  if (limits->max_components && component_count > limits->max_components) {
+    return {heif_error_Invalid_input,
+            heif_suberror_Security_limit_exceeded,
+            "sbpm component_count exceeds security limit."};
+  }
+
+  m_map.component_indices.resize(component_count);
+  for (uint32_t i = 0; i < component_count; i++) {
+    m_map.component_indices[i] = range.read32();
+  }
+
+  uint8_t flags = range.read8();
+  m_map.correction_applied = !!(flags & 0x80);
+
+  uint32_t num_bad_rows = range.read32();
+  uint32_t num_bad_cols = range.read32();
+  uint32_t num_bad_pixels = range.read32();
+
+  // Security check: limit total number of entries
+  uint64_t total_entries = static_cast<uint64_t>(num_bad_rows) + num_bad_cols + num_bad_pixels;
+  if (limits->max_bad_pixels && total_entries > limits->max_bad_pixels) {
+    return {heif_error_Invalid_input,
+            heif_suberror_Security_limit_exceeded,
+            "sbpm total bad pixel entries exceed security limit."};
+  }
+
+  m_map.bad_rows.resize(num_bad_rows);
+  for (uint32_t i = 0; i < num_bad_rows; i++) {
+    m_map.bad_rows[i] = range.read32();
+  }
+
+  m_map.bad_columns.resize(num_bad_cols);
+  for (uint32_t i = 0; i < num_bad_cols; i++) {
+    m_map.bad_columns[i] = range.read32();
+  }
+
+  m_map.bad_pixels.resize(num_bad_pixels);
+  for (uint32_t i = 0; i < num_bad_pixels; i++) {
+    m_map.bad_pixels[i].row = range.read32();
+    m_map.bad_pixels[i].column = range.read32();
+  }
+
+  return range.get_error();
+}
+
+
+std::string Box_sbpm::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+
+  sstr << FullBox::dump(indent);
+
+  sstr << indent << "component_count: " << m_map.component_indices.size() << "\n";
+  for (size_t i = 0; i < m_map.component_indices.size(); i++) {
+    sstr << indent << "  component_index[" << i << "]: " << m_map.component_indices[i] << "\n";
+  }
+
+  sstr << indent << "correction_applied: " << m_map.correction_applied << "\n";
+
+  sstr << indent << "num_bad_rows: " << m_map.bad_rows.size() << "\n";
+  for (size_t i = 0; i < m_map.bad_rows.size(); i++) {
+    sstr << indent << "  bad_row[" << i << "]: " << m_map.bad_rows[i] << "\n";
+  }
+
+  sstr << indent << "num_bad_columns: " << m_map.bad_columns.size() << "\n";
+  for (size_t i = 0; i < m_map.bad_columns.size(); i++) {
+    sstr << indent << "  bad_column[" << i << "]: " << m_map.bad_columns[i] << "\n";
+  }
+
+  sstr << indent << "num_bad_pixels: " << m_map.bad_pixels.size() << "\n";
+  for (size_t i = 0; i < m_map.bad_pixels.size(); i++) {
+    sstr << indent << "  bad_pixel[" << i << "]: row=" << m_map.bad_pixels[i].row
+         << ", column=" << m_map.bad_pixels[i].column << "\n";
+  }
+
+  return sstr.str();
+}
+
+
+Error Box_sbpm::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  writer.write32(static_cast<uint32_t>(m_map.component_indices.size()));
+  for (uint32_t idx : m_map.component_indices) {
+    writer.write32(idx);
+  }
+
+  uint8_t flags = m_map.correction_applied ? 0x80 : 0;
+  writer.write8(flags);
+
+  writer.write32(static_cast<uint32_t>(m_map.bad_rows.size()));
+  writer.write32(static_cast<uint32_t>(m_map.bad_columns.size()));
+  writer.write32(static_cast<uint32_t>(m_map.bad_pixels.size()));
+
+  for (uint32_t row : m_map.bad_rows) {
+    writer.write32(row);
+  }
+
+  for (uint32_t col : m_map.bad_columns) {
+    writer.write32(col);
+  }
+
+  for (const auto& pixel : m_map.bad_pixels) {
+    writer.write32(pixel.row);
+    writer.write32(pixel.column);
+  }
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+
+Error Box_snuc::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  parse_full_box_header(range);
+
+  if (get_version() != 0) {
+    return unsupported_version_error("snuc");
+  }
+
+  uint32_t component_count = range.read32();
+
+  if (limits->max_components && component_count > limits->max_components) {
+    return {heif_error_Invalid_input,
+            heif_suberror_Security_limit_exceeded,
+            "snuc component_count exceeds security limit."};
+  }
+
+  m_nuc.component_indices.resize(component_count);
+  for (uint32_t i = 0; i < component_count; i++) {
+    m_nuc.component_indices[i] = range.read32();
+  }
+
+  uint8_t flags = range.read8();
+  m_nuc.nuc_is_applied = !!(flags & 0x80);
+
+  m_nuc.image_width = range.read32();
+  m_nuc.image_height = range.read32();
+
+  if (m_nuc.image_width == 0 || m_nuc.image_height == 0) {
+    return {heif_error_Invalid_input,
+            heif_suberror_Invalid_parameter_value,
+            "snuc image width and height must be non-zero."};
+  }
+
+  uint64_t num_pixels = static_cast<uint64_t>(m_nuc.image_width) * m_nuc.image_height;
+
+  if (limits->max_image_size_pixels && num_pixels > limits->max_image_size_pixels) {
+    return {heif_error_Invalid_input,
+            heif_suberror_Security_limit_exceeded,
+            "snuc image dimensions exceed security limit."};
+  }
+
+  // Prevent size_t overflow when computing alloc size (matters on 32-bit systems)
+  if (std::numeric_limits<size_t>::max() / num_pixels < 2 * sizeof(float)) {
+    return {heif_error_Invalid_input,
+            heif_suberror_Security_limit_exceeded,
+            "snuc image memory size exceeds max integer size."};
+  }
+
+  Error err = m_memory_handle.alloc(2 * sizeof(float) * num_pixels, limits, "snuc box");
+  if (err) {
+    return err;
+  }
+
+  m_nuc.nuc_gains.resize(num_pixels);
+  for (uint64_t i = 0; i < num_pixels; i++) {
+    m_nuc.nuc_gains[i] = range.read_float32();
+  }
+
+  m_nuc.nuc_offsets.resize(num_pixels);
+  for (uint64_t i = 0; i < num_pixels; i++) {
+    m_nuc.nuc_offsets[i] = range.read_float32();
+  }
+
+  return range.get_error();
+}
+
+
+std::string Box_snuc::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+
+  sstr << FullBox::dump(indent);
+
+  sstr << indent << "component_count: " << m_nuc.component_indices.size() << "\n";
+  for (size_t i = 0; i < m_nuc.component_indices.size(); i++) {
+    sstr << indent << "  component_index[" << i << "]: " << m_nuc.component_indices[i] << "\n";
+  }
+
+  sstr << indent << "nuc_is_applied: " << m_nuc.nuc_is_applied << "\n";
+  sstr << indent << "image_width: " << m_nuc.image_width << "\n";
+  sstr << indent << "image_height: " << m_nuc.image_height << "\n";
+
+  uint64_t num_pixels = static_cast<uint64_t>(m_nuc.image_width) * m_nuc.image_height;
+  sstr << indent << "nuc_gains: " << num_pixels << " values\n";
+  sstr << indent << "nuc_offsets: " << num_pixels << " values\n";
+
+  return sstr.str();
+}
+
+
+Error Box_snuc::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  writer.write32(static_cast<uint32_t>(m_nuc.component_indices.size()));
+  for (uint32_t idx : m_nuc.component_indices) {
+    writer.write32(idx);
+  }
+
+  uint8_t flags = m_nuc.nuc_is_applied ? 0x80 : 0;
+  writer.write8(flags);
+
+  writer.write32(m_nuc.image_width);
+  writer.write32(m_nuc.image_height);
+
+  for (float gain : m_nuc.nuc_gains) {
+    writer.write_float32(gain);
+  }
+
+  for (float offset : m_nuc.nuc_offsets) {
+    writer.write_float32(offset);
+  }
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+
+Error Box_cloc::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  parse_full_box_header(range);
+
+  if (get_version() != 0) {
+    return unsupported_version_error("cloc");
+  }
+
+  m_chroma_location = range.read8();
+
+  if (m_chroma_location > 6) {
+    return {heif_error_Invalid_input,
+            heif_suberror_Invalid_parameter_value,
+            "cloc chroma_location value out of range (must be 0-6)."};
+  }
+
+  return range.get_error();
+}
+
+
+std::string Box_cloc::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+
+  sstr << FullBox::dump(indent);
+
+  static const char* location_names[] = {
+    "h=0,   v=0.5",   // 0
+    "h=0.5, v=0.5",   // 1
+    "h=0,   v=0",     // 2
+    "h=0.5, v=0",     // 3
+    "h=0,   v=1",     // 4
+    "h=0.5, v=1",     // 5
+    "Cr:0,0 / Cb:1,0" // 6
+  };
+
+  sstr << indent << "chroma_location: " << static_cast<int>(m_chroma_location);
+  if (m_chroma_location <= 6) {
+    sstr << " (" << location_names[m_chroma_location] << ")";
+  }
+  sstr << "\n";
+
+  return sstr.str();
+}
+
+
+Error Box_cloc::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  writer.write8(m_chroma_location);
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+
+Error Box_gimi_component_content_ids::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  uint32_t number_of_components = range.read32();
+
+  if (limits->max_components && number_of_components > limits->max_components) {
+    std::stringstream sstr;
+    sstr << "GIMI component content IDs box contains " << number_of_components
+         << " components, but security limit is set to " << limits->max_components << " components";
+    return {heif_error_Invalid_input,
+            heif_suberror_Security_limit_exceeded,
+            sstr.str()};
+  }
+
+  for (uint32_t i = 0; i < number_of_components; i++) {
+    if (range.eof()) {
+      return {heif_error_Invalid_input,
+              heif_suberror_End_of_data,
+              "Not enough data for all component content IDs"};
+    }
+    m_content_ids.push_back(range.read_string());
+  }
+
+  return range.get_error();
+}
+
+
+Error Box_gimi_component_content_ids::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  writer.write32(static_cast<uint32_t>(m_content_ids.size()));
+
+  for (const auto& id : m_content_ids) {
+    writer.write(id);
+  }
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+
+std::string Box_gimi_component_content_ids::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
+
+  for (size_t i = 0; i < m_content_ids.size(); i++) {
+    sstr << indent << "[" << i << "] content ID: " << m_content_ids[i] << "\n";
+  }
+
+  return sstr.str();
+}
diff --git a/libheif/codecs/uncompressed/unc_boxes.h b/libheif/codecs/uncompressed/unc_boxes.h
new file mode 100644
index 0000000000..1ce7ef4813
--- /dev/null
+++ b/libheif/codecs/uncompressed/unc_boxes.h
@@ -0,0 +1,544 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef LIBHEIF_UNC_BOXES_H
+#define LIBHEIF_UNC_BOXES_H
+
+#include "box.h"
+#include "bitstream.h"
+#include "pixelimage.h"
+#include "unc_types.h"
+#include "sequences/seq_boxes.h"
+
+#include <cstdint>
+#include <string>
+#include <vector>
+#include <memory>
+#include <utility>
+
+
+/**
+ * Component definition (cmpd) box.
+ */
+class Box_cmpd : public Box
+{
+public:
+  Box_cmpd()
+  {
+    set_short_type(fourcc("cmpd"));
+  }
+
+  std::string dump(Indent&) const override;
+
+  Error write(StreamWriter& writer) const override;
+
+  bool is_essential() const override { return true; }
+
+  struct Component
+  {
+    uint16_t component_type;
+    std::string component_type_uri;
+
+    std::string get_component_type_name() const { return get_component_type_name(component_type); }
+
+    static std::string get_component_type_name(uint16_t type);
+  };
+
+  const std::vector<Component>& get_components() const { return m_components; }
+
+  bool has_component(heif_uncompressed_component_type) const;
+
+  uint16_t add_component(const Component& component)
+  {
+    auto index = static_cast<uint16_t>(m_components.size());
+    m_components.push_back(component);
+    return index;
+  }
+
+  void set_components(const std::vector<uint16_t>&);
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits* limits) override;
+
+  std::vector<Component> m_components;
+};
+
+/**
+ * Uncompressed Frame Configuration Box
+*/
+class Box_uncC : public FullBox
+{
+public:
+  Box_uncC() {
+    set_short_type(fourcc("uncC"));
+  }
+
+  bool is_essential() const override { return true; }
+
+  bool is_minimized() const
+  {
+    return m_profile != 0 && m_num_tile_cols==1 && m_num_tile_rows==1;
+  }
+
+  void derive_box_version() override
+  {
+    set_version(is_minimized() ? 1 : 0);
+  }
+
+  std::string dump(Indent&) const override;
+
+  Error write(StreamWriter& writer) const override;
+
+  struct Component
+  {
+    uint32_t component_index;
+    uint16_t component_bit_depth; // range [1..256]
+    uint8_t component_format;
+    uint8_t component_align_size;
+  };
+
+  const std::vector<Component>& get_components() const { return m_components; }
+
+  void add_component(Component component)
+  {
+    m_components.push_back(component);
+  }
+
+  uint32_t get_profile() const { return m_profile; }
+
+  void set_profile(const uint32_t profile)
+  {
+    m_profile = profile;
+  }
+
+  uint8_t get_sampling_type() const { return m_sampling_type; }
+
+  void set_sampling_type(const uint8_t sampling_type)
+  {
+    m_sampling_type = sampling_type;
+  }
+
+  uint8_t get_interleave_type() const { return m_interleave_type; }
+
+  void set_interleave_type(const uint8_t interleave_type)
+  {
+    m_interleave_type = interleave_type;
+  }
+
+  uint8_t get_block_size() const { return m_block_size; }
+
+  void set_block_size(const uint8_t block_size)
+  {
+    m_block_size = block_size;
+  }
+
+  bool is_components_little_endian() const { return m_components_little_endian; }
+
+  void set_components_little_endian (const bool components_little_endian)
+  {
+    m_components_little_endian = components_little_endian;
+  }
+
+  bool is_block_pad_lsb() const { return m_block_pad_lsb; }
+
+  void set_block_pad_lsb(const bool block_pad_lsb)
+  {
+    m_block_pad_lsb = block_pad_lsb;
+  }
+
+  bool is_block_little_endian() const { return m_block_little_endian; }
+
+  void set_block_little_endian(const bool block_little_endian)
+  {
+    m_block_little_endian = block_little_endian;
+  }
+
+  bool is_block_reversed() const { return m_block_reversed; }
+
+  void set_block_reversed(const bool block_reversed)
+  {
+    m_block_reversed = block_reversed;
+  }
+
+  bool is_pad_unknown() const { return m_pad_unknown; }
+
+  void set_pad_unknown(const bool pad_unknown)
+  {
+    m_pad_unknown = pad_unknown;
+  }
+
+  uint32_t get_pixel_size() const { return m_pixel_size; }
+
+  void set_pixel_size(const uint32_t pixel_size)
+  {
+    m_pixel_size = pixel_size;
+  }
+
+  uint32_t get_row_align_size() const { return m_row_align_size; }
+
+  void set_row_align_size(const uint32_t row_align_size)
+  {
+    m_row_align_size = row_align_size;
+  }
+
+  uint32_t get_tile_align_size() const { return m_tile_align_size; }
+
+  void set_tile_align_size(const uint32_t tile_align_size)
+  {
+    m_tile_align_size = tile_align_size;
+  }
+
+  uint32_t get_number_of_tile_columns() const { return m_num_tile_cols; }
+
+  void set_number_of_tile_columns(const uint32_t num_tile_cols)
+  {
+    m_num_tile_cols = num_tile_cols;
+  }
+
+  uint32_t get_number_of_tile_rows() const { return m_num_tile_rows; }
+
+  void set_number_of_tile_rows(const uint32_t num_tile_rows)
+  {
+    m_num_tile_rows = num_tile_rows;
+  }
+
+  uint32_t get_number_of_tiles() const { return m_num_tile_rows * m_num_tile_rows; }
+
+  std::shared_ptr<Box_cmpd> get_synthetic_cmpd() const { return m_synthetic_cmpd; }
+
+  void set_synthetic_cmpd(std::shared_ptr<Box_cmpd> cmpd) { m_synthetic_cmpd = std::move(cmpd); }
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits* limits) override;
+
+  uint32_t m_profile = 0; // 0 = not compliant to any profile
+
+  std::vector<Component> m_components;
+  uint8_t m_sampling_type = sampling_mode_no_subsampling; // no subsampling
+  uint8_t m_interleave_type = interleave_mode_pixel; // component interleaving
+  uint8_t m_block_size = 0;
+  bool m_components_little_endian = false;
+  bool m_block_pad_lsb = false;
+  bool m_block_little_endian = false;
+  bool m_block_reversed = false;
+  bool m_pad_unknown = false;
+  uint32_t m_pixel_size = 0;
+  uint32_t m_row_align_size = 0;
+  uint32_t m_tile_align_size = 0;
+  uint32_t m_num_tile_cols = 1;
+  uint32_t m_num_tile_rows = 1;
+
+  std::shared_ptr<Box_cmpd> m_synthetic_cmpd;
+};
+
+
+enum heif_cmpC_compressed_unit_type {
+  heif_cmpC_compressed_unit_type_full_item = 0,
+  heif_cmpC_compressed_unit_type_image = 1,
+  heif_cmpC_compressed_unit_type_image_tile = 2,
+  heif_cmpC_compressed_unit_type_image_row = 3,
+  heif_cmpC_compressed_unit_type_image_pixel = 4
+};
+
+/**
+ * Generic compression configuration box (cmpC).
+ *
+ * This is from ISO/IEC 23001-17 Amd 2.
+ */
+class Box_cmpC : public FullBox
+{
+public:
+  Box_cmpC()
+  {
+    set_short_type(fourcc("cmpC"));
+  }
+
+  std::string dump(Indent&) const override;
+
+  uint32_t get_compression_type() const { return m_compression_type; }
+
+  heif_cmpC_compressed_unit_type get_compressed_unit_type() const { return m_compressed_unit_type; }
+
+  void set_compression_type(uint32_t type) { m_compression_type = type; }
+
+  void set_compressed_unit_type(heif_cmpC_compressed_unit_type type) { m_compressed_unit_type = type; }
+
+  Error write(StreamWriter& writer) const override;
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits* limits) override;
+
+  uint32_t m_compression_type = 0;
+  heif_cmpC_compressed_unit_type m_compressed_unit_type = heif_cmpC_compressed_unit_type_full_item;
+};
+
+/**
+ * Generically compressed units item info (icef).
+ *
+ * This describes the units of compressed data for an item.
+ *
+ * The box is from ISO/IEC 23001-17 Amd 2.
+ */
+class Box_icef : public FullBox
+{
+public:
+  Box_icef()
+  {
+    set_short_type(fourcc("icef"));
+  }
+
+  struct CompressedUnitInfo
+  {
+    uint64_t unit_offset = 0;
+    uint64_t unit_size = 0;
+  };
+
+  const std::vector<CompressedUnitInfo>& get_units() const { return m_unit_infos; }
+
+  void add_component(const CompressedUnitInfo& unit_info)
+  {
+    m_unit_infos.push_back(unit_info);
+  }
+
+  void set_component(uint32_t tile_idx, const CompressedUnitInfo& unit_info)
+  {
+    if (tile_idx >= m_unit_infos.size()) {
+      m_unit_infos.resize(tile_idx+1);
+    }
+
+    m_unit_infos[tile_idx] = unit_info;
+  }
+
+  std::string dump(Indent&) const override;
+
+  Error write(StreamWriter& writer) const override;
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits* limits) override;
+
+  std::vector<CompressedUnitInfo> m_unit_infos;
+
+private:
+  const uint8_t get_required_offset_code(uint64_t offset) const;
+  const uint8_t get_required_size_code(uint64_t size) const;
+};
+
+
+/**
+ * Component pattern definition box (cpat).
+ *
+ * The component pattern is used when representing filter array
+ * data, such as Bayer. It defines the filter mask in the raw
+ * data.
+ *
+ * This is from ISO/IEC 23001-17 Section 6.1.3.
+ */
+class Box_cpat : public FullBox
+{
+public:
+  Box_cpat()
+  {
+    set_short_type(fourcc("cpat"));
+  }
+
+  uint16_t get_pattern_width() const { return m_pattern.pattern_width; }
+
+  uint16_t get_pattern_height() const { return m_pattern.pattern_height; }
+
+  const BayerPattern& get_pattern() const { return m_pattern; }
+
+  void set_pattern(const BayerPattern& pattern) { m_pattern = pattern; }
+
+  std::string dump(Indent&) const override;
+
+  Error write(StreamWriter& writer) const override;
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits* limits) override;
+
+  BayerPattern m_pattern;
+};
+
+
+/**
+ * Polarization pattern definition box (splz).
+ *
+ * Describes the polarization filter array pattern on an image sensor.
+ * Multiple splz boxes can exist (one per set of components with
+ * different polarization filters).
+ *
+ * This is from ISO/IEC 23001-17 Section 6.1.5.
+ */
+class Box_splz : public FullBox
+{
+public:
+  Box_splz() { set_short_type(fourcc("splz")); }
+
+  const PolarizationPattern& get_pattern() const { return m_pattern; }
+
+  void set_pattern(const PolarizationPattern& pattern) { m_pattern = pattern; }
+
+  std::string dump(Indent&) const override;
+
+  Error write(StreamWriter& writer) const override;
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits* limits) override;
+
+  PolarizationPattern m_pattern;
+};
+
+
+/**
+ * Sensor bad pixels map box (sbpm).
+ *
+ * Identifies bad pixels on a sensor for which at least one component
+ * value is corrupted. Supports bad rows, bad columns, and individual
+ * bad pixel coordinates.
+ *
+ * This is from ISO/IEC 23001-17 Section 6.1.7.
+ */
+class Box_sbpm : public FullBox
+{
+public:
+  Box_sbpm() { set_short_type(fourcc("sbpm")); }
+
+  const SensorBadPixelsMap& get_bad_pixels_map() const { return m_map; }
+  void set_bad_pixels_map(const SensorBadPixelsMap& map) { m_map = map; }
+
+  std::string dump(Indent&) const override;
+  Error write(StreamWriter& writer) const override;
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits* limits) override;
+
+  SensorBadPixelsMap m_map;
+};
+
+
+/**
+ * Sensor non-uniformity correction box (snuc).
+ *
+ * Provides per-pixel gain and offset tables for sensor non-uniformity
+ * correction. The correction equation is: y = nuc_gain * x + nuc_offset.
+ *
+ * This is from ISO/IEC 23001-17 Section 6.1.6.
+ */
+class Box_snuc : public FullBox
+{
+public:
+  Box_snuc() { set_short_type(fourcc("snuc")); }
+
+  const SensorNonUniformityCorrection& get_nuc() const { return m_nuc; }
+  void set_nuc(const SensorNonUniformityCorrection& nuc) { m_nuc = nuc; }
+
+  std::string dump(Indent&) const override;
+  Error write(StreamWriter& writer) const override;
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits* limits) override;
+
+  MemoryHandle m_memory_handle;
+  SensorNonUniformityCorrection m_nuc;
+};
+
+
+/**
+ * Chroma location box (cloc).
+ *
+ * Signals the chroma sample position for subsampled images.
+ *
+ * This is from ISO/IEC 23001-17 Section 6.1.4.
+ */
+class Box_cloc : public FullBox
+{
+public:
+  Box_cloc() { set_short_type(fourcc("cloc")); }
+
+  uint8_t get_chroma_location() const { return m_chroma_location; }
+  void set_chroma_location(uint8_t loc) { m_chroma_location = loc; }
+
+  std::string dump(Indent&) const override;
+  Error write(StreamWriter& writer) const override;
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits* limits) override;
+
+  uint8_t m_chroma_location = 0;
+};
+
+
+void fill_uncC_and_cmpd_from_profile(const std::shared_ptr<Box_uncC>& uncC,
+                                     std::shared_ptr<Box_cmpd>& cmpd);
+
+
+class Box_uncv : public Box_VisualSampleEntry
+{
+public:
+  Box_uncv()
+  {
+    set_short_type(fourcc("uncv"));
+  }
+};
+
+
+/**
+ * GIMI ItemComponentContentIDProperty.
+ *
+ * A UUID-type item property that assigns a unique Content ID string
+ * to each cmpd component of an image item.
+ *
+ * UUID: 9db9dd6e-373c-5a4e-8110-21fc83a911fd
+ */
+class Box_gimi_component_content_ids : public Box
+{
+public:
+  Box_gimi_component_content_ids()
+  {
+    set_uuid_type(std::vector<uint8_t>{0x9d, 0xb9, 0xdd, 0x6e, 0x37, 0x3c, 0x5a, 0x4e,
+                                       0x81, 0x10, 0x21, 0xfc, 0x83, 0xa9, 0x11, 0xfd});
+  }
+
+  bool is_essential() const override { return false; }
+
+  bool is_transformative_property() const override { return false; }
+
+  std::string dump(Indent&) const override;
+
+  const char* debug_box_name() const override { return "GIMI Component Content IDs"; }
+
+  const std::vector<std::string>& get_content_ids() const { return m_content_ids; }
+
+  void set_content_ids(const std::vector<std::string>& ids) { m_content_ids = ids; }
+
+  [[nodiscard]] parse_error_fatality get_parse_error_fatality() const override { return parse_error_fatality::ignorable; }
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+
+  Error write(StreamWriter& writer) const override;
+
+private:
+  std::vector<std::string> m_content_ids;
+};
+
+
+#endif //LIBHEIF_UNC_BOXES_H
diff --git a/libheif/codecs/uncompressed/unc_codec.cc b/libheif/codecs/uncompressed/unc_codec.cc
new file mode 100644
index 0000000000..741d78ad01
--- /dev/null
+++ b/libheif/codecs/uncompressed/unc_codec.cc
@@ -0,0 +1,501 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "unc_codec.h"
+
+#include "common_utils.h"
+#include "context.h"
+#include "error.h"
+#include "libheif/heif.h"
+#include "unc_types.h"
+#include "unc_boxes.h"
+
+#include "unc_decoder.h"
+#include "codecs/decoder.h"
+
+#include <algorithm>
+#include <cassert>
+#include <iostream>
+#include <map>
+#include <sstream>
+#include "security_limits.h"
+#include <utility>
+
+
+Error UncompressedImageCodec::get_heif_chroma_uncompressed(const std::shared_ptr<const Box_uncC>& uncC,
+                                                           const std::shared_ptr<const Box_cmpd>& cmpd,
+                                                           heif_chroma* out_chroma, heif_colorspace* out_colourspace,
+                                                           bool* out_has_alpha)
+{
+  bool dummy_has_alpha;
+  if (out_has_alpha == nullptr) {
+    out_has_alpha = &dummy_has_alpha;
+  }
+
+  *out_chroma = heif_chroma_undefined;
+  *out_colourspace = heif_colorspace_undefined;
+  *out_has_alpha = false;
+
+  Error error = check_header_validity(std::nullopt, cmpd, uncC);
+  if (error) {
+    return error;
+  }
+
+
+  if (uncC != nullptr && uncC->get_version() == 1) {
+    switch (uncC->get_profile()) {
+      case fourcc("rgb3"):
+        *out_chroma = heif_chroma_444;
+        *out_colourspace = heif_colorspace_RGB;
+        *out_has_alpha = false;
+        return Error::Ok;
+
+      case fourcc("abgr"):
+      case fourcc("rgba"):
+        *out_chroma = heif_chroma_444;
+        *out_colourspace = heif_colorspace_RGB;
+        *out_has_alpha = true;
+        return Error::Ok;
+
+      default:
+        return Error(heif_error_Unsupported_feature, heif_suberror_Unsupported_image_type,
+                     "unci image has unsupported profile");
+    }
+  }
+
+
+  // each 1-bit represents an existing component in the image
+  uint16_t componentSet = 0;
+
+  for (Box_uncC::Component component : uncC->get_components()) {
+    uint32_t component_index = component.component_index;
+    uint16_t component_type = cmpd->get_components()[component_index].component_type;
+
+    if (component_type > heif_uncompressed_component_type_max_valid) {
+      std::stringstream sstr;
+      sstr << "a component_type > " << heif_uncompressed_component_type_max_valid << " is not supported";
+      return {heif_error_Unsupported_feature, heif_suberror_Invalid_parameter_value, sstr.str()};
+    }
+    if (component_type == heif_uncompressed_component_type_padded) {
+      // not relevant for determining chroma
+      continue;
+    }
+    componentSet |= (1 << component_type);
+  }
+
+  *out_has_alpha = (componentSet & (1 << heif_uncompressed_component_type_alpha)) != 0;
+
+  if (componentSet == ((1 << heif_uncompressed_component_type_red) | (1 << heif_uncompressed_component_type_green) | (1 << heif_uncompressed_component_type_blue)) ||
+      componentSet == ((1 << heif_uncompressed_component_type_red) | (1 << heif_uncompressed_component_type_green) | (1 << heif_uncompressed_component_type_blue) | (1 << heif_uncompressed_component_type_alpha))) {
+    *out_chroma = heif_chroma_444;
+    *out_colourspace = heif_colorspace_RGB;
+  }
+
+  if (componentSet == ((1 << heif_uncompressed_component_type_Y) | (1 << heif_uncompressed_component_type_Cb) | (1 << heif_uncompressed_component_type_Cr))) {
+    switch (uncC->get_sampling_type()) {
+      case sampling_mode_no_subsampling:
+        *out_chroma = heif_chroma_444;
+        break;
+      case sampling_mode_422:
+        *out_chroma = heif_chroma_422;
+        break;
+      case sampling_mode_420:
+        *out_chroma = heif_chroma_420;
+        break;
+    }
+    *out_colourspace = heif_colorspace_YCbCr;
+  }
+
+  if (componentSet == (1 << heif_uncompressed_component_type_monochrome) || componentSet == ((1 << heif_uncompressed_component_type_monochrome) | (1 << heif_uncompressed_component_type_alpha)) ||
+      componentSet == (1 << heif_uncompressed_component_type_Y) || componentSet == ((1 << heif_uncompressed_component_type_Y) | (1 << heif_uncompressed_component_type_alpha))) {
+    // mono or mono + alpha input, mono output.
+    *out_chroma = heif_chroma_monochrome;
+    *out_colourspace = heif_colorspace_monochrome;
+  }
+
+  if (componentSet == (1 << heif_uncompressed_component_type_filter_array)) {
+    // TODO - we should look up the components
+    *out_chroma = heif_chroma_monochrome;
+    *out_colourspace = heif_colorspace_filter_array;
+  }
+
+  // TODO: more combinations
+
+  if (*out_chroma == heif_chroma_undefined) {
+    return Error(heif_error_Unsupported_feature,
+                 heif_suberror_Unsupported_data_version,
+                 "Could not determine chroma");
+  }
+  else if (*out_colourspace == heif_colorspace_undefined) {
+    return Error(heif_error_Unsupported_feature,
+                 heif_suberror_Unsupported_data_version,
+                 "Could not determine colourspace");
+  }
+  else {
+    return Error::Ok;
+  }
+}
+
+bool map_uncompressed_component_to_channel(const std::shared_ptr<const Box_cmpd>& cmpd,
+                                           Box_uncC::Component component,
+                                           heif_channel* channel)
+{
+  uint32_t component_index = component.component_index;
+  uint16_t component_type = cmpd->get_components()[component_index].component_type;
+
+  *channel = map_uncompressed_component_to_channel(component_type);
+  return true;
+}
+
+
+heif_channel_datatype unc_component_format_to_datatype(uint8_t format)
+{
+  switch (format) {
+    case component_format_unsigned:
+      return heif_channel_datatype_unsigned_integer;
+
+    case component_format_signed:
+      return heif_channel_datatype_signed_integer;
+
+    case component_format_float:
+      return heif_channel_datatype_floating_point;
+
+    case component_format_complex:
+      return heif_channel_datatype_complex_number;
+
+    default:
+      return heif_channel_datatype_undefined;
+  }
+}
+
+
+Result<std::shared_ptr<HeifPixelImage>> UncompressedImageCodec::create_image(const std::shared_ptr<const Box_cmpd> cmpd,
+                                                                             const std::shared_ptr<const Box_uncC> uncC,
+                                                                             uint32_t width,
+                                                                             uint32_t height,
+                                                                             const heif_security_limits* limits)
+{
+  const auto& components = cmpd->get_components();
+
+  auto img = std::make_shared<HeifPixelImage>();
+  heif_chroma chroma = heif_chroma_undefined;
+  heif_colorspace colourspace = heif_colorspace_undefined;
+
+  Error error = get_heif_chroma_uncompressed(uncC, cmpd, &chroma, &colourspace, nullptr);
+  if (error) {
+    return error;
+  }
+  img->create(width, height,
+              colourspace,
+              chroma);
+
+  // Populate the cmpd table on the image so add_component_for_index() can look up types.
+  {
+    std::vector<uint16_t> cmpd_types;
+    cmpd_types.reserve(components.size());
+    for (const auto& c : components) {
+      cmpd_types.push_back(c.component_type);
+    }
+    img->set_cmpd_component_types(std::move(cmpd_types));
+  }
+
+  for (Box_uncC::Component component : uncC->get_components()) {
+    if (component.component_index >= components.size()) {
+      return Error{
+        heif_error_Invalid_input,
+        heif_suberror_Unspecified,
+        "Component index out of range."
+      };
+    }
+
+    auto component_type = components[component.component_index].component_type;
+
+    if ((component_type == heif_uncompressed_component_type_Cb) ||
+        (component_type == heif_uncompressed_component_type_Cr)) {
+      Result<uint32_t> result = img->add_component_for_index(component.component_index,
+                                                              (width / chroma_h_subsampling(chroma)),
+                                                              (height / chroma_v_subsampling(chroma)),
+                                                              unc_component_format_to_datatype(component.component_format),
+                                                              component.component_bit_depth,
+                                                              limits);
+      if (result.is_error()) {
+        return result.error();
+      }
+    }
+    else {
+      Result<uint32_t> result = img->add_component_for_index(component.component_index,
+                                                              width,
+                                                              height,
+                                                              unc_component_format_to_datatype(component.component_format),
+                                                              component.component_bit_depth,
+                                                              limits);
+      if (result.is_error()) {
+        return result.error();
+      }
+    }
+  }
+
+  return img;
+}
+
+
+Error UncompressedImageCodec::decode_uncompressed_image_tile(const HeifContext* context,
+                                                             heif_item_id ID,
+                                                             std::shared_ptr<HeifPixelImage>& img,
+                                                             uint32_t tile_x0, uint32_t tile_y0)
+{
+  auto file = context->get_heif_file();
+  auto image = context->get_image(ID, false);
+  if (!image) {
+    return {heif_error_Invalid_input,
+            heif_suberror_Nonexisting_item_referenced};
+  }
+
+  UncompressedImageCodec::unci_properties properties;
+  properties.fill_from_image_item(image);
+
+  auto ispe = properties.ispe;
+  auto uncC = properties.uncC;
+  auto cmpd = properties.cmpd;
+
+  Error error = check_header_validity(ispe, cmpd, uncC);
+  if (error) {
+    return error;
+  }
+
+  uint32_t tile_width = ispe->get_width() / uncC->get_number_of_tile_columns();
+  uint32_t tile_height = ispe->get_height() / uncC->get_number_of_tile_rows();
+
+  Result<std::shared_ptr<HeifPixelImage>> createImgResult = create_image(cmpd, uncC, tile_width, tile_height, context->get_security_limits());
+  if (!createImgResult) {
+    return createImgResult.error();
+  }
+
+  img = *createImgResult;
+
+  auto decoderResult = unc_decoder_factory::get_unc_decoder(ispe->get_width(), ispe->get_height(), cmpd, uncC);
+  if (!decoderResult) {
+    return decoderResult.error();
+  }
+
+  auto& decoder = *decoderResult;
+
+  DataExtent dataExtent;
+  dataExtent.set_from_image_item(file, ID);
+
+  decoder->ensure_channel_list(img);
+
+  std::vector<uint8_t> tile_data;
+  Error err = decoder->fetch_tile_data(dataExtent, properties, tile_x0, tile_y0, tile_data);
+  if (err) {
+    return err;
+  }
+
+  return decoder->decode_tile(tile_data, img, 0, 0);
+}
+
+
+Error UncompressedImageCodec::check_header_validity(std::optional<const std::shared_ptr<const Box_ispe>> ispe,
+                                                    const std::shared_ptr<const Box_cmpd>& cmpd,
+                                                    const std::shared_ptr<const Box_uncC>& uncC)
+{
+  // if we miss a required box, show error
+
+  if (!uncC) {
+    return {heif_error_Unsupported_feature,
+            heif_suberror_Unsupported_data_version,
+            "Missing required uncC box for uncompressed codec"};
+  }
+
+  if (!cmpd && (uncC->get_version() != 1)) {
+    return {heif_error_Unsupported_feature,
+            heif_suberror_Unsupported_data_version,
+            "Missing required cmpd or uncC version 1 box for uncompressed codec"};
+  }
+
+  if (cmpd) {
+    for (const auto& comp : uncC->get_components()) {
+      if (comp.component_index >= cmpd->get_components().size()) {
+        return {heif_error_Invalid_input,
+                heif_suberror_Unspecified,
+                "Invalid component index in uncC box"};
+      }
+
+      uint16_t component_type = cmpd->get_components()[comp.component_index].component_type;
+      if (component_type > 7 && component_type != heif_uncompressed_component_type_padded && component_type != heif_uncompressed_component_type_filter_array) {
+        std::stringstream sstr;
+        sstr << "Uncompressed image with component_type " << ((int) component_type) << " is not implemented yet";
+        return {heif_error_Unsupported_feature,
+                heif_suberror_Unsupported_data_version,
+                sstr.str()};
+      }
+    }
+  }
+
+
+  if (ispe) {
+    if (!*ispe) {
+      return {heif_error_Unsupported_feature,
+              heif_suberror_Unsupported_data_version,
+              "Missing required ispe box for uncompressed codec"};
+    }
+
+    if (uncC->get_number_of_tile_rows() > (*ispe)->get_height() ||
+        uncC->get_number_of_tile_columns() > (*ispe)->get_width()) {
+      return {heif_error_Invalid_input,
+              heif_suberror_Unspecified,
+              "More tiles than pixels in uncC box"};
+    }
+
+    if ((*ispe)->get_height() % uncC->get_number_of_tile_rows() != 0 ||
+        (*ispe)->get_width() % uncC->get_number_of_tile_columns() != 0) {
+      return {heif_error_Invalid_input,
+              heif_suberror_Unspecified,
+              "Invalid tile size (image size not a multiple of the tile size)"};
+    }
+  }
+
+  return Error::Ok;
+}
+
+
+// TODO: this should be deprecated and replaced with the function taking unci_properties/DataExtent
+Error UncompressedImageCodec::decode_uncompressed_image(const HeifContext* context,
+                                                        heif_item_id ID,
+                                                        std::shared_ptr<HeifPixelImage>& img)
+{
+  // Get the properties for this item
+  // We need: ispe, cmpd, uncC
+  std::vector<std::shared_ptr<Box>> item_properties;
+  Error error = context->get_heif_file()->get_properties(ID, item_properties);
+  if (error) {
+    return error;
+  }
+
+  auto image = context->get_image(ID, false);
+  if (!image) {
+    return {heif_error_Invalid_input,
+            heif_suberror_Nonexisting_item_referenced};
+  }
+
+  UncompressedImageCodec::unci_properties properties;
+  properties.fill_from_image_item(image);
+
+  auto ispe = properties.ispe;
+  auto uncC = properties.uncC;
+  auto cmpd = properties.cmpd;
+
+  error = check_header_validity(ispe, cmpd, uncC);
+  if (error) {
+    return error;
+  }
+
+  assert(ispe);
+  uint32_t width = ispe->get_width();
+  uint32_t height = ispe->get_height();
+  error = check_for_valid_image_size(context->get_security_limits(), width, height);
+  if (error) {
+    return error;
+  }
+
+  if (uncC->get_pixel_size() > 0 &&
+      UINT32_MAX / uncC->get_pixel_size() / width < height) {
+    return {
+      heif_error_Invalid_input,
+      heif_suberror_Unspecified,
+      "Aligned total image size exceeds maximum integer range"
+    };
+  }
+
+  if (uncC->get_row_align_size() > 0 &&
+      UINT32_MAX / uncC->get_row_align_size() < 8) {
+    return {
+      heif_error_Invalid_input,
+      heif_suberror_Unspecified,
+      "Aligned row size larger than supported maximum"
+    };
+  }
+
+  DataExtent dataExtent;
+  dataExtent.set_from_image_item(context->get_heif_file(), ID);
+
+  auto result = unc_decoder::decode_full_image(properties, dataExtent, context->get_security_limits());
+  if (!result) {
+    return result.error();
+  }
+
+  img = *result;
+  return Error::Ok;
+}
+
+
+void UncompressedImageCodec::unci_properties::fill_from_image_item(const std::shared_ptr<const ImageItem>& image)
+{
+  ispe = image->get_property<Box_ispe>();
+  auto cmpd_mut = image->get_property<Box_cmpd>();
+  auto uncC_mut = image->get_property<Box_uncC>();
+  if (uncC_mut) {
+    fill_uncC_and_cmpd_from_profile(uncC_mut, cmpd_mut);
+  }
+  cmpd = cmpd_mut;
+  uncC = uncC_mut;
+  cmpC = image->get_property<Box_cmpC>();
+  icef = image->get_property<Box_icef>();
+  cpat = image->get_property<Box_cpat>();
+  splz = image->get_all_properties<Box_splz>();
+  sbpm = image->get_all_properties<Box_sbpm>();
+  snuc = image->get_all_properties<Box_snuc>();
+  cloc = image->get_property<Box_cloc>();
+}
+
+
+Result<std::shared_ptr<HeifPixelImage>>
+UncompressedImageCodec::decode_uncompressed_image(const UncompressedImageCodec::unci_properties& properties,
+                                                  const DataExtent& extent,
+                                                  const heif_security_limits* securityLimits)
+{
+  const std::shared_ptr<const Box_ispe>& ispe = properties.ispe;
+  const std::shared_ptr<const Box_cmpd>& cmpd = properties.cmpd;
+  const std::shared_ptr<const Box_uncC>& uncC = properties.uncC;
+
+  Error error = check_header_validity(ispe, cmpd, uncC);
+  if (error) {
+    return error;
+  }
+
+  assert(ispe);
+  uint32_t width = ispe->get_width();
+  uint32_t height = ispe->get_height();
+  error = check_for_valid_image_size(securityLimits, width, height);
+  if (error) {
+    return error;
+  }
+
+  if (uncC->get_pixel_size() > 0 &&
+      UINT32_MAX / uncC->get_pixel_size() / width < height) {
+    return Error{
+      heif_error_Invalid_input,
+      heif_suberror_Unspecified,
+      "Aligned total image size exceeds maximum integer range"
+    };
+  }
+
+  return unc_decoder::decode_full_image(properties, extent, securityLimits);
+}
diff --git a/libheif/codecs/uncompressed/unc_codec.h b/libheif/codecs/uncompressed/unc_codec.h
new file mode 100644
index 0000000000..eb08061ad8
--- /dev/null
+++ b/libheif/codecs/uncompressed/unc_codec.h
@@ -0,0 +1,97 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef LIBHEIF_UNC_CODEC_H
+#define LIBHEIF_UNC_CODEC_H
+
+#include "pixelimage.h"
+#include "file.h"
+#include "context.h"
+#include "libheif/heif_uncompressed.h"
+
+#if WITH_UNCOMPRESSED_CODEC
+#include "unc_boxes.h"
+#endif
+
+#include <cstdint>
+#include <string>
+#include <vector>
+#include <memory>
+#include <optional>
+
+class HeifContext;
+
+
+bool map_uncompressed_component_to_channel(const std::shared_ptr<const Box_cmpd> &cmpd,
+                                           Box_uncC::Component component,
+                                           heif_channel *channel);
+
+
+class UncompressedImageCodec
+{
+public:
+  static Error decode_uncompressed_image(const HeifContext* context,
+                                         heif_item_id ID,
+                                         std::shared_ptr<HeifPixelImage>& img);
+
+  static Error decode_uncompressed_image_tile(const HeifContext* context,
+                                              heif_item_id ID,
+                                              std::shared_ptr<HeifPixelImage>& img,
+                                              uint32_t tile_x0, uint32_t tile_y0);
+
+  struct unci_properties {
+    std::shared_ptr<const Box_ispe> ispe;
+    std::shared_ptr<const Box_cmpd> cmpd;
+    std::shared_ptr<const Box_uncC> uncC;
+    std::shared_ptr<const Box_cmpC> cmpC;
+    std::shared_ptr<const Box_icef> icef;
+    std::shared_ptr<const Box_cpat> cpat;
+    std::vector<std::shared_ptr<const Box_splz>> splz;
+    std::vector<std::shared_ptr<const Box_sbpm>> sbpm;
+    std::vector<std::shared_ptr<const Box_snuc>> snuc;
+    std::shared_ptr<const Box_cloc> cloc;
+
+    void fill_from_image_item(const std::shared_ptr<const ImageItem>&);
+  };
+
+  static Result<std::shared_ptr<HeifPixelImage>> decode_uncompressed_image(const unci_properties& properties,
+                                                                           const struct DataExtent& extent,
+                                                                           const heif_security_limits*);
+
+
+  static Error get_heif_chroma_uncompressed(const std::shared_ptr<const Box_uncC>& uncC,
+                                            const std::shared_ptr<const Box_cmpd>& cmpd,
+                                            heif_chroma* out_chroma,
+                                            heif_colorspace* out_colourspace,
+                                            bool* out_has_alpha);
+
+  static Result<std::shared_ptr<HeifPixelImage>> create_image(std::shared_ptr<const Box_cmpd>,
+                                                              std::shared_ptr<const Box_uncC>,
+                                                              uint32_t width,
+                                                              uint32_t height,
+                                                              const heif_security_limits* limits);
+
+  static Error check_header_validity(std::optional<const std::shared_ptr<const Box_ispe>>,
+                                     const std::shared_ptr<const Box_cmpd>&,
+                                     const std::shared_ptr<const Box_uncC>&);
+};
+
+#endif //LIBHEIF_UNC_CODEC_H
diff --git a/libheif/codecs/uncompressed/unc_dec.cc b/libheif/codecs/uncompressed/unc_dec.cc
new file mode 100644
index 0000000000..c831d0e3e7
--- /dev/null
+++ b/libheif/codecs/uncompressed/unc_dec.cc
@@ -0,0 +1,228 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "codecs/uncompressed/unc_dec.h"
+#include "codecs/uncompressed/unc_boxes.h"
+#include "codecs/uncompressed/unc_codec.h"
+#include "error.h"
+#include "context.h"
+
+#include <string>
+#include <algorithm>
+#include <utility>
+
+
+Decoder_uncompressed::Decoder_uncompressed(std::shared_ptr<Box_uncC> uncC,
+                                           std::shared_ptr<Box_cmpd> cmpd,
+                                           std::shared_ptr<const Box_ispe> ispe)
+    : m_ispe(std::move(ispe))
+{
+  if (uncC) {
+    fill_uncC_and_cmpd_from_profile(uncC, cmpd);
+  }
+  m_uncC = std::move(uncC);
+  m_cmpd = std::move(cmpd);
+}
+
+
+Result<std::vector<uint8_t>> Decoder_uncompressed::read_bitstream_configuration_data() const
+{
+  return std::vector<uint8_t>{};
+}
+
+
+int Decoder_uncompressed::get_luma_bits_per_pixel() const
+{
+  assert(m_uncC);
+
+  if (!m_cmpd) {
+    return -1;
+  }
+
+  int luma_bits = 0;
+  int alternate_channel_bits = 0;
+  for (Box_uncC::Component component : m_uncC->get_components()) {
+    uint32_t component_index = component.component_index;
+    if (component_index >= m_cmpd->get_components().size()) {
+      return -1;
+    }
+    auto component_type = m_cmpd->get_components()[component_index].component_type;
+    switch (component_type) {
+      case heif_uncompressed_component_type_monochrome:
+      case heif_uncompressed_component_type_red:
+      case heif_uncompressed_component_type_green:
+      case heif_uncompressed_component_type_blue:
+      case heif_uncompressed_component_type_filter_array:
+        alternate_channel_bits = std::max(alternate_channel_bits, (int) component.component_bit_depth);
+        break;
+      case heif_uncompressed_component_type_Y:
+        luma_bits = std::max(luma_bits, (int) component.component_bit_depth);
+        break;
+        // TODO: there are other things we'll need to handle eventually, like palette.
+    }
+  }
+  if (luma_bits > 0) {
+    return luma_bits;
+  }
+  else if (alternate_channel_bits > 0) {
+    return alternate_channel_bits;
+  }
+  else {
+    return 8;
+  }
+}
+
+int Decoder_uncompressed::get_chroma_bits_per_pixel() const
+{
+  if (m_uncC && m_uncC->get_version() == 1) {
+    // All of the version 1 cases are 8 bit
+    return 8;
+  }
+
+  if (!m_uncC || !m_cmpd) {
+    return -1;
+  }
+
+  int chroma_bits = 0;
+  int alternate_channel_bits = 0;
+  for (Box_uncC::Component component : m_uncC->get_components()) {
+    uint32_t component_index = component.component_index;
+    if (component_index >= m_cmpd->get_components().size()) {
+      return -1;
+    }
+    auto component_type = m_cmpd->get_components()[component_index].component_type;
+    switch (component_type) {
+      case heif_uncompressed_component_type_monochrome:
+      case heif_uncompressed_component_type_red:
+      case heif_uncompressed_component_type_green:
+      case heif_uncompressed_component_type_blue:
+      case heif_uncompressed_component_type_filter_array:
+        alternate_channel_bits = std::max(alternate_channel_bits, (int) component.component_bit_depth);
+        break;
+      case heif_uncompressed_component_type_Cb:
+      case heif_uncompressed_component_type_Cr:
+        chroma_bits = std::max(chroma_bits, (int) component.component_bit_depth);
+        break;
+        // TODO: there are other things we'll need to handle eventually, like palette.
+    }
+  }
+  if (chroma_bits > 0) {
+    return chroma_bits;
+  }
+  else if (alternate_channel_bits > 0) {
+    return alternate_channel_bits;
+  }
+  else {
+    return 8;
+  }
+}
+
+
+Error Decoder_uncompressed::get_coded_image_colorspace(heif_colorspace* out_colorspace, heif_chroma* out_chroma) const
+{
+  if (m_uncC->get_version() == 1) {
+    // This is the shortform case, no cmpd box, and always some kind of RGB
+    *out_colorspace = heif_colorspace_RGB;
+    if (m_uncC->get_profile() == fourcc("rgb3")) {
+      *out_chroma = heif_chroma_interleaved_RGB;
+    }
+    else if ((m_uncC->get_profile() == fourcc("rgba")) || (m_uncC->get_profile() == fourcc("abgr"))) {
+      *out_chroma = heif_chroma_interleaved_RGBA;
+    }
+
+    return Error::Ok;
+  }
+  else if (m_cmpd) {
+    UncompressedImageCodec::get_heif_chroma_uncompressed(m_uncC, m_cmpd, out_chroma, out_colorspace, nullptr);
+    return Error::Ok;
+  }
+  else {
+    return {heif_error_Invalid_input,
+            heif_suberror_Unspecified,
+            "Missing 'cmpd' box."};
+  }
+}
+
+
+bool Decoder_uncompressed::has_alpha_component() const
+{
+  heif_colorspace dummy_colorspace;
+  heif_chroma dummy_chroma;
+  bool has_alpha;
+
+  UncompressedImageCodec::get_heif_chroma_uncompressed(m_uncC, m_cmpd, &dummy_chroma, &dummy_colorspace, &has_alpha);
+
+  return has_alpha;
+}
+
+
+Result<std::shared_ptr<HeifPixelImage>>
+Decoder_uncompressed::decode_single_frame_from_compressed_data(const struct heif_decoding_options& options,
+                                                               const struct heif_security_limits* limits)
+{
+  UncompressedImageCodec::unci_properties properties;
+  properties.uncC = m_uncC;
+  properties.cmpd = m_cmpd;
+  properties.ispe = m_ispe;
+  properties.cpat = m_cpat;
+  properties.cmpC = m_cmpC;
+  properties.icef = m_icef;
+  properties.splz = m_splz;
+  properties.sbpm = m_sbpm;
+  properties.snuc = m_snuc;
+  properties.cloc = m_cloc;
+
+  auto decodeResult = UncompressedImageCodec::decode_uncompressed_image(properties,
+                                                          get_data_extent(),
+                                                          limits);
+  return decodeResult;
+}
+
+
+Error
+Decoder_uncompressed::decode_sequence_frame_from_compressed_data(bool upload_configuration_NALs,
+                                                                 const heif_decoding_options& options,
+                                                                 uintptr_t user_data,
+                                                                 const heif_security_limits* limits)
+{
+  auto decodingResult = decode_single_frame_from_compressed_data(options, limits);
+  if (decodingResult.error()) {
+    return decodingResult.error();
+  }
+
+  m_decoded_image = *decodingResult;
+  m_decoded_image_user_data = user_data;
+
+  return {};
+}
+
+Result<std::shared_ptr<HeifPixelImage> > Decoder_uncompressed::get_decoded_frame(const heif_decoding_options& options,
+                                                                                 uintptr_t* out_user_data,
+                                                                                 const heif_security_limits* limits)
+{
+  auto img = std::move(m_decoded_image);
+  m_decoded_image.reset();
+
+  if (out_user_data) {
+    *out_user_data = m_decoded_image_user_data;
+  }
+
+  return img;
+}
diff --git a/libheif/codecs/uncompressed/unc_dec.h b/libheif/codecs/uncompressed/unc_dec.h
new file mode 100644
index 0000000000..c1d22d56cf
--- /dev/null
+++ b/libheif/codecs/uncompressed/unc_dec.h
@@ -0,0 +1,112 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef HEIF_UNC_DEC_H
+#define HEIF_UNC_DEC_H
+
+#include "libheif/heif.h"
+#include "box.h"
+#include "error.h"
+
+#include <memory>
+#include <vector>
+#include "codecs/decoder.h"
+#include <utility>
+
+class Box_uncC;
+class Box_cmpd;
+class Box_cpat;
+class Box_cmpC;
+class Box_icef;
+class Box_splz;
+class Box_sbpm;
+class Box_snuc;
+class Box_cloc;
+
+
+class Decoder_uncompressed : public Decoder
+{
+public:
+  explicit Decoder_uncompressed(std::shared_ptr<Box_uncC> uncC,
+                                std::shared_ptr<Box_cmpd> cmpd,
+                                std::shared_ptr<const Box_ispe> ispe);
+
+  void set_cpat(std::shared_ptr<const Box_cpat> cpat) { m_cpat = std::move(cpat); }
+  void set_cmpC(std::shared_ptr<const Box_cmpC> cmpC) { m_cmpC = std::move(cmpC); }
+  void set_icef(std::shared_ptr<const Box_icef> icef) { m_icef = std::move(icef); }
+  void set_cloc(std::shared_ptr<const Box_cloc> cloc) { m_cloc = std::move(cloc); }
+  void set_splz(std::vector<std::shared_ptr<const Box_splz>> splz) { m_splz = std::move(splz); }
+  void set_sbpm(std::vector<std::shared_ptr<const Box_sbpm>> sbpm) { m_sbpm = std::move(sbpm); }
+  void set_snuc(std::vector<std::shared_ptr<const Box_snuc>> snuc) { m_snuc = std::move(snuc); }
+
+  // Overloads accepting non-const shared_ptrs (from get_child_boxes)
+  void set_splz(std::vector<std::shared_ptr<Box_splz>> splz) { m_splz.assign(splz.begin(), splz.end()); }
+  void set_sbpm(std::vector<std::shared_ptr<Box_sbpm>> sbpm) { m_sbpm.assign(sbpm.begin(), sbpm.end()); }
+  void set_snuc(std::vector<std::shared_ptr<Box_snuc>> snuc) { m_snuc.assign(snuc.begin(), snuc.end()); }
+
+  heif_compression_format get_compression_format() const override { return heif_compression_uncompressed; }
+
+  int get_luma_bits_per_pixel() const override;
+
+  int get_chroma_bits_per_pixel() const override;
+
+  Error get_coded_image_colorspace(heif_colorspace*, heif_chroma*) const override;
+
+  bool has_alpha_component() const;
+
+  Result<std::vector<uint8_t>> read_bitstream_configuration_data() const override;
+
+  Result<std::shared_ptr<HeifPixelImage>>
+  decode_single_frame_from_compressed_data(const struct heif_decoding_options& options,
+                                           const struct heif_security_limits* limits) override;
+
+
+  // Push data for one frame into decoder.
+  Error
+  decode_sequence_frame_from_compressed_data(bool upload_configuration_NALs,
+                                             const heif_decoding_options& options,
+                                             uintptr_t user_data,
+                                             const heif_security_limits* limits) override;
+
+  Error flush_decoder() override { return {}; }
+
+  // Get a decoded frame from the decoder.
+  // It may return NULL when there is buffering in the codec.
+  Result<std::shared_ptr<HeifPixelImage> > get_decoded_frame(const heif_decoding_options& options,
+                                                             uintptr_t* out_user_data,
+                                                             const heif_security_limits* limits) override;
+
+private:
+  std::shared_ptr<const Box_uncC> m_uncC;
+  std::shared_ptr<const Box_cmpd> m_cmpd;
+  std::shared_ptr<const Box_ispe> m_ispe;
+  std::shared_ptr<const Box_cpat> m_cpat;
+  std::shared_ptr<const Box_cmpC> m_cmpC;
+  std::shared_ptr<const Box_icef> m_icef;
+  std::vector<std::shared_ptr<const Box_splz>> m_splz;
+  std::vector<std::shared_ptr<const Box_sbpm>> m_sbpm;
+  std::vector<std::shared_ptr<const Box_snuc>> m_snuc;
+  std::shared_ptr<const Box_cloc> m_cloc;
+
+  std::shared_ptr<HeifPixelImage> m_decoded_image;
+  uintptr_t m_decoded_image_user_data;
+};
+
+#endif
diff --git a/libheif/codecs/uncompressed/unc_decoder.cc b/libheif/codecs/uncompressed/unc_decoder.cc
new file mode 100644
index 0000000000..1272e57aaf
--- /dev/null
+++ b/libheif/codecs/uncompressed/unc_decoder.cc
@@ -0,0 +1,532 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <algorithm>
+#include <cassert>
+#include <sstream>
+#include <utility>
+
+#include "unc_decoder.h"
+#include "unc_decoder_component_interleave.h"
+#include "unc_decoder_pixel_interleave.h"
+#include "unc_decoder_mixed_interleave.h"
+#include "unc_decoder_row_interleave.h"
+#include "unc_decoder_block_pixel_interleave.h"
+#include "unc_decoder_bytealign_component_interleave.h"
+#include "unc_decoder_block_component_interleave.h"
+#include "unc_codec.h"
+#include "unc_boxes.h"
+#include "compression.h"
+#include "codecs/decoder.h"
+#include "security_limits.h"
+#include <string>
+
+
+static Error validate_component_indices(const std::vector<uint32_t>& indices,
+                                        size_t cmpd_size,
+                                        const char* box_name)
+{
+  for (uint32_t idx : indices) {
+    if (idx >= cmpd_size) {
+      return {heif_error_Invalid_input,
+              heif_suberror_Invalid_parameter_value,
+              std::string(box_name) + " component index out of range of cmpd table"};
+    }
+  }
+  return Error::Ok;
+}
+
+
+// --- unc_decoder ---
+
+unc_decoder::unc_decoder(uint32_t width, uint32_t height,
+                         const std::shared_ptr<const Box_cmpd>& cmpd,
+                         const std::shared_ptr<const Box_uncC>& uncC)
+  : m_width(width),
+    m_height(height),
+    m_cmpd(cmpd),
+    m_uncC(uncC)
+{
+  m_tile_height = m_height / m_uncC->get_number_of_tile_rows();
+  m_tile_width = m_width / m_uncC->get_number_of_tile_columns();
+
+  assert(m_tile_width > 0);
+  assert(m_tile_height > 0);
+}
+
+
+Error unc_decoder::fetch_tile_data(const DataExtent& dataExtent,
+                                   const UncompressedImageCodec::unci_properties& properties,
+                                   uint32_t tile_x, uint32_t tile_y,
+                                   std::vector<uint8_t>& tile_data)
+{
+  if (m_tile_width == 0 || m_tile_height == 0) {
+    return {heif_error_Decoder_plugin_error, heif_suberror_Unspecified, "Internal error: unc_decoder tile dimensions are 0"};
+  }
+
+  auto sizes = get_tile_data_sizes();
+  uint32_t tileIdx = tile_x + tile_y * (m_width / m_tile_width);
+
+  if (sizes.size() == 1) {
+    // Single contiguous read (component, pixel, mixed, row interleave)
+    uint64_t tile_start_offset = sizes[0] * tileIdx;
+    return get_compressed_image_data_uncompressed(dataExtent, properties, &tile_data, tile_start_offset, sizes[0], tileIdx, nullptr);
+  }
+  else {
+    // Scattered per-component reads (tile_component interleave)
+    uint32_t num_tiles = (m_width / m_tile_width) * (m_height / m_tile_height);
+    uint64_t component_offset = 0;
+
+    for (uint64_t size : sizes) {
+      uint64_t tile_start = component_offset + size * tileIdx;
+
+      std::vector<uint8_t> channel_data;
+      Error err = get_compressed_image_data_uncompressed(dataExtent, properties, &channel_data, tile_start, size, tileIdx, nullptr);
+      if (err) {
+        return err;
+      }
+
+      tile_data.insert(tile_data.end(), channel_data.begin(), channel_data.end());
+      component_offset += size * num_tiles;
+    }
+  }
+
+  return Error::Ok;
+}
+
+
+const Error unc_decoder::get_compressed_image_data_uncompressed(const DataExtent& dataExtent,
+                                                                const UncompressedImageCodec::unci_properties& properties,
+                                                                std::vector<uint8_t>* data,
+                                                                uint64_t range_start_offset, uint64_t range_size,
+                                                                uint32_t tile_idx,
+                                                                const Box_iloc::Item* item) const
+{
+  // --- get codec configuration
+
+  std::shared_ptr<const Box_cmpC> cmpC_box = properties.cmpC;
+  std::shared_ptr<const Box_icef> icef_box = properties.icef;
+
+  if (!cmpC_box) {
+    // assume no generic compression
+    auto readResult = dataExtent.read_data(range_start_offset, range_size);
+    if (!readResult) {
+      return readResult.error();
+    }
+
+    data->insert(data->end(), readResult->begin(), readResult->end());
+
+    return Error::Ok;
+  }
+
+  if (icef_box && cmpC_box->get_compressed_unit_type() == heif_cmpC_compressed_unit_type_image_tile) {
+    const auto& units = icef_box->get_units();
+    if (tile_idx >= units.size()) {
+      return {
+        heif_error_Invalid_input,
+        heif_suberror_Unspecified,
+        "no icef-box entry for tile index"
+      };
+    }
+
+    const auto unit = units[tile_idx];
+
+    // get data needed for one tile
+    Result<std::vector<uint8_t> > readingResult = dataExtent.read_data(unit.unit_offset, unit.unit_size);
+    if (!readingResult) {
+      return readingResult.error();
+    }
+
+    const std::vector<uint8_t>& compressed_bytes = *readingResult;
+
+    // decompress only the unit
+    auto dataResult = do_decompress_data(cmpC_box, compressed_bytes);
+    if (!dataResult) {
+      return dataResult.error();
+    }
+
+    *data = std::move(*dataResult);
+  }
+  else if (icef_box) {
+    // get all data and decode all
+    Result<std::vector<uint8_t>*> readResult = dataExtent.read_data();
+    if (!readResult) {
+      return readResult.error();
+    }
+
+    const std::vector<uint8_t> compressed_bytes = std::move(**readResult);
+
+    for (Box_icef::CompressedUnitInfo unit_info : icef_box->get_units()) {
+      if (unit_info.unit_offset + unit_info.unit_size > compressed_bytes.size()) {
+        return Error{
+          heif_error_Invalid_input,
+          heif_suberror_Unspecified,
+          "incomplete data in unci image"
+        };
+      }
+
+      auto unit_start = compressed_bytes.begin() + unit_info.unit_offset;
+      auto unit_end = unit_start + unit_info.unit_size;
+      std::vector<uint8_t> compressed_unit_data = std::vector<uint8_t>(unit_start, unit_end);
+
+      auto dataResult = do_decompress_data(cmpC_box, std::move(compressed_unit_data));
+      if (!dataResult) {
+        return dataResult.error();
+      }
+
+      const std::vector<uint8_t> uncompressed_unit_data = std::move(*dataResult);
+      data->insert(data->end(), uncompressed_unit_data.data(), uncompressed_unit_data.data() + uncompressed_unit_data.size());
+    }
+
+    if (range_start_offset + range_size > data->size()) {
+      return {
+        heif_error_Invalid_input,
+        heif_suberror_Unspecified,
+        "Data range out of existing range"
+      };
+    }
+
+    // cut out the range that we actually need
+    memcpy(data->data(), data->data() + range_start_offset, range_size);
+    data->resize(range_size);
+  }
+  else {
+    // get all data and decode all
+    Result<std::vector<uint8_t>*> readResult = dataExtent.read_data();
+    if (!readResult) {
+      return readResult.error();
+    }
+
+    std::vector<uint8_t> compressed_bytes = std::move(**readResult);
+
+    // Decode as a single blob
+    auto dataResult = do_decompress_data(cmpC_box, compressed_bytes);
+    if (!dataResult) {
+      return dataResult.error();
+    }
+
+    *data = std::move(*dataResult);
+
+    if (range_start_offset + range_size > data->size()) {
+      return {
+        heif_error_Invalid_input,
+        heif_suberror_Unspecified,
+        "Data range out of existing range"
+      };
+    }
+
+    // cut out the range that we actually need
+    memcpy(data->data(), data->data() + range_start_offset, range_size);
+    data->resize(range_size);
+  }
+
+  return Error::Ok;
+}
+
+
+Result<std::vector<uint8_t> > unc_decoder::do_decompress_data(std::shared_ptr<const Box_cmpC>& cmpC_box,
+                                                              std::vector<uint8_t> compressed_data) const
+{
+  if (cmpC_box->get_compression_type() == fourcc("brot")) {
+#if HAVE_BROTLI
+    return decompress_brotli(compressed_data);
+#else
+    std::stringstream sstr;
+    sstr << "cannot decode unci item with brotli compression - not enabled" << std::endl;
+    return Error(heif_error_Unsupported_feature,
+                 heif_suberror_Unsupported_generic_compression_method,
+                 sstr.str());
+#endif
+  }
+  else if (cmpC_box->get_compression_type() == fourcc("zlib")) {
+#if HAVE_ZLIB
+    return decompress_zlib(compressed_data);
+#else
+    std::stringstream sstr;
+    sstr << "cannot decode unci item with zlib compression - not enabled" << std::endl;
+    return Error(heif_error_Unsupported_feature,
+                 heif_suberror_Unsupported_generic_compression_method,
+                 sstr.str());
+#endif
+  }
+  else if (cmpC_box->get_compression_type() == fourcc("defl")) {
+#if HAVE_ZLIB
+    return decompress_deflate(compressed_data);
+#else
+    std::stringstream sstr;
+    sstr << "cannot decode unci item with deflate compression - not enabled" << std::endl;
+    return Error(heif_error_Unsupported_feature,
+                 heif_suberror_Unsupported_generic_compression_method,
+                 sstr.str());
+#endif
+  }
+  else {
+    std::stringstream sstr;
+    sstr << "cannot decode unci item with unsupported compression type: " << cmpC_box->get_compression_type() << std::endl;
+    return Error(heif_error_Unsupported_feature,
+                 heif_suberror_Unsupported_generic_compression_method,
+                 sstr.str());
+  }
+}
+
+
+Error unc_decoder::decode_image(const DataExtent& extent,
+                                const UncompressedImageCodec::unci_properties& properties,
+                                std::shared_ptr<HeifPixelImage>& img)
+{
+  uint32_t tile_width = m_width / m_uncC->get_number_of_tile_columns();
+  uint32_t tile_height = m_height / m_uncC->get_number_of_tile_rows();
+
+  ensure_channel_list(img);
+
+  for (uint32_t tile_y0 = 0; tile_y0 < m_height; tile_y0 += tile_height)
+    for (uint32_t tile_x0 = 0; tile_x0 < m_width; tile_x0 += tile_width) {
+      std::vector<uint8_t> tile_data;
+      Error error = fetch_tile_data(extent, properties, tile_x0 / tile_width, tile_y0 / tile_height, tile_data);
+      if (error) {
+        return error;
+      }
+
+      error = decode_tile(tile_data, img, tile_x0, tile_y0);
+      if (error) {
+        return error;
+      }
+    }
+
+  return Error::Ok;
+}
+
+
+// --- unc_decoder_factory ---
+
+bool unc_decoder_factory::check_common_requirements(const std::shared_ptr<const Box_uncC>& uncC)
+{
+  for (const auto& component : uncC->get_components()) {
+    if (component.component_bit_depth > 16) {
+      return false;
+    }
+    if (component.component_format != component_format_unsigned) {
+      return false;
+    }
+    if (component.component_align_size > 2) {
+      return false;
+    }
+  }
+
+  if (uncC->get_block_size() != 0) {
+    return false;
+  }
+  if (uncC->is_block_pad_lsb()) {
+    return false;
+  }
+  if (uncC->is_block_little_endian()) {
+    return false;
+  }
+  if (uncC->is_block_reversed()) {
+    return false;
+  }
+
+#if 0
+  if (uncC->is_components_little_endian()) {
+    const auto& comps = uncC->get_components();
+    bool all_8_bit = std::all_of(comps.begin(), comps.end(),
+                                 [](const Box_uncC::Component& c) { return c.component_bit_depth == 8; });
+    if (!all_8_bit) {
+      return false;
+    }
+  }
+#endif
+
+  return true;
+}
+
+
+Error check_hard_limits(const std::shared_ptr<const Box_uncC>& uncC)
+{
+  const auto& components = uncC->get_components();
+
+  for (const auto& component : components) {
+    switch (component.component_format) {
+      case heif_uncompressed_component_format::component_format_signed:
+      case heif_uncompressed_component_format::component_format_unsigned:
+        if (component.component_bit_depth > 64) {
+          return Error{heif_error_Unsupported_feature, heif_suberror_Unspecified, "Maximum supported integer bit-depth is 64 bits."};
+        }
+        break;
+
+      case heif_uncompressed_component_format::component_format_float:
+        if (component.component_bit_depth != 32 &&
+            component.component_bit_depth != 64) {
+          return Error{heif_error_Unsupported_feature, heif_suberror_Unspecified, "Only 32 bit and 64 bit floats are supported."};
+        }
+        break;
+
+      case heif_uncompressed_component_format::component_format_complex:
+        if (component.component_bit_depth != 64 &&
+            component.component_bit_depth != 128) {
+          return Error{heif_error_Unsupported_feature, heif_suberror_Unspecified, "Only 2x32 bit and 2x64 bit complex values are supported."};
+        }
+        break;
+
+      default:
+        return Error{heif_error_Unsupported_feature, heif_suberror_Unspecified, "Unknown component format."};
+    }
+  }
+
+  if (uncC->get_interleave_type() != 1 &&
+      uncC->get_interleave_type() != 5 &&
+      uncC->get_pixel_size() != 0) {
+        return Error{heif_error_Invalid_input, heif_suberror_Unspecified, "uncC pixel_size must be 0 for interleave_types other than 1 or 5."};
+  }
+
+  if (uncC->get_interleave_type() == interleave_mode_pixel &&
+      uncC->get_pixel_size() != 0) {
+    uint32_t total_pixel_bits = 0;
+    for (const auto& component : uncC->get_components()) {
+      total_pixel_bits += component.component_bit_depth;
+    }
+
+    // TODO: we do not consider padding or block sizes yet
+    uint32_t PixelBytes = (total_pixel_bits + 7)/8;
+    if (PixelBytes > uncC->get_pixel_size()) {
+      return Error{heif_error_Invalid_input, heif_suberror_Unspecified, "uncC pixel_size smaller than sum of component sizes."};
+    }
+  }
+
+  return {};
+}
+
+
+Result<std::unique_ptr<unc_decoder> > unc_decoder_factory::get_unc_decoder(
+  uint32_t width, uint32_t height,
+  const std::shared_ptr<const Box_cmpd>& cmpd,
+  const std::shared_ptr<const Box_uncC>& uncC)
+{
+  static unc_decoder_factory_component_interleave dec_component;
+  static unc_decoder_factory_bytealign_component_interleave dec_bytealign_component;
+  static unc_decoder_factory_block_component_interleave dec_block_component;
+  static unc_decoder_factory_pixel_interleave dec_pixel;
+  static unc_decoder_factory_block_pixel_interleave dec_block_pixel;
+  static unc_decoder_factory_mixed_interleave dec_mixed;
+  static unc_decoder_factory_row_interleave dec_row;
+
+  static const unc_decoder_factory* decoders[]{
+    &dec_bytealign_component, &dec_block_component, &dec_component, &dec_pixel, &dec_block_pixel, &dec_mixed, &dec_row
+  };
+
+  for (const unc_decoder_factory* dec : decoders) {
+    if (dec->can_decode(uncC)) {
+      return {dec->create(width, height, cmpd, uncC)};
+    }
+  }
+
+  std::stringstream sstr;
+  sstr << "No decoder found for uncompressed format (interleave_type of " << ((int) uncC->get_interleave_type()) << ")";
+  return Error{heif_error_Unsupported_feature, heif_suberror_Unsupported_data_version, sstr.str()};
+}
+
+
+// --- decode orchestration ---
+
+Result<std::shared_ptr<HeifPixelImage> > unc_decoder::decode_full_image(
+  const UncompressedImageCodec::unci_properties& properties,
+  const DataExtent& extent,
+  const heif_security_limits* limits)
+{
+  const std::shared_ptr<const Box_ispe>& ispe = properties.ispe;
+  const std::shared_ptr<const Box_cmpd>& cmpd = properties.cmpd;
+  const std::shared_ptr<const Box_uncC>& uncC = properties.uncC;
+
+  assert(ispe);
+  uint32_t width = ispe->get_width();
+  uint32_t height = ispe->get_height();
+
+  Error global_limit_error = check_hard_limits(uncC);
+  if (global_limit_error) {
+    return {global_limit_error};
+  }
+
+  Result<std::shared_ptr<HeifPixelImage> > createImgResult = UncompressedImageCodec::create_image(cmpd, uncC, width, height, limits);
+  if (!createImgResult) {
+    return createImgResult.error();
+  }
+
+  auto img = *createImgResult;
+
+  size_t cmpd_size = cmpd ? cmpd->get_components().size() : 0;
+
+  if (properties.cpat) {
+    const auto& pattern = properties.cpat->get_pattern();
+    std::vector<uint32_t> cpat_indices;
+    for (const auto& pixel : pattern.pixels) {
+      cpat_indices.push_back(pixel.component_index);
+    }
+    Error err = validate_component_indices(cpat_indices, cmpd_size, "cpat");
+    if (err) {
+      return err;
+    }
+    img->set_bayer_pattern(pattern);
+  }
+
+  for (const auto& splz_box : properties.splz) {
+    const auto& pattern = splz_box->get_pattern();
+    Error err = validate_component_indices(pattern.component_indices, cmpd_size, "splz");
+    if (err) {
+      return err;
+    }
+    img->add_polarization_pattern(pattern);
+  }
+
+  for (const auto& sbpm_box : properties.sbpm) {
+    const auto& bad_pixels_map = sbpm_box->get_bad_pixels_map();
+    Error err = validate_component_indices(bad_pixels_map.component_indices, cmpd_size, "sbpm");
+    if (err) {
+      return err;
+    }
+    img->add_sensor_bad_pixels_map(bad_pixels_map);
+  }
+
+  for (const auto& snuc_box : properties.snuc) {
+    const auto& nuc = snuc_box->get_nuc();
+    Error err = validate_component_indices(nuc.component_indices, cmpd_size, "snuc");
+    if (err) {
+      return err;
+    }
+    img->add_sensor_nuc(nuc);
+  }
+
+  if (properties.cloc) {
+    img->set_chroma_location(properties.cloc->get_chroma_location());
+  }
+
+  auto decoderResult = unc_decoder_factory::get_unc_decoder(width, height, cmpd, uncC);
+  if (!decoderResult) {
+    return decoderResult.error();
+  }
+
+  auto& decoder = *decoderResult;
+
+  Error error = decoder->decode_image(extent, properties, img);
+  if (error) {
+    return error;
+  }
+
+  return img;
+}
diff --git a/libheif/codecs/uncompressed/unc_decoder.h b/libheif/codecs/uncompressed/unc_decoder.h
new file mode 100644
index 0000000000..895f53ef4e
--- /dev/null
+++ b/libheif/codecs/uncompressed/unc_decoder.h
@@ -0,0 +1,109 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_UNC_DECODER_H
+#define LIBHEIF_UNC_DECODER_H
+
+#include <cstdint>
+#include <memory>
+#include <vector>
+
+#include "error.h"
+#include "unc_codec.h"
+#include "unc_boxes.h"
+
+class HeifPixelImage;
+struct DataExtent;
+struct heif_security_limits;
+
+
+class unc_decoder
+{
+public:
+  virtual ~unc_decoder() = default;
+
+  virtual void ensure_channel_list(std::shared_ptr<HeifPixelImage>& img) {}
+
+  Error fetch_tile_data(const DataExtent& dataExtent,
+                        const UncompressedImageCodec::unci_properties& properties,
+                        uint32_t tile_x, uint32_t tile_y,
+                        std::vector<uint8_t>& tile_data);
+
+  virtual Error decode_tile(const std::vector<uint8_t>& tile_data,
+                            std::shared_ptr<HeifPixelImage>& img,
+                            uint32_t out_x0, uint32_t out_y0) = 0;
+
+  Error decode_image(const DataExtent& extent,
+                     const UncompressedImageCodec::unci_properties& properties,
+                     std::shared_ptr<HeifPixelImage>& img);
+
+  static Result<std::shared_ptr<HeifPixelImage>> decode_full_image(
+      const UncompressedImageCodec::unci_properties& properties,
+      const DataExtent& extent,
+      const heif_security_limits* limits);
+
+protected:
+  unc_decoder(uint32_t width, uint32_t height,
+              const std::shared_ptr<const Box_cmpd>& cmpd,
+              const std::shared_ptr<const Box_uncC>& uncC);
+
+  virtual std::vector<uint64_t> get_tile_data_sizes() const = 0;
+
+  const Error get_compressed_image_data_uncompressed(const DataExtent& dataExtent,
+                                                     const UncompressedImageCodec::unci_properties& properties,
+                                                     std::vector<uint8_t>* data,
+                                                     uint64_t range_start_offset, uint64_t range_size,
+                                                     uint32_t tile_idx,
+                                                     const Box_iloc::Item* item) const;
+
+  Result<std::vector<uint8_t>> do_decompress_data(std::shared_ptr<const Box_cmpC>& cmpC_box,
+                                                  std::vector<uint8_t> compressed_data) const;
+
+  const uint32_t m_width;
+  const uint32_t m_height;
+  const std::shared_ptr<const Box_cmpd> m_cmpd;
+  const std::shared_ptr<const Box_uncC> m_uncC;
+  uint32_t m_tile_height;
+  uint32_t m_tile_width;
+};
+
+
+class unc_decoder_factory
+{
+public:
+  virtual ~unc_decoder_factory() = default;
+
+  static Result<std::unique_ptr<unc_decoder>> get_unc_decoder(
+      uint32_t width, uint32_t height,
+      const std::shared_ptr<const Box_cmpd>& cmpd,
+      const std::shared_ptr<const Box_uncC>& uncC);
+
+protected:
+  static bool check_common_requirements(const std::shared_ptr<const Box_uncC>& uncC);
+
+  virtual bool can_decode(const std::shared_ptr<const Box_uncC>& uncC) const = 0;
+
+  virtual std::unique_ptr<unc_decoder> create(
+      uint32_t width, uint32_t height,
+      const std::shared_ptr<const Box_cmpd>& cmpd,
+      const std::shared_ptr<const Box_uncC>& uncC) const = 0;
+};
+
+#endif
diff --git a/libheif/codecs/uncompressed/unc_decoder_block_component_interleave.cc b/libheif/codecs/uncompressed/unc_decoder_block_component_interleave.cc
new file mode 100644
index 0000000000..625df8fde4
--- /dev/null
+++ b/libheif/codecs/uncompressed/unc_decoder_block_component_interleave.cc
@@ -0,0 +1,228 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2026 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "unc_decoder_block_component_interleave.h"
+#include "unc_decoder_legacybase.h" // for skip_to_alignment
+#include "unc_codec.h"
+#include "unc_types.h"
+#include "error.h"
+
+#include <bit>
+#include <cassert>
+#include <cstring>
+#include <vector>
+
+
+unc_decoder_block_component_interleave::unc_decoder_block_component_interleave(
+    uint32_t width, uint32_t height,
+    std::shared_ptr<const Box_cmpd> cmpd,
+    std::shared_ptr<const Box_uncC> uncC)
+    : unc_decoder(width, height, cmpd, uncC)
+{
+}
+
+
+std::vector<uint64_t> unc_decoder_block_component_interleave::get_tile_data_sizes() const
+{
+  const uint32_t block_size = m_uncC->get_block_size();
+  assert(block_size > 0);
+
+  uint64_t total_tile_size = 0;
+
+  for (const auto& component : m_uncC->get_components()) {
+    (void) component;
+    uint32_t bytes_per_row = block_size * m_tile_width;
+    skip_to_alignment(bytes_per_row, m_uncC->get_row_align_size());
+    total_tile_size += static_cast<uint64_t>(bytes_per_row) * m_tile_height;
+  }
+
+  if (m_uncC->get_tile_align_size() != 0) {
+    skip_to_alignment(total_tile_size, m_uncC->get_tile_align_size());
+  }
+
+  return {total_tile_size};
+}
+
+
+Error unc_decoder_block_component_interleave::decode_tile(const std::vector<uint8_t>& tile_data,
+                                                           std::shared_ptr<HeifPixelImage>& img,
+                                                           uint32_t out_x0, uint32_t out_y0)
+{
+  const uint32_t block_size = m_uncC->get_block_size();
+  const bool little_endian = m_uncC->is_block_little_endian();
+  const bool pad_lsb = m_uncC->is_block_pad_lsb();
+
+  // Build per-component info
+  struct ComponentInfo {
+    uint32_t shift;
+    uint64_t mask;
+    uint32_t bytes_per_sample;
+    bool use;
+    uint8_t* dst_plane;
+    size_t dst_plane_stride;
+  };
+
+  const auto& components = m_uncC->get_components();
+  const uint32_t num_components = static_cast<uint32_t>(components.size());
+  std::vector<ComponentInfo> comp(num_components);
+
+  for (uint32_t i = 0; i < num_components; i++) {
+    const auto& c = components[i];
+    comp[i].bytes_per_sample = (c.component_bit_depth + 7) / 8;
+    comp[i].mask = (uint64_t{1} << c.component_bit_depth) - 1;
+
+    // Each component is alone in its block, so shift depends only on padding.
+    if (pad_lsb) {
+      comp[i].shift = block_size * 8 - c.component_bit_depth;
+    }
+    else {
+      comp[i].shift = 0;
+    }
+
+    heif_channel channel;
+    comp[i].use = map_uncompressed_component_to_channel(m_cmpd, c, &channel);
+    if (comp[i].use) {
+      comp[i].dst_plane = img->get_plane(channel, &comp[i].dst_plane_stride);
+    }
+    else {
+      comp[i].dst_plane = nullptr;
+      comp[i].dst_plane_stride = 0;
+    }
+  }
+
+  const uint8_t* src = tile_data.data();
+  const uint8_t* src_end = src + tile_data.size();
+
+  // Process components sequentially (component interleave)
+  for (uint32_t c = 0; c < num_components; c++) {
+    uint32_t bytes_per_row = block_size * m_tile_width;
+    skip_to_alignment(bytes_per_row, m_uncC->get_row_align_size());
+
+    for (uint32_t tile_y = 0; tile_y < m_tile_height; tile_y++) {
+      for (uint32_t tile_x = 0; tile_x < m_tile_width; tile_x++) {
+        if (src + block_size > src_end) {
+          return {heif_error_Invalid_input, heif_suberror_Unspecified,
+                  "Block-component interleave: insufficient data"};
+        }
+
+        if (comp[c].use) {
+          // Read block_size bytes into a uint64_t.
+          uint64_t block_val = 0;
+          if (little_endian) {
+            for (uint32_t b = 0; b < block_size; b++) {
+              block_val |= static_cast<uint64_t>(src[b]) << (b * 8);
+            }
+          }
+          else {
+            for (uint32_t b = 0; b < block_size; b++) {
+              block_val = (block_val << 8) | src[b];
+            }
+          }
+
+          uint32_t value = static_cast<uint32_t>((block_val >> comp[c].shift) & comp[c].mask);
+          uint32_t dst_x = out_x0 + tile_x;
+          uint32_t dst_y = out_y0 + tile_y;
+          uint64_t dst_offset = static_cast<uint64_t>(dst_y) * comp[c].dst_plane_stride
+                                + static_cast<uint64_t>(dst_x) * comp[c].bytes_per_sample;
+          uint8_t* dst = comp[c].dst_plane + dst_offset;
+
+          if (comp[c].bytes_per_sample == 1) {
+            *dst = static_cast<uint8_t>(value);
+          }
+          else {
+            // Store in native endian (2 bytes).
+            if constexpr (std::endian::native == std::endian::little) {
+              dst[0] = static_cast<uint8_t>(value & 0xFF);
+              dst[1] = static_cast<uint8_t>((value >> 8) & 0xFF);
+            }
+            else {
+              dst[0] = static_cast<uint8_t>((value >> 8) & 0xFF);
+              dst[1] = static_cast<uint8_t>(value & 0xFF);
+            }
+          }
+        }
+
+        src += block_size;
+      }
+
+      // Skip row alignment padding
+      uint32_t pixel_bytes = block_size * m_tile_width;
+      src += bytes_per_row - pixel_bytes;
+    }
+  }
+
+  return Error::Ok;
+}
+
+
+// --- Factory ---
+
+bool unc_decoder_factory_block_component_interleave::can_decode(const std::shared_ptr<const Box_uncC>& uncC) const
+{
+  if (uncC->get_interleave_type() != interleave_mode_component) {
+    return false;
+  }
+
+  if (uncC->get_block_size() == 0 || uncC->get_block_size() > 8) {
+    return false;
+  }
+
+  if (uncC->get_pixel_size() != 0) {
+    return false;
+  }
+
+  if (uncC->get_sampling_type() != sampling_mode_no_subsampling) {
+    return false;
+  }
+
+  if (uncC->is_components_little_endian() == true) {
+    return false;
+  }
+
+  uint32_t block_bits = uncC->get_block_size() * 8;
+
+  for (const auto& component : uncC->get_components()) {
+    if (component.component_bit_depth > 16) {
+      return false;
+    }
+    if (component.component_format != component_format_unsigned) {
+      return false;
+    }
+    // Each component must fit in the block, and must be larger than half the
+    // block so that exactly one component occupies each block.
+    // Each component must be larger than half the block so that exactly one
+    // component occupies each block, and must fit within the block.
+    if (component.component_bit_depth > block_bits ||
+        component.component_bit_depth <= block_bits / 2) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+
+std::unique_ptr<unc_decoder> unc_decoder_factory_block_component_interleave::create(
+    uint32_t width, uint32_t height,
+    const std::shared_ptr<const Box_cmpd>& cmpd,
+    const std::shared_ptr<const Box_uncC>& uncC) const
+{
+  return std::make_unique<unc_decoder_block_component_interleave>(width, height, cmpd, uncC);
+}
diff --git a/libheif/codecs/uncompressed/unc_decoder_block_component_interleave.h b/libheif/codecs/uncompressed/unc_decoder_block_component_interleave.h
new file mode 100644
index 0000000000..597f1d7494
--- /dev/null
+++ b/libheif/codecs/uncompressed/unc_decoder_block_component_interleave.h
@@ -0,0 +1,55 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2026 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_UNC_DECODER_BLOCK_COMPONENT_INTERLEAVE_H
+#define LIBHEIF_UNC_DECODER_BLOCK_COMPONENT_INTERLEAVE_H
+
+#include "unc_decoder.h"
+#include <memory>
+#include <vector>
+
+
+class unc_decoder_block_component_interleave : public unc_decoder
+{
+public:
+  unc_decoder_block_component_interleave(uint32_t width, uint32_t height,
+                                          std::shared_ptr<const Box_cmpd> cmpd,
+                                          std::shared_ptr<const Box_uncC> uncC);
+
+  std::vector<uint64_t> get_tile_data_sizes() const override;
+
+  Error decode_tile(const std::vector<uint8_t>& tile_data,
+                    std::shared_ptr<HeifPixelImage>& img,
+                    uint32_t out_x0, uint32_t out_y0) override;
+};
+
+
+class unc_decoder_factory_block_component_interleave : public unc_decoder_factory
+{
+private:
+  bool can_decode(const std::shared_ptr<const Box_uncC>& uncC) const override;
+
+  std::unique_ptr<unc_decoder> create(
+      uint32_t width, uint32_t height,
+      const std::shared_ptr<const Box_cmpd>& cmpd,
+      const std::shared_ptr<const Box_uncC>& uncC) const override;
+};
+
+#endif // LIBHEIF_UNC_DECODER_BLOCK_COMPONENT_INTERLEAVE_H
diff --git a/libheif/codecs/uncompressed/unc_decoder_block_pixel_interleave.cc b/libheif/codecs/uncompressed/unc_decoder_block_pixel_interleave.cc
new file mode 100644
index 0000000000..848b618658
--- /dev/null
+++ b/libheif/codecs/uncompressed/unc_decoder_block_pixel_interleave.cc
@@ -0,0 +1,234 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2026 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "unc_decoder_block_pixel_interleave.h"
+#include "unc_decoder_legacybase.h" // for skip_to_alignment
+#include "unc_codec.h"
+#include "unc_types.h"
+#include "error.h"
+
+#include <bit>
+#include <cassert>
+#include <cstring>
+#include <vector>
+
+
+unc_decoder_block_pixel_interleave::unc_decoder_block_pixel_interleave(
+    uint32_t width, uint32_t height,
+    std::shared_ptr<const Box_cmpd> cmpd,
+    std::shared_ptr<const Box_uncC> uncC)
+    : unc_decoder(width, height, cmpd, uncC)
+{
+}
+
+
+std::vector<uint64_t> unc_decoder_block_pixel_interleave::get_tile_data_sizes() const
+{
+  uint32_t pixel_size = m_uncC->get_pixel_size();
+  assert(pixel_size > 0);
+
+  uint32_t bytes_per_row = m_tile_width * pixel_size;
+  skip_to_alignment(bytes_per_row, m_uncC->get_row_align_size());
+
+  uint64_t tile_size = static_cast<uint64_t>(bytes_per_row) * m_tile_height;
+  if (m_uncC->get_tile_align_size() != 0) {
+    skip_to_alignment(tile_size, m_uncC->get_tile_align_size());
+  }
+
+  return {tile_size};
+}
+
+
+Error unc_decoder_block_pixel_interleave::decode_tile(const std::vector<uint8_t>& tile_data,
+                                                       std::shared_ptr<HeifPixelImage>& img,
+                                                       uint32_t out_x0, uint32_t out_y0)
+{
+  uint32_t block_size = m_uncC->get_block_size();
+  const uint32_t pixel_size = m_uncC->get_pixel_size();
+  const bool little_endian = m_uncC->is_block_little_endian();
+  const bool pad_lsb = m_uncC->is_block_pad_lsb();
+  const bool reversed = m_uncC->is_block_reversed();
+
+  if (block_size == 0) {
+    block_size = pixel_size;
+  }
+
+  // Build per-component info
+  struct ComponentInfo {
+    uint32_t shift;
+    uint64_t mask;
+    uint32_t bytes_per_sample;
+    bool use;
+    uint8_t* dst_plane;
+    size_t dst_plane_stride;
+  };
+
+  const auto& components = m_uncC->get_components();
+  const uint32_t num_components = static_cast<uint32_t>(components.size());
+  std::vector<ComponentInfo> comp(num_components);
+
+  for (uint32_t i = 0; i < num_components; i++) {
+    const auto& c = components[i];
+    comp[i].bytes_per_sample = (c.component_bit_depth + 7) / 8;
+    comp[i].mask = (uint64_t{1} << c.component_bit_depth) - 1;
+
+    heif_channel channel;
+    comp[i].use = map_uncompressed_component_to_channel(m_cmpd, c, &channel);
+    if (comp[i].use) {
+      comp[i].dst_plane = img->get_plane(channel, &comp[i].dst_plane_stride);
+    }
+    else {
+      comp[i].dst_plane = nullptr;
+      comp[i].dst_plane_stride = 0;
+    }
+  }
+
+  // Compute bit shifts within the block.
+  if (!pad_lsb) {
+    uint32_t bit_offset = 0;
+    for (uint32_t i = 0; i < num_components; i++) {
+      uint32_t idx = reversed ? i : (num_components - 1 - i);
+      comp[idx].shift = bit_offset;
+      bit_offset += components[idx].component_bit_depth;
+    }
+  }
+  else {
+    uint32_t total_bits = block_size * 8;
+    uint32_t bit_offset = total_bits;
+    for (uint32_t i = 0; i < num_components; i++) {
+      uint32_t idx = reversed ? i : (num_components - 1 - i);
+      bit_offset -= components[idx].component_bit_depth;
+      comp[idx].shift = bit_offset;
+    }
+  }
+
+  const uint8_t* src_end = tile_data.data() + tile_data.size();
+
+  uint32_t bytes_per_row = m_tile_width * pixel_size;
+  skip_to_alignment(bytes_per_row, m_uncC->get_row_align_size());
+
+  for (uint32_t tile_y = 0; tile_y < m_tile_height; tile_y++) {
+    const uint8_t* row_start = tile_data.data() + static_cast<uint64_t>(tile_y) * bytes_per_row;
+
+    for (uint32_t tile_x = 0; tile_x < m_tile_width; tile_x++) {
+      const uint8_t* pixel_ptr = row_start + static_cast<uint64_t>(tile_x) * pixel_size;
+
+      if (pixel_ptr + block_size > src_end) {
+        return {heif_error_Invalid_input, heif_suberror_Unspecified,
+                "Block-pixel interleave: insufficient data"};
+      }
+
+      // Read block_size bytes into a uint64_t.
+      uint64_t block_val = 0;
+      if (little_endian) {
+        for (uint32_t b = 0; b < block_size; b++) {
+          block_val |= static_cast<uint64_t>(pixel_ptr[b]) << (b * 8);
+        }
+      }
+      else {
+        for (uint32_t b = 0; b < block_size; b++) {
+          block_val = (block_val << 8) | pixel_ptr[b];
+        }
+      }
+
+      // Extract each component.
+      for (uint32_t c = 0; c < num_components; c++) {
+        if (!comp[c].use) {
+          continue;
+        }
+
+        uint32_t value = static_cast<uint32_t>((block_val >> comp[c].shift) & comp[c].mask);
+        uint32_t dst_x = out_x0 + tile_x;
+        uint32_t dst_y = out_y0 + tile_y;
+        uint64_t dst_offset = static_cast<uint64_t>(dst_y) * comp[c].dst_plane_stride
+                              + static_cast<uint64_t>(dst_x) * comp[c].bytes_per_sample;
+        uint8_t* dst = comp[c].dst_plane + dst_offset;
+
+        if (comp[c].bytes_per_sample == 1) {
+          *dst = static_cast<uint8_t>(value);
+        }
+        else {
+          // Store in native endian (2 bytes).
+          if constexpr (std::endian::native == std::endian::little) {
+            dst[0] = static_cast<uint8_t>(value & 0xFF);
+            dst[1] = static_cast<uint8_t>((value >> 8) & 0xFF);
+          }
+          else {
+            dst[0] = static_cast<uint8_t>((value >> 8) & 0xFF);
+            dst[1] = static_cast<uint8_t>(value & 0xFF);
+          }
+        }
+      }
+    }
+  }
+
+  return Error::Ok;
+}
+
+
+// --- Factory ---
+
+bool unc_decoder_factory_block_pixel_interleave::can_decode(const std::shared_ptr<const Box_uncC>& uncC) const
+{
+  if (uncC->get_interleave_type() != interleave_mode_pixel) {
+    return false;
+  }
+
+  if (uncC->get_pixel_size() == 0) {
+    return false;
+  }
+
+  // Block size must be either 0 or equal to the pixel_size.
+  if (uncC->get_block_size() != 0 && uncC->get_block_size() != uncC->get_pixel_size()) {
+    return false;
+  }
+
+  if (uncC->get_block_size() > 8) {
+    return false;
+  }
+
+  if (uncC->get_sampling_type() != sampling_mode_no_subsampling) {
+    return false;
+  }
+
+  if (uncC->is_components_little_endian()) {
+    return false;
+  }
+
+  for (const auto& component : uncC->get_components()) {
+    if (component.component_bit_depth > 16) {
+      return false;
+    }
+    if (component.component_format != component_format_unsigned) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+
+std::unique_ptr<unc_decoder> unc_decoder_factory_block_pixel_interleave::create(
+    uint32_t width, uint32_t height,
+    const std::shared_ptr<const Box_cmpd>& cmpd,
+    const std::shared_ptr<const Box_uncC>& uncC) const
+{
+  return std::make_unique<unc_decoder_block_pixel_interleave>(width, height, cmpd, uncC);
+}
diff --git a/libheif/codecs/uncompressed/unc_decoder_block_pixel_interleave.h b/libheif/codecs/uncompressed/unc_decoder_block_pixel_interleave.h
new file mode 100644
index 0000000000..a9dfe6b994
--- /dev/null
+++ b/libheif/codecs/uncompressed/unc_decoder_block_pixel_interleave.h
@@ -0,0 +1,55 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2026 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_UNC_DECODER_BLOCK_PIXEL_INTERLEAVE_H
+#define LIBHEIF_UNC_DECODER_BLOCK_PIXEL_INTERLEAVE_H
+
+#include "unc_decoder.h"
+#include <memory>
+#include <vector>
+
+
+class unc_decoder_block_pixel_interleave : public unc_decoder
+{
+public:
+  unc_decoder_block_pixel_interleave(uint32_t width, uint32_t height,
+                                     std::shared_ptr<const Box_cmpd> cmpd,
+                                     std::shared_ptr<const Box_uncC> uncC);
+
+  std::vector<uint64_t> get_tile_data_sizes() const override;
+
+  Error decode_tile(const std::vector<uint8_t>& tile_data,
+                    std::shared_ptr<HeifPixelImage>& img,
+                    uint32_t out_x0, uint32_t out_y0) override;
+};
+
+
+class unc_decoder_factory_block_pixel_interleave : public unc_decoder_factory
+{
+private:
+  bool can_decode(const std::shared_ptr<const Box_uncC>& uncC) const override;
+
+  std::unique_ptr<unc_decoder> create(
+      uint32_t width, uint32_t height,
+      const std::shared_ptr<const Box_cmpd>& cmpd,
+      const std::shared_ptr<const Box_uncC>& uncC) const override;
+};
+
+#endif // LIBHEIF_UNC_DECODER_BLOCK_PIXEL_INTERLEAVE_H
diff --git a/libheif/codecs/uncompressed/unc_decoder_bytealign_component_interleave.cc b/libheif/codecs/uncompressed/unc_decoder_bytealign_component_interleave.cc
new file mode 100644
index 0000000000..1ba6e1c4db
--- /dev/null
+++ b/libheif/codecs/uncompressed/unc_decoder_bytealign_component_interleave.cc
@@ -0,0 +1,278 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2026 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "unc_decoder_bytealign_component_interleave.h"
+#include "unc_decoder_legacybase.h" // for skip_to_alignment
+#include "unc_codec.h"
+#include "unc_types.h"
+#include "error.h"
+
+#include <bit>
+#include <cassert>
+#include <cstring>
+#include <vector>
+
+
+unc_decoder_bytealign_component_interleave::unc_decoder_bytealign_component_interleave(
+    uint32_t width, uint32_t height,
+    std::shared_ptr<const Box_cmpd> cmpd,
+    std::shared_ptr<const Box_uncC> uncC)
+    : unc_decoder(width, height, cmpd, uncC)
+{
+}
+
+
+std::vector<uint64_t> unc_decoder_bytealign_component_interleave::get_tile_data_sizes() const
+{
+  uint64_t total_tile_size = 0;
+
+  for (const auto& component : m_uncC->get_components()) {
+    uint32_t bytes_per_sample = (component.component_bit_depth + 7) / 8;
+    if (component.component_align_size > 0) {
+      skip_to_alignment(bytes_per_sample, component.component_align_size);
+    }
+
+    uint32_t bytes_per_row = bytes_per_sample * m_tile_width;
+    skip_to_alignment(bytes_per_row, m_uncC->get_row_align_size());
+
+    total_tile_size += static_cast<uint64_t>(bytes_per_row) * m_tile_height;
+  }
+
+  if (m_uncC->get_tile_align_size() != 0) {
+    skip_to_alignment(total_tile_size, m_uncC->get_tile_align_size());
+  }
+
+  return {total_tile_size};
+}
+
+
+Error unc_decoder_bytealign_component_interleave::decode_tile(const std::vector<uint8_t>& tile_data,
+                                                               std::shared_ptr<HeifPixelImage>& img,
+                                                               uint32_t out_x0, uint32_t out_y0)
+{
+  const bool little_endian = m_uncC->is_components_little_endian();
+
+  struct ComponentInfo {
+    uint32_t bytes_per_sample;
+    bool use;
+    uint8_t* dst_plane;
+    size_t dst_plane_stride;
+  };
+
+  const auto& components = m_uncC->get_components();
+  const uint32_t num_components = static_cast<uint32_t>(components.size());
+  std::vector<ComponentInfo> comp(num_components);
+
+  for (uint32_t i = 0; i < num_components; i++) {
+    const auto& c = components[i];
+    comp[i].bytes_per_sample = (c.component_bit_depth + 7) / 8;
+
+    comp[i].use = true; // map_uncompressed_component_to_channel(m_cmpd, c, &channel);
+    if (comp[i].use) {
+      comp[i].dst_plane = img->get_component(c.component_index, &comp[i].dst_plane_stride);
+    }
+    else {
+      comp[i].dst_plane = nullptr;
+      comp[i].dst_plane_stride = 0;
+    }
+  }
+
+  const uint8_t* src = tile_data.data();
+  const uint8_t* src_end = src + tile_data.size();
+
+  for (uint32_t c = 0; c < num_components; c++) {
+    uint32_t aligned_bytes_per_sample = comp[c].bytes_per_sample;
+    if (components[c].component_align_size > 0) {
+      skip_to_alignment(aligned_bytes_per_sample, components[c].component_align_size);
+    }
+
+    uint32_t bytes_per_row = aligned_bytes_per_sample * m_tile_width;
+    skip_to_alignment(bytes_per_row, m_uncC->get_row_align_size());
+
+    for (uint32_t tile_y = 0; tile_y < m_tile_height; tile_y++) {
+      const uint8_t* row_start = src;
+
+      for (uint32_t tile_x = 0; tile_x < m_tile_width; tile_x++) {
+        if (src + aligned_bytes_per_sample > src_end) {
+          return {heif_error_Invalid_input, heif_suberror_Unspecified,
+                  "Bytealign-component interleave: insufficient data"};
+        }
+
+        if (comp[c].use) {
+          uint32_t dst_x = out_x0 + tile_x;
+          uint32_t dst_y = out_y0 + tile_y;
+          uint64_t dst_offset = static_cast<uint64_t>(dst_y) * comp[c].dst_plane_stride
+                                + static_cast<uint64_t>(dst_x) * comp[c].bytes_per_sample;
+          uint8_t* dst = comp[c].dst_plane + dst_offset;
+
+          if (comp[c].bytes_per_sample == 1) {
+            *dst = src[0];
+          }
+          else if (comp[c].bytes_per_sample == 2) {
+            uint16_t value;
+            if (little_endian) {
+              value = static_cast<uint16_t>(src[0] | (src[1] << 8));
+            }
+            else {
+              value = static_cast<uint16_t>((src[0] << 8) | src[1]);
+            }
+            std::memcpy(dst, &value, 2);
+          }
+          else if (comp[c].bytes_per_sample == 4) {
+            uint32_t value;
+            if (little_endian) {
+              value = static_cast<uint32_t>(src[0])
+                      | (static_cast<uint32_t>(src[1]) << 8)
+                      | (static_cast<uint32_t>(src[2]) << 16)
+                      | (static_cast<uint32_t>(src[3]) << 24);
+            }
+            else {
+              value = (static_cast<uint32_t>(src[0]) << 24)
+                      | (static_cast<uint32_t>(src[1]) << 16)
+                      | (static_cast<uint32_t>(src[2]) << 8)
+                      | static_cast<uint32_t>(src[3]);
+            }
+            std::memcpy(dst, &value, 4);
+          }
+          else if (comp[c].bytes_per_sample == 8) {
+            // 8-byte sample
+            uint64_t value;
+            if (little_endian) {
+              value = static_cast<uint64_t>(src[0])
+                      | (static_cast<uint64_t>(src[1]) << 8)
+                      | (static_cast<uint64_t>(src[2]) << 16)
+                      | (static_cast<uint64_t>(src[3]) << 24)
+                      | (static_cast<uint64_t>(src[4]) << 32)
+                      | (static_cast<uint64_t>(src[5]) << 40)
+                      | (static_cast<uint64_t>(src[6]) << 48)
+                      | (static_cast<uint64_t>(src[7]) << 56);
+            }
+            else {
+              value = (static_cast<uint64_t>(src[0]) << 56)
+                      | (static_cast<uint64_t>(src[1]) << 48)
+                      | (static_cast<uint64_t>(src[2]) << 40)
+                      | (static_cast<uint64_t>(src[3]) << 32)
+                      | (static_cast<uint64_t>(src[4]) << 24)
+                      | (static_cast<uint64_t>(src[5]) << 16)
+                      | (static_cast<uint64_t>(src[6]) << 8)
+                      | static_cast<uint64_t>(src[7]);
+            }
+            std::memcpy(dst, &value, 8);
+          }
+          else if (comp[c].bytes_per_sample == 16) {
+            // 16-byte sample (2* 8 complex)
+            uint64_t value[2];
+            if (little_endian) {
+              value[0] = static_cast<uint64_t>(src[0])
+                         | (static_cast<uint64_t>(src[1]) << 8)
+                         | (static_cast<uint64_t>(src[2]) << 16)
+                         | (static_cast<uint64_t>(src[3]) << 24)
+                         | (static_cast<uint64_t>(src[4]) << 32)
+                         | (static_cast<uint64_t>(src[5]) << 40)
+                         | (static_cast<uint64_t>(src[6]) << 48)
+                         | (static_cast<uint64_t>(src[7]) << 56);
+              value[1] = static_cast<uint64_t>(src[8])
+                         | (static_cast<uint64_t>(src[9]) << 8)
+                         | (static_cast<uint64_t>(src[10]) << 16)
+                         | (static_cast<uint64_t>(src[11]) << 24)
+                         | (static_cast<uint64_t>(src[12]) << 32)
+                         | (static_cast<uint64_t>(src[13]) << 40)
+                         | (static_cast<uint64_t>(src[14]) << 48)
+                         | (static_cast<uint64_t>(src[15]) << 56);
+            }
+            else {
+              value[0] = (static_cast<uint64_t>(src[0]) << 56)
+                         | (static_cast<uint64_t>(src[1]) << 48)
+                         | (static_cast<uint64_t>(src[2]) << 40)
+                         | (static_cast<uint64_t>(src[3]) << 32)
+                         | (static_cast<uint64_t>(src[4]) << 24)
+                         | (static_cast<uint64_t>(src[5]) << 16)
+                         | (static_cast<uint64_t>(src[6]) << 8)
+                         | static_cast<uint64_t>(src[7]);
+              value[1] = (static_cast<uint64_t>(src[8]) << 56)
+                         | (static_cast<uint64_t>(src[9]) << 48)
+                         | (static_cast<uint64_t>(src[10]) << 40)
+                         | (static_cast<uint64_t>(src[11]) << 32)
+                         | (static_cast<uint64_t>(src[12]) << 24)
+                         | (static_cast<uint64_t>(src[13]) << 16)
+                         | (static_cast<uint64_t>(src[14]) << 8)
+                         | static_cast<uint64_t>(src[15]);
+            }
+            std::memcpy(dst, &value, 2*8);
+          }
+          else {
+            assert(false);
+          }
+        }
+
+        src += aligned_bytes_per_sample;
+      }
+
+      // Skip row alignment padding
+      src = row_start + bytes_per_row;
+    }
+  }
+
+  return Error::Ok;
+}
+
+
+// --- Factory ---
+
+bool unc_decoder_factory_bytealign_component_interleave::can_decode(const std::shared_ptr<const Box_uncC>& uncC) const
+{
+  if (uncC->get_interleave_type() != interleave_mode_component) {
+    return false;
+  }
+
+  if (uncC->get_block_size() != 0) {
+    return false;
+  }
+
+  if (uncC->get_pixel_size() != 0) {
+    return false;
+  }
+
+  if (uncC->get_sampling_type() != sampling_mode_no_subsampling) {
+    return false;
+  }
+
+  for (const auto& component : uncC->get_components()) {
+    uint32_t d = component.component_bit_depth;
+    if (d != 8 && d != 16 && d != 32 && d != 64 && d != 128) {
+      return false;
+    }
+
+    if (d == 128 && component.component_format != heif_uncompressed_component_format::component_format_complex) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+
+std::unique_ptr<unc_decoder> unc_decoder_factory_bytealign_component_interleave::create(
+    uint32_t width, uint32_t height,
+    const std::shared_ptr<const Box_cmpd>& cmpd,
+    const std::shared_ptr<const Box_uncC>& uncC) const
+{
+  return std::make_unique<unc_decoder_bytealign_component_interleave>(width, height, cmpd, uncC);
+}
diff --git a/libheif/codecs/uncompressed/unc_decoder_bytealign_component_interleave.h b/libheif/codecs/uncompressed/unc_decoder_bytealign_component_interleave.h
new file mode 100644
index 0000000000..4a2326aba4
--- /dev/null
+++ b/libheif/codecs/uncompressed/unc_decoder_bytealign_component_interleave.h
@@ -0,0 +1,55 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2026 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_UNC_DECODER_BYTEALIGN_COMPONENT_INTERLEAVE_H
+#define LIBHEIF_UNC_DECODER_BYTEALIGN_COMPONENT_INTERLEAVE_H
+
+#include "unc_decoder.h"
+#include <memory>
+#include <vector>
+
+
+class unc_decoder_bytealign_component_interleave : public unc_decoder
+{
+public:
+  unc_decoder_bytealign_component_interleave(uint32_t width, uint32_t height,
+                                              std::shared_ptr<const Box_cmpd> cmpd,
+                                              std::shared_ptr<const Box_uncC> uncC);
+
+  std::vector<uint64_t> get_tile_data_sizes() const override;
+
+  Error decode_tile(const std::vector<uint8_t>& tile_data,
+                    std::shared_ptr<HeifPixelImage>& img,
+                    uint32_t out_x0, uint32_t out_y0) override;
+};
+
+
+class unc_decoder_factory_bytealign_component_interleave : public unc_decoder_factory
+{
+private:
+  bool can_decode(const std::shared_ptr<const Box_uncC>& uncC) const override;
+
+  std::unique_ptr<unc_decoder> create(
+      uint32_t width, uint32_t height,
+      const std::shared_ptr<const Box_cmpd>& cmpd,
+      const std::shared_ptr<const Box_uncC>& uncC) const override;
+};
+
+#endif // LIBHEIF_UNC_DECODER_BYTEALIGN_COMPONENT_INTERLEAVE_H
diff --git a/libheif/codecs/uncompressed/unc_decoder_component_interleave.cc b/libheif/codecs/uncompressed/unc_decoder_component_interleave.cc
new file mode 100644
index 0000000000..7faf02447f
--- /dev/null
+++ b/libheif/codecs/uncompressed/unc_decoder_component_interleave.cc
@@ -0,0 +1,170 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "unc_decoder_component_interleave.h"
+#include "context.h"
+#include "error.h"
+
+#include <vector>
+
+
+std::vector<uint64_t> unc_decoder_component_interleave::get_tile_data_sizes() const
+{
+  if (m_uncC->get_interleave_type() == interleave_mode_tile_component) {
+    // Per-component sizes for scattered reads
+    std::vector<uint64_t> sizes;
+
+    for (const ChannelListEntry& entry : channelList) {
+      uint32_t bits_per_pixel = entry.bits_per_component_sample;
+      if (entry.component_alignment > 0) {
+        uint32_t bytes_per_component = (bits_per_pixel + 7) / 8;
+        skip_to_alignment(bytes_per_component, entry.component_alignment);
+        bits_per_pixel = bytes_per_component * 8;
+      }
+
+      uint32_t bytes_per_row;
+      if (m_uncC->get_pixel_size() != 0) {
+        uint32_t bytes_per_pixel = (bits_per_pixel + 7) / 8;
+        skip_to_alignment(bytes_per_pixel, m_uncC->get_pixel_size());
+        bytes_per_row = bytes_per_pixel * m_tile_width;
+      }
+      else {
+        bytes_per_row = (bits_per_pixel * m_tile_width + 7) / 8;
+      }
+
+      skip_to_alignment(bytes_per_row, m_uncC->get_row_align_size());
+
+      uint64_t component_tile_size = bytes_per_row * static_cast<uint64_t>(m_tile_height);
+
+      if (m_uncC->get_tile_align_size() != 0) {
+        skip_to_alignment(component_tile_size, m_uncC->get_tile_align_size());
+      }
+
+      sizes.push_back(component_tile_size);
+    }
+
+    return sizes;
+  }
+
+  // interleave_mode_component: single contiguous block
+  uint64_t total_tile_size = 0;
+
+  for (const ChannelListEntry& entry : channelList) {
+    uint32_t bits_per_component = entry.bits_per_component_sample;
+    if (entry.component_alignment > 0) {
+      uint32_t bytes_per_component = (bits_per_component + 7) / 8;
+      skip_to_alignment(bytes_per_component, entry.component_alignment);
+      bits_per_component = bytes_per_component * 8;
+    }
+
+    uint32_t bytes_per_tile_row = (bits_per_component * entry.tile_width + 7) / 8;
+    skip_to_alignment(bytes_per_tile_row, m_uncC->get_row_align_size());
+    uint64_t bytes_per_tile = uint64_t{bytes_per_tile_row} * entry.tile_height;
+    total_tile_size += bytes_per_tile;
+  }
+
+  if (m_uncC->get_tile_align_size() != 0) {
+    skip_to_alignment(total_tile_size, m_uncC->get_tile_align_size());
+  }
+
+  return {total_tile_size};
+}
+
+
+Error unc_decoder_component_interleave::decode_tile(const std::vector<uint8_t>& tile_data,
+                                                     std::shared_ptr<HeifPixelImage>& img,
+                                                     uint32_t out_x0, uint32_t out_y0)
+{
+  UncompressedBitReader srcBits(tile_data);
+
+  bool per_channel_tile_align = (m_uncC->get_interleave_type() == interleave_mode_tile_component);
+
+  for (ChannelListEntry& entry : channelList) {
+    srcBits.markTileStart();
+    for (uint32_t y = 0; y < entry.tile_height; y++) {
+      srcBits.markRowStart();
+      if (entry.use_channel) {
+        uint64_t dst_row_offset = uint64_t{(out_y0 + y)} * entry.dst_plane_stride;
+        processComponentTileRow(entry, srcBits, dst_row_offset + out_x0 * entry.bytes_per_component_sample);
+      }
+      else {
+        srcBits.skip_bytes(entry.bytes_per_tile_row_src);
+      }
+      srcBits.handleRowAlignment(m_uncC->get_row_align_size());
+    }
+    if (per_channel_tile_align) {
+      srcBits.handleTileAlignment(m_uncC->get_tile_align_size());
+    }
+  }
+
+  return Error::Ok;
+}
+
+
+bool unc_decoder_factory_component_interleave::can_decode(const std::shared_ptr<const Box_uncC>& uncC) const
+{
+  if (!check_common_requirements(uncC)) {
+    return false;
+  }
+
+  if (uncC->get_interleave_type() != interleave_mode_component &&
+      uncC->get_interleave_type() != interleave_mode_tile_component) {
+    return false;
+  }
+
+  auto sampling = uncC->get_sampling_type();
+  if (sampling != sampling_mode_no_subsampling &&
+      sampling != sampling_mode_422 &&
+      sampling != sampling_mode_420) {
+    return false;
+  }
+
+  if (sampling == sampling_mode_422 || sampling == sampling_mode_420) {
+    if (uncC->get_row_align_size() != 0 && uncC->get_row_align_size() % 2 != 0) {
+      return false;
+    }
+  }
+
+  if (sampling == sampling_mode_422) {
+    if (uncC->get_tile_align_size() != 0 && uncC->get_tile_align_size() % 2 != 0) {
+      return false;
+    }
+  }
+
+  if (sampling == sampling_mode_420) {
+    if (uncC->get_tile_align_size() != 0 && uncC->get_tile_align_size() % 4 != 0) {
+      return false;
+    }
+  }
+
+  if (uncC->get_pixel_size() != 0) {
+    return false;
+  }
+
+  return true;
+}
+
+std::unique_ptr<unc_decoder> unc_decoder_factory_component_interleave::create(
+    uint32_t width, uint32_t height,
+    const std::shared_ptr<const Box_cmpd>& cmpd,
+    const std::shared_ptr<const Box_uncC>& uncC) const
+{
+  return std::make_unique<unc_decoder_component_interleave>(width, height, cmpd, uncC);
+}
diff --git a/libheif/codecs/uncompressed/unc_decoder_component_interleave.h b/libheif/codecs/uncompressed/unc_decoder_component_interleave.h
new file mode 100644
index 0000000000..c32ab6eadf
--- /dev/null
+++ b/libheif/codecs/uncompressed/unc_decoder_component_interleave.h
@@ -0,0 +1,57 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_UNC_DECODER_COMPONENT_INTERLEAVE_H
+#define LIBHEIF_UNC_DECODER_COMPONENT_INTERLEAVE_H
+
+#include "unc_decoder_legacybase.h"
+#include <memory>
+#include <vector>
+#include <utility>
+
+
+class unc_decoder_component_interleave : public unc_decoder_legacybase
+{
+public:
+  unc_decoder_component_interleave(uint32_t width, uint32_t height,
+                                    std::shared_ptr<const Box_cmpd> cmpd,
+                                    std::shared_ptr<const Box_uncC> uncC) :
+      unc_decoder_legacybase(width, height, std::move(cmpd), std::move(uncC)) {}
+
+  std::vector<uint64_t> get_tile_data_sizes() const override;
+
+  Error decode_tile(const std::vector<uint8_t>& tile_data,
+                    std::shared_ptr<HeifPixelImage>& img,
+                    uint32_t out_x0, uint32_t out_y0) override;
+};
+
+
+class unc_decoder_factory_component_interleave : public unc_decoder_factory
+{
+private:
+  bool can_decode(const std::shared_ptr<const Box_uncC>& uncC) const override;
+
+  std::unique_ptr<unc_decoder> create(
+      uint32_t width, uint32_t height,
+      const std::shared_ptr<const Box_cmpd>& cmpd,
+      const std::shared_ptr<const Box_uncC>& uncC) const override;
+};
+
+#endif // LIBHEIF_UNC_DECODER_COMPONENT_INTERLEAVE_H
diff --git a/libheif/codecs/uncompressed/unc_decoder_legacybase.cc b/libheif/codecs/uncompressed/unc_decoder_legacybase.cc
new file mode 100644
index 0000000000..af706ae513
--- /dev/null
+++ b/libheif/codecs/uncompressed/unc_decoder_legacybase.cc
@@ -0,0 +1,170 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <cstring>
+#include <algorithm>
+#include <iostream>
+#include <cassert>
+#include <utility>
+
+#if ((defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER) && !defined(__PGI)) && __GNUC__ < 9) || (defined(__clang__) && __clang_major__ < 10)
+#include <type_traits>
+#else
+#include <bit>
+#endif
+
+#include "common_utils.h"
+#include "context.h"
+#include "compression.h"
+#include "error.h"
+#include "libheif/heif.h"
+#include "unc_types.h"
+#include "unc_boxes.h"
+#include "unc_codec.h"
+#include "unc_decoder_legacybase.h"
+#include "codecs/decoder.h"
+
+
+unc_decoder_legacybase::unc_decoder_legacybase(uint32_t width, uint32_t height,
+                                               const std::shared_ptr<const Box_cmpd>& cmpd,
+                                               const std::shared_ptr<const Box_uncC>& uncC)
+    : unc_decoder(width, height, cmpd, uncC)
+{
+}
+
+void unc_decoder_legacybase::ensureChannelList(std::shared_ptr<HeifPixelImage>& img)
+{
+  if (channelList.empty()) {
+    buildChannelList(img);
+  }
+}
+
+void unc_decoder_legacybase::buildChannelList(std::shared_ptr<HeifPixelImage>& img)
+{
+  for (Box_uncC::Component component : m_uncC->get_components()) {
+    ChannelListEntry entry = buildChannelListEntry(component.component_index, component, img);
+    channelList.push_back(entry);
+  }
+}
+
+void unc_decoder_legacybase::memcpy_to_native_endian(uint8_t* dst, uint32_t value, uint32_t bytes_per_sample)
+{
+  // TODO: this assumes that the file endianness is always big-endian. The endianness flags in the uncC header are not taken into account yet.
+
+  if (bytes_per_sample==1) {
+    *dst = static_cast<uint8_t>(value);
+    return;
+  }
+  else if (std::endian::native == std::endian::big) {
+    for (uint32_t i = 0; i < bytes_per_sample; i++) {
+      dst[bytes_per_sample - 1 - i] = static_cast<uint8_t>((value >> (i * 8)) & 0xFF);
+    }
+  }
+  else {
+    for (uint32_t i = 0; i < bytes_per_sample; i++) {
+      dst[i] = static_cast<uint8_t>((value >> (i * 8)) & 0xFF);
+    }
+  }
+}
+
+void unc_decoder_legacybase::processComponentSample(UncompressedBitReader& srcBits, const ChannelListEntry& entry, uint64_t dst_row_offset, uint32_t tile_column, uint32_t tile_x)
+{
+  uint64_t dst_col_number = static_cast<uint64_t>(tile_column) * entry.tile_width + tile_x;
+  uint64_t dst_column_offset = dst_col_number * entry.bytes_per_component_sample;
+  int val = srcBits.get_bits(entry.bits_per_component_sample); // get_bits() reads input in big-endian order
+  memcpy_to_native_endian(entry.dst_plane + dst_row_offset + dst_column_offset, val, entry.bytes_per_component_sample);
+}
+
+// Handles the case where a row consists of a single component type
+// Not valid for Pixel interleave
+// Not valid for the Cb/Cr channels in Mixed Interleave
+// Not valid for multi-Y pixel interleave
+void unc_decoder_legacybase::processComponentRow(ChannelListEntry& entry, UncompressedBitReader& srcBits, uint64_t dst_row_offset, uint32_t tile_column)
+{
+  for (uint32_t tile_x = 0; tile_x < entry.tile_width; tile_x++) {
+    if (entry.component_alignment != 0) {
+      srcBits.skip_to_byte_boundary();
+      int numPadBits = (entry.component_alignment * 8) - entry.bits_per_component_sample;
+      srcBits.skip_bits(numPadBits);
+    }
+    processComponentSample(srcBits, entry, dst_row_offset, tile_column, tile_x);
+  }
+  srcBits.skip_to_byte_boundary();
+}
+
+void unc_decoder_legacybase::processComponentTileSample(UncompressedBitReader& srcBits, const ChannelListEntry& entry, uint64_t dst_offset, uint32_t tile_x)
+{
+  uint64_t dst_sample_offset = uint64_t{tile_x} * entry.bytes_per_component_sample;
+  int val = srcBits.get_bits(entry.bits_per_component_sample);
+  memcpy_to_native_endian(entry.dst_plane + dst_offset + dst_sample_offset, val, entry.bytes_per_component_sample);
+}
+
+// Handles the case where a row consists of a single component type
+// Not valid for Pixel interleave
+// Not valid for the Cb/Cr channels in Mixed Interleave
+// Not valid for multi-Y pixel interleave
+void unc_decoder_legacybase::processComponentTileRow(ChannelListEntry& entry, UncompressedBitReader& srcBits, uint64_t dst_offset)
+{
+  for (uint32_t tile_x = 0; tile_x < entry.tile_width; tile_x++) {
+    if (entry.component_alignment != 0) {
+      srcBits.skip_to_byte_boundary();
+      int numPadBits = (entry.component_alignment * 8) - entry.bits_per_component_sample;
+      srcBits.skip_bits(numPadBits);
+    }
+    processComponentTileSample(srcBits, entry, dst_offset, tile_x);
+  }
+  srcBits.skip_to_byte_boundary();
+}
+
+
+unc_decoder_legacybase::ChannelListEntry unc_decoder_legacybase::buildChannelListEntry(uint32_t component_idx,
+                                                                                        Box_uncC::Component component,
+                                                                                        std::shared_ptr<HeifPixelImage>& img)
+{
+  ChannelListEntry entry;
+  entry.use_channel = map_uncompressed_component_to_channel(m_cmpd, component, &(entry.channel));
+  entry.dst_plane = img->get_component(component_idx, &(entry.dst_plane_stride));
+  entry.tile_width = m_tile_width;
+  entry.tile_height = m_tile_height;
+  entry.other_chroma_dst_plane_stride = 0; // will be overwritten below if used
+  if ((entry.channel == heif_channel_Cb) || (entry.channel == heif_channel_Cr)) {
+    if (m_uncC->get_sampling_type() == sampling_mode_422) {
+      entry.tile_width /= 2;
+    }
+    else if (m_uncC->get_sampling_type() == sampling_mode_420) {
+      entry.tile_width /= 2;
+      entry.tile_height /= 2;
+    }
+    if (entry.channel == heif_channel_Cb) {
+      entry.other_chroma_dst_plane = img->get_plane(heif_channel_Cr, &(entry.other_chroma_dst_plane_stride));
+    }
+    else if (entry.channel == heif_channel_Cr) {
+      entry.other_chroma_dst_plane = img->get_plane(heif_channel_Cb, &(entry.other_chroma_dst_plane_stride));
+    }
+  }
+  entry.bits_per_component_sample = component.component_bit_depth;
+  entry.component_alignment = component.component_align_size;
+  entry.bytes_per_component_sample = (component.component_bit_depth + 7) / 8;
+  entry.bytes_per_tile_row_src = entry.tile_width * entry.bytes_per_component_sample;
+  return entry;
+}
+
+
+
diff --git a/libheif/codecs/uncompressed/unc_decoder_legacybase.h b/libheif/codecs/uncompressed/unc_decoder_legacybase.h
new file mode 100644
index 0000000000..79b93fcc1c
--- /dev/null
+++ b/libheif/codecs/uncompressed/unc_decoder_legacybase.h
@@ -0,0 +1,204 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_UNC_DECODER_LEGACYBASE_H
+#define LIBHEIF_UNC_DECODER_LEGACYBASE_H
+
+#include <cstdint>
+#include <cstring>
+#include <algorithm>
+#include <map>
+#include <iostream>
+#include <cassert>
+#include <utility>
+#include <vector>
+#include <memory>
+
+#include "common_utils.h"
+#include "context.h"
+#include "compression.h"
+#include "error.h"
+#include "libheif/heif.h"
+#include "unc_types.h"
+#include "unc_boxes.h"
+#include "unc_codec.h"
+#include "unc_decoder.h"
+
+
+class UncompressedBitReader : public BitReader
+{
+public:
+  UncompressedBitReader(const std::vector<uint8_t>& data) : BitReader(data.data(), (int) data.size()) {}
+
+  void markPixelStart()
+  {
+    m_pixelStartOffset = get_current_byte_index();
+  }
+
+  void markRowStart()
+  {
+    m_rowStartOffset = get_current_byte_index();
+  }
+
+  void markTileStart()
+  {
+    m_tileStartOffset = get_current_byte_index();
+  }
+
+  inline Error handlePixelAlignment(uint32_t pixel_size)
+  {
+    if (pixel_size != 0) {
+      uint32_t bytes_in_pixel = get_current_byte_index() - m_pixelStartOffset;
+      if (pixel_size > bytes_in_pixel) {
+        uint32_t padding = pixel_size - bytes_in_pixel;
+        skip_bytes(padding);
+      }
+      else if (pixel_size == bytes_in_pixel) {
+        // NOP
+      }
+      else {
+        return {
+          heif_error_Invalid_input,
+          heif_suberror_Unspecified,
+          "Uncompressed image: invalid 'pixel_size'"
+        };
+      }
+    }
+
+    return {};
+  }
+
+  void handleRowAlignment(uint32_t alignment)
+  {
+    skip_to_byte_boundary();
+    if (alignment != 0) {
+      uint32_t bytes_in_row = get_current_byte_index() - m_rowStartOffset;
+      uint32_t residual = bytes_in_row % alignment;
+      if (residual != 0) {
+        uint32_t padding = alignment - residual;
+        skip_bytes(padding);
+      }
+    }
+  }
+
+  void handleTileAlignment(uint32_t alignment)
+  {
+    if (alignment != 0) {
+      uint32_t bytes_in_tile = get_current_byte_index() - m_tileStartOffset;
+      uint32_t residual = bytes_in_tile % alignment;
+      if (residual != 0) {
+        uint32_t tile_padding = alignment - residual;
+        skip_bytes(tile_padding);
+      }
+    }
+  }
+
+private:
+  int m_pixelStartOffset = 0;
+  int m_rowStartOffset = 0;
+  int m_tileStartOffset = 0;
+};
+
+
+template<typename T> void skip_to_alignment(T& position, uint32_t alignment)
+{
+  if (alignment == 0) {
+    return;
+  }
+
+  T residual = position % alignment;
+  if (residual == 0) {
+    return;
+  }
+
+  position += alignment - residual;
+}
+
+
+class unc_decoder_legacybase : public unc_decoder
+{
+public:
+  ~unc_decoder_legacybase() override = default;
+
+  void ensure_channel_list(std::shared_ptr<HeifPixelImage>& img) override { ensureChannelList(img); }
+
+protected:
+  unc_decoder_legacybase(uint32_t width, uint32_t height,
+                         const std::shared_ptr<const Box_cmpd>& cmpd,
+                         const std::shared_ptr<const Box_uncC>& uncC);
+
+  class ChannelListEntry
+  {
+  public:
+    uint32_t get_bytes_per_tile() const
+    {
+      return bytes_per_tile_row_src * tile_height;
+    }
+
+    inline uint64_t getDestinationRowOffset(uint32_t tile_row, uint32_t tile_y) const
+    {
+      uint64_t dst_row_number = uint64_t{tile_row} * tile_height + tile_y;
+      return dst_row_number * dst_plane_stride;
+    }
+
+    heif_channel channel = heif_channel_Y;
+    uint8_t* dst_plane = nullptr;
+    uint8_t* other_chroma_dst_plane = nullptr;
+    size_t dst_plane_stride;
+    size_t other_chroma_dst_plane_stride;
+    uint32_t tile_width;
+    uint32_t tile_height;
+    uint32_t bytes_per_component_sample;
+    uint16_t bits_per_component_sample;
+    uint8_t component_alignment;
+    uint32_t bytes_per_tile_row_src;
+    bool use_channel;
+  };
+
+  std::vector<ChannelListEntry> channelList;
+
+  // TODO: refactor so that the channel list is passed explicitly instead of being lazily initialized as member state.
+  void ensureChannelList(std::shared_ptr<HeifPixelImage>& img);
+
+  void processComponentSample(UncompressedBitReader& srcBits, const ChannelListEntry& entry, uint64_t dst_row_offset, uint32_t tile_column, uint32_t tile_x);
+
+  // Handles the case where a row consists of a single component type
+  // Not valid for Pixel interleave
+  // Not valid for the Cb/Cr channels in Mixed Interleave
+  // Not valid for multi-Y pixel interleave
+  void processComponentRow(ChannelListEntry& entry, UncompressedBitReader& srcBits, uint64_t dst_row_offset, uint32_t tile_column);
+
+  void processComponentTileSample(UncompressedBitReader& srcBits, const ChannelListEntry& entry, uint64_t dst_offset, uint32_t tile_x);
+
+  // Handles the case where a row consists of a single component type
+  // Not valid for Pixel interleave
+  // Not valid for the Cb/Cr channels in Mixed Interleave
+  // Not valid for multi-Y pixel interleave
+  void processComponentTileRow(ChannelListEntry& entry, UncompressedBitReader& srcBits, uint64_t dst_offset);
+
+protected:
+  void memcpy_to_native_endian(uint8_t* dst, uint32_t value, uint32_t bytes_per_sample);
+
+private:
+  void buildChannelList(std::shared_ptr<HeifPixelImage>& img);
+  ChannelListEntry buildChannelListEntry(uint32_t component_idx, Box_uncC::Component component, std::shared_ptr<HeifPixelImage>& img);
+};
+
+#endif
diff --git a/libheif/codecs/uncompressed/unc_decoder_mixed_interleave.cc b/libheif/codecs/uncompressed/unc_decoder_mixed_interleave.cc
new file mode 100644
index 0000000000..81b1e8b233
--- /dev/null
+++ b/libheif/codecs/uncompressed/unc_decoder_mixed_interleave.cc
@@ -0,0 +1,156 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "unc_decoder_mixed_interleave.h"
+#include "context.h"
+#include "error.h"
+
+#include <cstring>
+#include <vector>
+
+
+std::vector<uint64_t> unc_decoder_mixed_interleave::get_tile_data_sizes() const
+{
+  uint64_t tile_size = 0;
+
+  for (const ChannelListEntry& entry : channelList) {
+    if (entry.channel == heif_channel_Cb || entry.channel == heif_channel_Cr) {
+      uint32_t bits_per_row = entry.bits_per_component_sample * entry.tile_width;
+      bits_per_row = (bits_per_row + 7) & ~7U; // align to byte boundary
+
+      tile_size += uint64_t{bits_per_row} / 8 * entry.tile_height;
+    }
+    else {
+      uint32_t bits_per_component = entry.bits_per_component_sample;
+      if (entry.component_alignment > 0) {
+        uint32_t bytes_per_component = (bits_per_component + 7) / 8;
+        skip_to_alignment(bytes_per_component, entry.component_alignment);
+        bits_per_component = bytes_per_component * 8;
+      }
+
+      uint32_t bits_per_row = bits_per_component * entry.tile_width;
+      bits_per_row = (bits_per_row + 7) & ~7U; // align to byte boundary
+
+      tile_size += uint64_t{bits_per_row} / 8 * entry.tile_height;
+    }
+  }
+
+  if (m_uncC->get_tile_align_size() != 0) {
+    skip_to_alignment(tile_size, m_uncC->get_tile_align_size());
+  }
+
+  return {tile_size};
+}
+
+
+Error unc_decoder_mixed_interleave::decode_tile(const std::vector<uint8_t>& tile_data,
+                                                 std::shared_ptr<HeifPixelImage>& img,
+                                                 uint32_t out_x0, uint32_t out_y0)
+{
+  UncompressedBitReader srcBits(tile_data);
+
+  processTile(srcBits, out_x0, out_y0);
+
+  return Error::Ok;
+}
+
+
+void unc_decoder_mixed_interleave::processTile(UncompressedBitReader& srcBits, uint32_t out_x0, uint32_t out_y0)
+{
+  bool haveProcessedChromaForThisTile = false;
+  for (ChannelListEntry& entry : channelList) {
+    if (entry.use_channel) {
+      if ((entry.channel == heif_channel_Cb) || (entry.channel == heif_channel_Cr)) {
+        if (!haveProcessedChromaForThisTile) {
+          for (uint32_t tile_y = 0; tile_y < entry.tile_height; tile_y++) {
+            // TODO: row padding
+            uint64_t dst_row_number = tile_y + out_y0;
+            uint64_t dst_row_offset = dst_row_number * entry.dst_plane_stride;
+            for (uint32_t tile_x = 0; tile_x < entry.tile_width; tile_x++) {
+              uint64_t dst_column_number = out_x0 + tile_x;
+              uint64_t dst_column_offset = dst_column_number * entry.bytes_per_component_sample;
+              int val = srcBits.get_bits(entry.bytes_per_component_sample * 8);
+              memcpy_to_native_endian(entry.dst_plane + dst_row_offset + dst_column_offset, val, entry.bytes_per_component_sample);
+              val = srcBits.get_bits(entry.bytes_per_component_sample * 8);
+
+              uint64_t other_dst_row_offset = dst_row_number * entry.other_chroma_dst_plane_stride;
+              memcpy_to_native_endian(entry.other_chroma_dst_plane + other_dst_row_offset + dst_column_offset, val, entry.bytes_per_component_sample);
+            }
+            haveProcessedChromaForThisTile = true;
+          }
+        }
+      }
+      else {
+        for (uint32_t tile_y = 0; tile_y < entry.tile_height; tile_y++) {
+          uint64_t dst_row_offset = uint64_t{(out_y0 + tile_y)} * entry.dst_plane_stride;
+          processComponentTileRow(entry, srcBits, dst_row_offset + out_x0 * entry.bytes_per_component_sample);
+        }
+      }
+    }
+    else {
+      // skip over the data we are not using
+      srcBits.skip_bytes(entry.get_bytes_per_tile());
+      continue;
+    }
+  }
+}
+
+
+bool unc_decoder_factory_mixed_interleave::can_decode(const std::shared_ptr<const Box_uncC>& uncC) const
+{
+  if (!check_common_requirements(uncC)) {
+    return false;
+  }
+
+  if (uncC->get_interleave_type() != interleave_mode_mixed) {
+    return false;
+  }
+
+  auto sampling = uncC->get_sampling_type();
+  if (sampling != sampling_mode_422 && sampling != sampling_mode_420) {
+    return false;
+  }
+
+  if (sampling == sampling_mode_422) {
+    if (uncC->get_tile_align_size() != 0 && uncC->get_tile_align_size() % 2 != 0) {
+      return false;
+    }
+  }
+
+  if (sampling == sampling_mode_420) {
+    if (uncC->get_tile_align_size() != 0 && uncC->get_tile_align_size() % 4 != 0) {
+      return false;
+    }
+  }
+
+  if (uncC->get_pixel_size() != 0) {
+    return false;
+  }
+
+  return true;
+}
+
+std::unique_ptr<unc_decoder> unc_decoder_factory_mixed_interleave::create(
+    uint32_t width, uint32_t height,
+    const std::shared_ptr<const Box_cmpd>& cmpd,
+    const std::shared_ptr<const Box_uncC>& uncC) const
+{
+  return std::make_unique<unc_decoder_mixed_interleave>(width, height, cmpd, uncC);
+}
diff --git a/libheif/codecs/uncompressed/unc_decoder_mixed_interleave.h b/libheif/codecs/uncompressed/unc_decoder_mixed_interleave.h
new file mode 100644
index 0000000000..2f37c85984
--- /dev/null
+++ b/libheif/codecs/uncompressed/unc_decoder_mixed_interleave.h
@@ -0,0 +1,57 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_UNC_DECODER_MIXED_INTERLEAVE_H
+#define LIBHEIF_UNC_DECODER_MIXED_INTERLEAVE_H
+
+#include "unc_decoder_legacybase.h"
+#include <memory>
+#include <utility>
+#include <vector>
+
+
+class unc_decoder_mixed_interleave : public unc_decoder_legacybase
+{
+public:
+  unc_decoder_mixed_interleave(uint32_t width, uint32_t height, std::shared_ptr<const Box_cmpd> cmpd, std::shared_ptr<const Box_uncC> uncC) :
+      unc_decoder_legacybase(width, height, std::move(cmpd), std::move(uncC)) {}
+
+  std::vector<uint64_t> get_tile_data_sizes() const override;
+
+  Error decode_tile(const std::vector<uint8_t>& tile_data,
+                    std::shared_ptr<HeifPixelImage>& img,
+                    uint32_t out_x0, uint32_t out_y0) override;
+
+  void processTile(UncompressedBitReader& srcBits, uint32_t out_x0, uint32_t out_y0);
+};
+
+
+class unc_decoder_factory_mixed_interleave : public unc_decoder_factory
+{
+private:
+  bool can_decode(const std::shared_ptr<const Box_uncC>& uncC) const override;
+
+  std::unique_ptr<unc_decoder> create(
+      uint32_t width, uint32_t height,
+      const std::shared_ptr<const Box_cmpd>& cmpd,
+      const std::shared_ptr<const Box_uncC>& uncC) const override;
+};
+
+#endif // LIBHEIF_UNC_DECODER_MIXED_INTERLEAVE_H
diff --git a/libheif/codecs/uncompressed/unc_decoder_pixel_interleave.cc b/libheif/codecs/uncompressed/unc_decoder_pixel_interleave.cc
new file mode 100644
index 0000000000..79886e7c1f
--- /dev/null
+++ b/libheif/codecs/uncompressed/unc_decoder_pixel_interleave.cc
@@ -0,0 +1,139 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "unc_decoder_pixel_interleave.h"
+#include "context.h"
+#include "error.h"
+
+#include <vector>
+
+
+std::vector<uint64_t> unc_decoder_pixel_interleave::get_tile_data_sizes() const
+{
+  uint32_t bits_per_row = 0;
+  for (uint32_t x = 0; x < m_tile_width; x++) {
+    uint32_t bits_per_pixel = 0;
+
+    for (const ChannelListEntry& entry : channelList) {
+      uint32_t bits_per_component = entry.bits_per_component_sample;
+      if (entry.component_alignment > 0) {
+        // start at byte boundary
+        bits_per_row = (bits_per_row + 7) & ~7U;
+
+        uint32_t bytes_per_component = (bits_per_component + 7) / 8;
+        skip_to_alignment(bytes_per_component, entry.component_alignment);
+        bits_per_component = bytes_per_component * 8;
+      }
+
+      bits_per_pixel += bits_per_component;
+    }
+
+    if (m_uncC->get_pixel_size() != 0) {
+      uint32_t bytes_per_pixel = (bits_per_pixel + 7) / 8;
+      skip_to_alignment(bytes_per_pixel, m_uncC->get_pixel_size());
+      bits_per_pixel = bytes_per_pixel * 8;
+    }
+
+    bits_per_row += bits_per_pixel;
+  }
+
+  uint32_t bytes_per_row = (bits_per_row + 7) / 8;
+  skip_to_alignment(bytes_per_row, m_uncC->get_row_align_size());
+
+  uint64_t total_tile_size = bytes_per_row * static_cast<uint64_t>(m_tile_height);
+  if (m_uncC->get_tile_align_size() != 0) {
+    skip_to_alignment(total_tile_size, m_uncC->get_tile_align_size());
+  }
+
+  return {total_tile_size};
+}
+
+
+Error unc_decoder_pixel_interleave::decode_tile(const std::vector<uint8_t>& tile_data,
+                                                 std::shared_ptr<HeifPixelImage>& img,
+                                                 uint32_t out_x0, uint32_t out_y0)
+{
+  UncompressedBitReader srcBits(tile_data);
+
+  return processTile(srcBits, out_x0, out_y0);
+}
+
+
+Error unc_decoder_pixel_interleave::processTile(UncompressedBitReader& srcBits, uint32_t out_x0, uint32_t out_y0)
+{
+  for (uint32_t tile_y = 0; tile_y < m_tile_height; tile_y++) {
+    srcBits.markRowStart();
+    for (uint32_t tile_x = 0; tile_x < m_tile_width; tile_x++) {
+      srcBits.markPixelStart();
+      for (ChannelListEntry& entry : channelList) {
+        if (entry.use_channel) {
+          uint64_t dst_row_offset = entry.getDestinationRowOffset(0, tile_y + out_y0);
+          if (entry.component_alignment != 0) {
+            srcBits.skip_to_byte_boundary();
+            int numPadBits = (entry.component_alignment * 8) - entry.bits_per_component_sample;
+            srcBits.skip_bits(numPadBits);
+          }
+          processComponentSample(srcBits, entry, dst_row_offset, 0, out_x0 + tile_x);
+        }
+        else {
+          srcBits.skip_bytes(entry.bytes_per_component_sample);
+        }
+      }
+      auto err = srcBits.handlePixelAlignment(m_uncC->get_pixel_size());
+      if (err) {
+        return err;
+      }
+    }
+
+    srcBits.handleRowAlignment(m_uncC->get_row_align_size());
+  }
+
+  return {};
+}
+
+
+bool unc_decoder_factory_pixel_interleave::can_decode(const std::shared_ptr<const Box_uncC>& uncC) const
+{
+  if (!check_common_requirements(uncC)) {
+    return false;
+  }
+
+  if (uncC->get_interleave_type() != interleave_mode_pixel) {
+    return false;
+  }
+
+  if (uncC->get_sampling_type() != sampling_mode_no_subsampling) {
+    return false;
+  }
+
+  if (uncC->is_components_little_endian()) {
+    return false;
+  }
+
+  return true;
+}
+
+std::unique_ptr<unc_decoder> unc_decoder_factory_pixel_interleave::create(
+    uint32_t width, uint32_t height,
+    const std::shared_ptr<const Box_cmpd>& cmpd,
+    const std::shared_ptr<const Box_uncC>& uncC) const
+{
+  return std::make_unique<unc_decoder_pixel_interleave>(width, height, cmpd, uncC);
+}
diff --git a/libheif/codecs/uncompressed/unc_decoder_pixel_interleave.h b/libheif/codecs/uncompressed/unc_decoder_pixel_interleave.h
new file mode 100644
index 0000000000..bee123fa87
--- /dev/null
+++ b/libheif/codecs/uncompressed/unc_decoder_pixel_interleave.h
@@ -0,0 +1,57 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_UNC_DECODER_PIXEL_INTERLEAVE_H
+#define LIBHEIF_UNC_DECODER_PIXEL_INTERLEAVE_H
+
+#include "unc_decoder_legacybase.h"
+#include <memory>
+#include <utility>
+#include <vector>
+
+
+class unc_decoder_pixel_interleave : public unc_decoder_legacybase
+{
+public:
+  unc_decoder_pixel_interleave(uint32_t width, uint32_t height, std::shared_ptr<const Box_cmpd> cmpd, std::shared_ptr<const Box_uncC> uncC) :
+      unc_decoder_legacybase(width, height, std::move(cmpd), std::move(uncC)) {}
+
+  std::vector<uint64_t> get_tile_data_sizes() const override;
+
+  Error decode_tile(const std::vector<uint8_t>& tile_data,
+                    std::shared_ptr<HeifPixelImage>& img,
+                    uint32_t out_x0, uint32_t out_y0) override;
+
+  [[nodiscard]] Error processTile(UncompressedBitReader& srcBits, uint32_t out_x0, uint32_t out_y0);
+};
+
+
+class unc_decoder_factory_pixel_interleave : public unc_decoder_factory
+{
+private:
+  bool can_decode(const std::shared_ptr<const Box_uncC>& uncC) const override;
+
+  std::unique_ptr<unc_decoder> create(
+      uint32_t width, uint32_t height,
+      const std::shared_ptr<const Box_cmpd>& cmpd,
+      const std::shared_ptr<const Box_uncC>& uncC) const override;
+};
+
+#endif // LIBHEIF_UNC_DECODER_PIXEL_INTERLEAVE_H
diff --git a/libheif/codecs/uncompressed/unc_decoder_row_interleave.cc b/libheif/codecs/uncompressed/unc_decoder_row_interleave.cc
new file mode 100644
index 0000000000..3136209fb7
--- /dev/null
+++ b/libheif/codecs/uncompressed/unc_decoder_row_interleave.cc
@@ -0,0 +1,126 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "unc_decoder_row_interleave.h"
+#include "context.h"
+#include "error.h"
+
+#include <vector>
+
+
+std::vector<uint64_t> unc_decoder_row_interleave::get_tile_data_sizes() const
+{
+  uint32_t bits_per_row = 0;
+  for (const ChannelListEntry& entry : channelList) {
+    uint32_t bits_per_component = entry.bits_per_component_sample;
+    if (entry.component_alignment > 0) {
+      // start at byte boundary
+      bits_per_row = (bits_per_row + 7) & ~7U;
+
+      uint32_t bytes_per_component = (bits_per_component + 7) / 8;
+      skip_to_alignment(bytes_per_component, entry.component_alignment);
+      bits_per_component = bytes_per_component * 8;
+    }
+
+    if (m_uncC->get_row_align_size() != 0) {
+      uint32_t bytes_this_row = (bits_per_component * m_tile_width + 7) / 8;
+      skip_to_alignment(bytes_this_row, m_uncC->get_row_align_size());
+      bits_per_row += bytes_this_row * 8;
+    }
+    else {
+      bits_per_row += bits_per_component * m_tile_width;
+    }
+
+    bits_per_row = (bits_per_row + 7) & ~7U;
+  }
+
+  uint32_t bytes_per_row = (bits_per_row + 7) / 8;
+  if (m_uncC->get_row_align_size()) {
+    skip_to_alignment(bytes_per_row, m_uncC->get_row_align_size());
+  }
+
+  uint64_t total_tile_size = bytes_per_row * static_cast<uint64_t>(m_tile_height);
+
+  if (m_uncC->get_tile_align_size() != 0) {
+    skip_to_alignment(total_tile_size, m_uncC->get_tile_align_size());
+  }
+
+  return {total_tile_size};
+}
+
+
+Error unc_decoder_row_interleave::decode_tile(const std::vector<uint8_t>& tile_data,
+                                               std::shared_ptr<HeifPixelImage>& img,
+                                               uint32_t out_x0, uint32_t out_y0)
+{
+  UncompressedBitReader srcBits(tile_data);
+
+  processTile(srcBits, out_x0, out_y0);
+
+  return Error::Ok;
+}
+
+
+void unc_decoder_row_interleave::processTile(UncompressedBitReader& srcBits, uint32_t out_x0, uint32_t out_y0)
+{
+  for (uint32_t tile_y = 0; tile_y < m_tile_height; tile_y++) {
+    for (ChannelListEntry& entry : channelList) {
+      srcBits.markRowStart();
+      if (entry.use_channel) {
+        uint64_t dst_row_offset = entry.getDestinationRowOffset(0, tile_y + out_y0);
+        processComponentRow(entry, srcBits, dst_row_offset + out_x0 * entry.bytes_per_component_sample, 0);
+      }
+      else {
+        srcBits.skip_bytes(entry.bytes_per_tile_row_src);
+      }
+      srcBits.handleRowAlignment(m_uncC->get_row_align_size());
+    }
+  }
+}
+
+
+bool unc_decoder_factory_row_interleave::can_decode(const std::shared_ptr<const Box_uncC>& uncC) const
+{
+  if (!check_common_requirements(uncC)) {
+    return false;
+  }
+
+  if (uncC->get_interleave_type() != interleave_mode_row) {
+    return false;
+  }
+
+  if (uncC->get_sampling_type() != sampling_mode_no_subsampling) {
+    return false;
+  }
+
+  if (uncC->get_pixel_size() != 0) {
+    return false;
+  }
+
+  return true;
+}
+
+std::unique_ptr<unc_decoder> unc_decoder_factory_row_interleave::create(
+    uint32_t width, uint32_t height,
+    const std::shared_ptr<const Box_cmpd>& cmpd,
+    const std::shared_ptr<const Box_uncC>& uncC) const
+{
+  return std::make_unique<unc_decoder_row_interleave>(width, height, cmpd, uncC);
+}
diff --git a/libheif/codecs/uncompressed/unc_decoder_row_interleave.h b/libheif/codecs/uncompressed/unc_decoder_row_interleave.h
new file mode 100644
index 0000000000..90d111b68d
--- /dev/null
+++ b/libheif/codecs/uncompressed/unc_decoder_row_interleave.h
@@ -0,0 +1,60 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_UNC_DECODER_ROW_INTERLEAVE_H
+#define LIBHEIF_UNC_DECODER_ROW_INTERLEAVE_H
+
+#include "unc_decoder_legacybase.h"
+#include <memory>
+#include <utility>
+#include <vector>
+
+
+class unc_decoder_row_interleave : public unc_decoder_legacybase
+{
+public:
+  unc_decoder_row_interleave(uint32_t width, uint32_t height,
+                              std::shared_ptr<const Box_cmpd> cmpd, std::shared_ptr<const Box_uncC> uncC) :
+      unc_decoder_legacybase(width, height, std::move(cmpd), std::move(uncC)) {}
+
+
+  std::vector<uint64_t> get_tile_data_sizes() const override;
+
+  Error decode_tile(const std::vector<uint8_t>& tile_data,
+                    std::shared_ptr<HeifPixelImage>& img,
+                    uint32_t out_x0, uint32_t out_y0) override;
+
+private:
+  void processTile(UncompressedBitReader& srcBits, uint32_t out_x0, uint32_t out_y0);
+};
+
+
+class unc_decoder_factory_row_interleave : public unc_decoder_factory
+{
+private:
+  bool can_decode(const std::shared_ptr<const Box_uncC>& uncC) const override;
+
+  std::unique_ptr<unc_decoder> create(
+      uint32_t width, uint32_t height,
+      const std::shared_ptr<const Box_cmpd>& cmpd,
+      const std::shared_ptr<const Box_uncC>& uncC) const override;
+};
+
+#endif // LIBHEIF_UNC_DECODER_ROW_INTERLEAVE_H
diff --git a/libheif/codecs/uncompressed/unc_enc.cc b/libheif/codecs/uncompressed/unc_enc.cc
new file mode 100644
index 0000000000..cde3a5978d
--- /dev/null
+++ b/libheif/codecs/uncompressed/unc_enc.cc
@@ -0,0 +1,83 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "unc_enc.h"
+#include "unc_boxes.h"
+#include "error.h"
+#include "context.h"
+#include "api_structs.h"
+#include <cstring>
+#include <image-items/unc_image.h>
+
+#include <string>
+
+#include "unc_encoder.h"
+
+
+Result<Encoder::CodedImageData> Encoder_uncompressed::encode(const std::shared_ptr<HeifPixelImage>& image,
+                                                             struct heif_encoder* encoder,
+                                                             const struct heif_encoding_options& options,
+                                                             enum heif_image_input_class input_class)
+{
+  auto uncEncoder = unc_encoder_factory::get_unc_encoder(image, options);
+  if (uncEncoder.error()) {
+    return uncEncoder.error();
+  }
+
+  auto codingResult = (*uncEncoder)->encode(image, options);
+  if (!codingResult) {
+    return codingResult.error();
+  }
+
+  Encoder::CodedImageData codedImage = *codingResult;
+
+  // codedImage.bitstream = std::move(vec);
+
+  codedImage.codingConstraints.intra_pred_used = false;
+  codedImage.codingConstraints.all_ref_pics_intra = true;
+  codedImage.codingConstraints.max_ref_per_pic = 0;
+
+  return {codedImage};
+}
+
+
+std::shared_ptr<class Box_VisualSampleEntry> Encoder_uncompressed::get_sample_description_box(const CodedImageData& data) const
+{
+  auto uncv = std::make_shared<Box_uncv>();
+  uncv->get_VisualSampleEntry().compressorname = "iso23001-17";
+
+  for (auto prop : data.properties) {
+    switch (prop->get_short_type()) {
+      case fourcc("cmpd"):
+      case fourcc("uncC"):
+      case fourcc("cmpC"):
+      case fourcc("icef"):
+      case fourcc("cpat"):
+      case fourcc("splz"):
+      case fourcc("sbpm"):
+      case fourcc("snuc"):
+      case fourcc("cloc"):
+        uncv->append_child_box(prop);
+      break;
+    }
+  }
+
+  return uncv;
+}
diff --git a/libheif/codecs/uncompressed/unc_enc.h b/libheif/codecs/uncompressed/unc_enc.h
new file mode 100644
index 0000000000..01d7eeebb1
--- /dev/null
+++ b/libheif/codecs/uncompressed/unc_enc.h
@@ -0,0 +1,86 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2025 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef HEIF_ENCODER_UNCOMPRESSED_H
+#define HEIF_ENCODER_UNCOMPRESSED_H
+
+#include "libheif/heif.h"
+#include "box.h"
+#include "error.h"
+#include "file.h"
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+#include "codecs/encoder.h"
+
+
+class Encoder_uncompressed : public Encoder {
+public:
+  Result<CodedImageData> encode(const std::shared_ptr<HeifPixelImage>& image,
+                                struct heif_encoder* encoder,
+                                const struct heif_encoding_options& options,
+                                enum heif_image_input_class input_class) override;
+
+  std::shared_ptr<class Box_VisualSampleEntry> get_sample_description_box(const CodedImageData&) const override;
+
+  bool encode_sequence_started() const override { return m_codedImageData.has_value(); }
+
+  Error encode_sequence_frame(const std::shared_ptr<HeifPixelImage>& image,
+                                      heif_encoder* encoder,
+                                      const heif_sequence_encoding_options& options,
+                                      heif_image_input_class input_class,
+                                      uint32_t framerate_num, uint32_t framerate_denom,
+                                      uintptr_t frame_number) override
+  {
+    heif_encoding_options dummy_options{};
+
+    dummy_options.save_alpha_channel = static_cast<uint8_t>(options.save_alpha_channel);
+
+    auto encodeResult = encode(image, encoder, dummy_options, input_class);
+    if (encodeResult.error()) {
+      return encodeResult.error();
+    }
+
+    m_codedImageData = std::move(*encodeResult);
+
+    m_codedImageData->frame_nr = frame_number;
+    m_codedImageData->is_sync_frame = true;
+
+    return {};
+  }
+
+  Error encode_sequence_flush(heif_encoder* encoder) override
+  {
+    return {};
+  }
+
+  std::optional<CodedImageData> encode_sequence_get_data() override
+  {
+    return std::move(m_codedImageData);
+  }
+
+private:
+  std::optional<CodedImageData> m_codedImageData;
+};
+
+
+#endif
diff --git a/libheif/codecs/uncompressed/unc_encoder.cc b/libheif/codecs/uncompressed/unc_encoder.cc
new file mode 100644
index 0000000000..c07fcc4106
--- /dev/null
+++ b/libheif/codecs/uncompressed/unc_encoder.cc
@@ -0,0 +1,291 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2026 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "unc_encoder.h"
+
+#include <cassert>
+#include <cstring>
+#include <map>
+#include <set>
+
+#include "pixelimage.h"
+#include "unc_boxes.h"
+#include "unc_encoder_component_interleave.h"
+#include "unc_encoder_rgb_block_pixel_interleave.h"
+#include "unc_encoder_rgb_pixel_interleave.h"
+#include "unc_encoder_rgb_bytealign_pixel_interleave.h"
+#include "libheif/heif_uncompressed.h"
+#include "compression.h"
+#include <utility>
+
+
+heif_uncompressed_component_type heif_channel_to_component_type(heif_channel channel)
+{
+  switch (channel) {
+    case heif_channel_Y: return heif_uncompressed_component_type_Y;
+    case heif_channel_Cb: return heif_uncompressed_component_type_Cb;
+    case heif_channel_Cr: return heif_uncompressed_component_type_Cr;
+    case heif_channel_R: return heif_uncompressed_component_type_red;
+    case heif_channel_G: return heif_uncompressed_component_type_green;
+    case heif_channel_B: return heif_uncompressed_component_type_blue;
+    case heif_channel_Alpha: return heif_uncompressed_component_type_alpha;
+    case heif_channel_interleaved: assert(false);
+      break;
+    case heif_channel_filter_array: return heif_uncompressed_component_type_filter_array;
+    case heif_channel_depth: return heif_uncompressed_component_type_depth;
+    case heif_channel_disparity: return heif_uncompressed_component_type_disparity;
+    case heif_channel_unknown: return heif_uncompressed_component_type_padded;
+  }
+
+  return heif_uncompressed_component_type_padded;
+}
+
+
+heif_uncompressed_component_format to_unc_component_format(heif_channel_datatype channel_datatype)
+{
+  switch (channel_datatype) {
+    case heif_channel_datatype_signed_integer:
+      return component_format_signed;
+
+    case heif_channel_datatype_floating_point:
+      return component_format_float;
+
+    case heif_channel_datatype_complex_number:
+      return component_format_complex;
+
+    case heif_channel_datatype_unsigned_integer:
+    case heif_channel_datatype_undefined:
+    default:
+      return component_format_unsigned;
+  }
+}
+
+
+unc_encoder::unc_encoder(const std::shared_ptr<const HeifPixelImage>& image)
+{
+  m_cmpd = std::make_shared<Box_cmpd>();
+  m_uncC = std::make_shared<Box_uncC>();
+
+  m_cmpd->set_components(image->get_cmpd_component_types());
+
+  // --- Bayer pattern: add reference components to cmpd and generate cpat box
+
+  if (image->has_bayer_pattern()) {
+    const BayerPattern& bayer = image->get_bayer_pattern();
+
+    // The bayer pattern stores component_index values. When the image has a cmpd
+    // table (add_component path), we look up the component type from it. When it
+    // doesn't (legacy add_plane path), the component_index IS the component type.
+
+    // Collect unique component types from the pattern (in order of first appearance)
+    std::vector<uint16_t> unique_types;
+    std::set<uint16_t> seen;
+    for (const auto& pixel : bayer.pixels) {
+      uint16_t comp_type = pixel.component_index;  // legacy: index IS the type
+      if (seen.insert(comp_type).second) {
+        unique_types.push_back(comp_type);
+      }
+    }
+
+    // Add reference components to cmpd (these have no uncC entries).
+    std::map<uint16_t, uint16_t> type_to_cmpd_index;
+    for (uint16_t type : unique_types) {
+      type_to_cmpd_index[type] = m_cmpd->add_component({type});
+    }
+
+    // Build cpat box with resolved cmpd indices
+    BayerPattern cpat_pattern;
+    cpat_pattern.pattern_width = bayer.pattern_width;
+    cpat_pattern.pattern_height = bayer.pattern_height;
+    cpat_pattern.pixels.resize(bayer.pixels.size());
+    for (size_t i = 0; i < bayer.pixels.size(); i++) {
+      uint16_t comp_type = bayer.pixels[i].component_index;  // legacy: index IS the type
+      cpat_pattern.pixels[i].component_index = type_to_cmpd_index[comp_type];
+      cpat_pattern.pixels[i].component_gain = bayer.pixels[i].component_gain;
+    }
+
+    m_cpat = std::make_shared<Box_cpat>();
+    m_cpat->set_pattern(cpat_pattern);
+  }
+
+  if (image->has_polarization_patterns()) {
+    for (const auto& pol : image->get_polarization_patterns()) {
+      auto splz = std::make_shared<Box_splz>();
+      splz->set_pattern(pol);
+      m_splz.push_back(splz);
+    }
+  }
+
+  if (image->has_sensor_bad_pixels_maps()) {
+    for (const auto& bpm : image->get_sensor_bad_pixels_maps()) {
+      auto sbpm = std::make_shared<Box_sbpm>();
+      sbpm->set_bad_pixels_map(bpm);
+      m_sbpm.push_back(sbpm);
+    }
+  }
+
+  if (image->has_sensor_nuc()) {
+    for (const auto& nuc : image->get_sensor_nuc()) {
+      auto snuc = std::make_shared<Box_snuc>();
+      snuc->set_nuc(nuc);
+      m_snuc.push_back(snuc);
+    }
+  }
+
+  if (image->has_chroma_location()) {
+    m_cloc = std::make_shared<Box_cloc>();
+    m_cloc->set_chroma_location(image->get_chroma_location());
+  }
+}
+
+
+Result<std::unique_ptr<const unc_encoder> > unc_encoder_factory::get_unc_encoder(const std::shared_ptr<const HeifPixelImage>& prototype_image,
+                                                                                 const heif_encoding_options& options)
+{
+  static unc_encoder_factory_rgb_pixel_interleave enc_rgb_pixel_interleave;
+  static unc_encoder_factory_rgb_block_pixel_interleave enc_rgb_block_pixel_interleave;
+  static unc_encoder_factory_rgb_bytealign_pixel_interleave enc_rgb_bytealign_pixel_interleave;
+  static unc_encoder_factory_component_interleave enc_component_interleave;
+
+  static const unc_encoder_factory* encoders[]{
+    &enc_rgb_pixel_interleave,
+    &enc_rgb_block_pixel_interleave,
+    &enc_rgb_bytealign_pixel_interleave,
+    &enc_component_interleave
+  };
+
+  for (const unc_encoder_factory* enc : encoders) {
+    if (enc->can_encode(prototype_image, options)) {
+      return {enc->create(prototype_image, options)};
+    }
+  }
+
+  return Error{
+    heif_error_Unsupported_filetype,
+    heif_suberror_Unspecified,
+    "Input image configuration unsupported by uncompressed codec."
+  };
+}
+
+
+heif_uncompressed_component_format to_unc_component_format(const std::shared_ptr<const HeifPixelImage>& image, heif_channel channel)
+{
+  heif_channel_datatype datatype = image->get_datatype(channel);
+  heif_uncompressed_component_format component_format = to_unc_component_format(datatype);
+  return component_format;
+}
+
+
+Result<Encoder::CodedImageData> unc_encoder::encode(const std::shared_ptr<const HeifPixelImage>& src_image,
+                                                           const heif_encoding_options& in_options) const
+{
+  auto parameters = std::unique_ptr<heif_unci_image_parameters,
+                                    void (*)(heif_unci_image_parameters*)>(heif_unci_image_parameters_alloc(),
+                                                                           heif_unci_image_parameters_release);
+
+  parameters->image_width = src_image->get_width();
+  parameters->image_height = src_image->get_height();
+  parameters->tile_width = parameters->image_width;
+  parameters->tile_height = parameters->image_height;
+
+
+  heif_encoding_options options = in_options;
+  if (src_image->has_alpha() && !options.save_alpha_channel) {
+    // TODO: drop alpha channel
+  }
+
+
+  // --- generate configuration property boxes
+
+  auto uncC = this->get_uncC();
+  uncC->derive_box_version();
+
+  Encoder::CodedImageData codedImageData;
+  codedImageData.properties.push_back(uncC);
+  if (!uncC->is_minimized()) {
+    codedImageData.properties.push_back(this->get_cmpd());
+  }
+
+  if (m_cpat) {
+    codedImageData.properties.push_back(m_cpat);
+  }
+
+  for (const auto& splz : m_splz) {
+    codedImageData.properties.push_back(splz);
+  }
+
+  for (const auto& sbpm : m_sbpm) {
+    codedImageData.properties.push_back(sbpm);
+  }
+
+  for (const auto& snuc : m_snuc) {
+    codedImageData.properties.push_back(snuc);
+  }
+
+  if (m_cloc) {
+    codedImageData.properties.push_back(m_cloc);
+  }
+
+
+  // --- encode image
+
+  Result<std::vector<uint8_t> > codedBitstreamResult = this->encode_tile(src_image);
+  if (!codedBitstreamResult) {
+    return codedBitstreamResult.error();
+  }
+
+  // --- optionally compress
+
+  heif_unci_compression compression = (in_options.version >= 8) ? in_options.unci_compression : heif_unci_compression_off;
+
+  if (compression != heif_unci_compression_off) {
+    uint32_t compr_fourcc = unci_compression_to_fourcc(compression);
+
+    auto compressed = compress_unci_fourcc(compr_fourcc,
+                                            codedBitstreamResult->data(),
+                                            codedBitstreamResult->size());
+    if (!compressed) {
+      return compressed.error();
+    }
+
+    auto cmpC = std::make_shared<Box_cmpC>();
+    cmpC->set_compression_type(compr_fourcc);
+    cmpC->set_compressed_unit_type(heif_cmpC_compressed_unit_type_image_tile);
+    codedImageData.properties.push_back(cmpC);
+
+    /* Generating an icef for a single unit is redundant because when no icef is present,
+     * the whole data extent will automatically be used.
+
+    auto icef = std::make_shared<Box_icef>();
+    Box_icef::CompressedUnitInfo info;
+    info.unit_offset = 0;
+    info.unit_size = compressed->size();
+    icef->add_component(info);
+    codedImageData.properties.push_back(icef);
+    */
+
+    codedImageData.bitstream = std::move(*compressed);
+  }
+  else {
+    codedImageData.bitstream = std::move(*codedBitstreamResult);
+  }
+
+  return codedImageData;
+}
diff --git a/libheif/codecs/uncompressed/unc_encoder.h b/libheif/codecs/uncompressed/unc_encoder.h
new file mode 100644
index 0000000000..40d2a8d94a
--- /dev/null
+++ b/libheif/codecs/uncompressed/unc_encoder.h
@@ -0,0 +1,96 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2026 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_UNC_ENCODER_H
+#define LIBHEIF_UNC_ENCODER_H
+
+#include <memory>
+#include <vector>
+
+#include "error.h"
+#include "codecs/encoder.h"
+#include "libheif/heif_encoding.h"
+#include "unc_types.h"
+
+class Box_uncC;
+class Box_cmpd;
+class Box_cpat;
+class Box_splz;
+class Box_sbpm;
+class Box_snuc;
+class Box_cloc;
+class HeifPixelImage;
+
+heif_uncompressed_component_type heif_channel_to_component_type(heif_channel channel);
+
+heif_uncompressed_component_format to_unc_component_format(heif_channel_datatype channel_datatype);
+
+
+class unc_encoder
+{
+public:
+  explicit unc_encoder(const std::shared_ptr<const HeifPixelImage>& image);
+
+  virtual ~unc_encoder() = default;
+
+  std::shared_ptr<Box_cmpd> get_cmpd() const { return m_cmpd; }
+  std::shared_ptr<Box_uncC> get_uncC() const { return m_uncC; }
+  std::shared_ptr<Box_cpat> get_cpat() const { return m_cpat; }
+  std::vector<std::shared_ptr<Box_splz>> get_splz() const { return m_splz; }
+  std::vector<std::shared_ptr<Box_sbpm>> get_sbpm() const { return m_sbpm; }
+  std::vector<std::shared_ptr<Box_snuc>> get_snuc() const { return m_snuc; }
+  std::shared_ptr<Box_cloc> get_cloc() const { return m_cloc; }
+
+
+  virtual uint64_t compute_tile_data_size_bytes(uint32_t tile_width, uint32_t tile_height) const = 0;
+
+  [[nodiscard]] virtual std::vector<uint8_t> encode_tile(const std::shared_ptr<const HeifPixelImage>& image) const = 0;
+
+  Result<Encoder::CodedImageData> encode(const std::shared_ptr<const HeifPixelImage>& src_image,
+                                         const heif_encoding_options& options) const;
+
+protected:
+  std::shared_ptr<Box_cmpd> m_cmpd;
+  std::shared_ptr<Box_uncC> m_uncC;
+  std::shared_ptr<Box_cpat> m_cpat;
+  std::vector<std::shared_ptr<Box_splz>> m_splz;
+  std::vector<std::shared_ptr<Box_sbpm>> m_sbpm;
+  std::vector<std::shared_ptr<Box_snuc>> m_snuc;
+  std::shared_ptr<Box_cloc> m_cloc;
+};
+
+
+class unc_encoder_factory
+{
+public:
+  virtual ~unc_encoder_factory() = default;
+
+  static Result<std::unique_ptr<const unc_encoder> > get_unc_encoder(const std::shared_ptr<const HeifPixelImage>& prototype_image,
+                                                                     const heif_encoding_options& options);
+
+private:
+  virtual bool can_encode(const std::shared_ptr<const HeifPixelImage>& image,
+                          const heif_encoding_options& options) const = 0;
+
+  virtual std::unique_ptr<const unc_encoder> create(const std::shared_ptr<const HeifPixelImage>& prototype_image,
+                                                    const heif_encoding_options& options) const = 0;
+};
+
+#endif //LIBHEIF_UNC_ENCODER_H
diff --git a/libheif/codecs/uncompressed/unc_encoder_component_interleave.cc b/libheif/codecs/uncompressed/unc_encoder_component_interleave.cc
new file mode 100644
index 0000000000..cf9bf64c2a
--- /dev/null
+++ b/libheif/codecs/uncompressed/unc_encoder_component_interleave.cc
@@ -0,0 +1,207 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2026 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "unc_encoder_component_interleave.h"
+
+#include <cstring>
+
+#include "pixelimage.h"
+#include "unc_boxes.h"
+
+
+bool unc_encoder_factory_component_interleave::can_encode(const std::shared_ptr<const HeifPixelImage>& image,
+                                                          const heif_encoding_options& options) const
+{
+  if (image->has_channel(heif_channel_interleaved)) {
+    return false;
+  }
+
+  return true;
+}
+
+
+std::unique_ptr<const unc_encoder> unc_encoder_factory_component_interleave::create(const std::shared_ptr<const HeifPixelImage>& image,
+                                                                                    const heif_encoding_options& options) const
+{
+  return std::make_unique<unc_encoder_component_interleave>(image, options);
+}
+
+
+unc_encoder_component_interleave::unc_encoder_component_interleave(const std::shared_ptr<const HeifPixelImage>& image,
+                                                                   const heif_encoding_options& options)
+    : unc_encoder(image)
+{
+  bool is_nonvisual = (image->get_colorspace() == heif_colorspace_nonvisual);
+  uint32_t num_components = image->get_number_of_used_components();
+
+  for (uint32_t idx = 0; idx < num_components; idx++) {
+    heif_uncompressed_component_type comp_type;
+    heif_channel ch = heif_channel_Y; // default for nonvisual
+
+    if (is_nonvisual) {
+      comp_type = static_cast<heif_uncompressed_component_type>(image->get_component_type(idx));
+    }
+    else {
+      ch = image->get_component_channel(idx);
+      if (ch == heif_channel_Y && !image->has_channel(heif_channel_Cb)) {
+        comp_type = heif_uncompressed_component_type_monochrome;
+      }
+      else {
+        comp_type = heif_channel_to_component_type(ch);
+      }
+    }
+
+    uint8_t bpp = image->get_component_bits_per_pixel(idx);
+    auto comp_format = to_unc_component_format(image->get_component_datatype(idx));
+    bool aligned = (bpp % 8 == 0);
+
+    m_components.push_back({idx, ch, comp_type, comp_format, bpp, aligned});
+  }
+
+  // Build cmpd/uncC boxes
+  bool little_endian = false;
+
+  for (const auto& comp : m_components) {
+    //uint16_t cmpd_index = m_cmpd->add_component({static_cast<uint16_t>(comp.component_type)});
+
+    uint8_t component_align_size = 0;
+
+    if (comp.byte_aligned && comp.bpp > 8) {
+      little_endian = true;
+    }
+
+    m_uncC->add_component({comp.component_idx, comp.bpp, comp.component_format, component_align_size});
+  }
+
+  m_uncC->set_interleave_type(interleave_mode_component);
+  m_uncC->set_components_little_endian(little_endian);
+  m_uncC->set_block_size(0);
+
+  if (image->get_chroma_format() == heif_chroma_420) {
+    m_uncC->set_sampling_type(sampling_mode_420);
+  }
+  else if (image->get_chroma_format() == heif_chroma_422) {
+    m_uncC->set_sampling_type(sampling_mode_422);
+  }
+  else {
+    m_uncC->set_sampling_type(sampling_mode_no_subsampling);
+  }
+}
+
+
+uint64_t unc_encoder_component_interleave::compute_tile_data_size_bytes(uint32_t tile_width, uint32_t tile_height) const
+{
+  uint64_t total = 0;
+  for (const auto& comp : m_components) {
+    uint32_t plane_width = tile_width;
+    uint32_t plane_height = tile_height;
+
+    if (comp.channel == heif_channel_Cb || comp.channel == heif_channel_Cr) {
+      // Adjust for chroma subsampling
+      if (m_uncC->get_sampling_type() == sampling_mode_420) {
+        plane_width = (plane_width + 1) / 2;
+        plane_height = (plane_height + 1) / 2;
+      }
+      else if (m_uncC->get_sampling_type() == sampling_mode_422) {
+        plane_width = (plane_width + 1) / 2;
+      }
+    }
+
+    uint64_t row_bytes;
+    if (comp.byte_aligned) {
+      row_bytes = static_cast<uint64_t>(plane_width) * ((comp.bpp + 7) / 8);
+    }
+    else {
+      row_bytes = (static_cast<uint64_t>(plane_width) * comp.bpp + 7) / 8;
+    }
+    total += row_bytes * plane_height;
+  }
+  return total;
+}
+
+
+std::vector<uint8_t> unc_encoder_component_interleave::encode_tile(const std::shared_ptr<const HeifPixelImage>& src_image) const
+{
+  uint64_t total_size = compute_tile_data_size_bytes(src_image->get_width(), src_image->get_height());
+  std::vector<uint8_t> data;
+  data.resize(total_size);
+
+  uint64_t out_pos = 0;
+
+  for (const auto& comp : m_components) {
+    uint32_t plane_width = src_image->get_component_width(comp.component_idx);
+    uint32_t plane_height = src_image->get_component_height(comp.component_idx);
+    uint8_t bpp = comp.bpp;
+
+    size_t src_stride;
+    const uint8_t* src_data = src_image->get_component(comp.component_idx, &src_stride);
+
+    if (comp.byte_aligned) {
+      // Byte-aligned path: memcpy per row
+      int bytes_per_pixel = (bpp + 7) / 8;
+
+      for (uint32_t y = 0; y < plane_height; y++) {
+        memcpy(data.data() + out_pos,
+               src_data + src_stride * y,
+               plane_width * bytes_per_pixel);
+        out_pos += plane_width * bytes_per_pixel;
+      }
+    }
+    else {
+      // Bit-packed path: bit accumulator with row-end flush
+      for (uint32_t y = 0; y < plane_height; y++) {
+        const uint8_t* row = src_data + src_stride * y;
+
+        uint64_t accumulator = 0;
+        int accumulated_bits = 0;
+
+        for (uint32_t x = 0; x < plane_width; x++) {
+          uint32_t sample;
+
+          if (bpp <= 8) {
+            sample = row[x];
+          }
+          else if (bpp <= 16) {
+            sample = reinterpret_cast<const uint16_t*>(row)[x];
+          }
+          else {
+            sample = reinterpret_cast<const uint32_t*>(row)[x];
+          }
+
+          accumulator = (accumulator << bpp) | sample;
+          accumulated_bits += bpp;
+
+          while (accumulated_bits >= 8) {
+            accumulated_bits -= 8;
+            data[out_pos++] = static_cast<uint8_t>(accumulator >> accumulated_bits);
+            accumulator &= (uint64_t{1} << accumulated_bits) - 1;
+          }
+        }
+
+        // Flush partial byte at row end (pad with zeros in LSBs)
+        if (accumulated_bits > 0) {
+          data[out_pos++] = static_cast<uint8_t>(accumulator << (8 - accumulated_bits));
+        }
+      }
+    }
+  }
+
+  return data;
+}
diff --git a/libheif/codecs/uncompressed/unc_encoder_component_interleave.h b/libheif/codecs/uncompressed/unc_encoder_component_interleave.h
new file mode 100644
index 0000000000..c53222920c
--- /dev/null
+++ b/libheif/codecs/uncompressed/unc_encoder_component_interleave.h
@@ -0,0 +1,67 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2026 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_UNC_ENCODER_COMPONENT_INTERLEAVE_H
+#define LIBHEIF_UNC_ENCODER_COMPONENT_INTERLEAVE_H
+
+#include "unc_encoder.h"
+#include "unc_types.h"
+
+#include <memory>
+#include <vector>
+
+class unc_encoder_component_interleave : public unc_encoder
+{
+public:
+  unc_encoder_component_interleave(const std::shared_ptr<const HeifPixelImage>& image,
+                            const heif_encoding_options& options);
+
+  uint64_t compute_tile_data_size_bytes(uint32_t tile_width, uint32_t tile_height) const override;
+
+  [[nodiscard]] std::vector<uint8_t> encode_tile(const std::shared_ptr<const HeifPixelImage>& image) const override;
+
+private:
+  struct channel_component
+  {
+    uint32_t component_idx;
+    heif_channel channel;
+    heif_uncompressed_component_type component_type;
+    heif_uncompressed_component_format component_format;
+    uint8_t bpp;
+    bool byte_aligned;
+  };
+
+  std::vector<channel_component> m_components;
+};
+
+
+class unc_encoder_factory_component_interleave : public unc_encoder_factory
+{
+public:
+
+private:
+  [[nodiscard]] bool can_encode(const std::shared_ptr<const HeifPixelImage>& image,
+                                const heif_encoding_options& options) const override;
+
+  std::unique_ptr<const unc_encoder> create(const std::shared_ptr<const HeifPixelImage>& image,
+                                            const heif_encoding_options& options) const override;
+};
+
+#endif //LIBHEIF_UNC_ENCODER_COMPONENT_INTERLEAVE_H
diff --git a/libheif/codecs/uncompressed/unc_encoder_rgb_block_pixel_interleave.cc b/libheif/codecs/uncompressed/unc_encoder_rgb_block_pixel_interleave.cc
new file mode 100644
index 0000000000..80b18c8934
--- /dev/null
+++ b/libheif/codecs/uncompressed/unc_encoder_rgb_block_pixel_interleave.cc
@@ -0,0 +1,123 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2026 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "unc_encoder_rgb_block_pixel_interleave.h"
+
+#include "pixelimage.h"
+#include "unc_boxes.h"
+#include "unc_types.h"
+
+
+bool unc_encoder_factory_rgb_block_pixel_interleave::can_encode(const std::shared_ptr<const HeifPixelImage>& image,
+                                                               const heif_encoding_options& options) const
+{
+  if (image->get_colorspace() != heif_colorspace_RGB) {
+    return false;
+  }
+
+  switch (image->get_chroma_format()) {
+    case heif_chroma_interleaved_RRGGBB_LE:
+    case heif_chroma_interleaved_RRGGBB_BE:
+      break;
+    default:
+      return false;
+  }
+
+  if (image->get_bits_per_pixel(heif_channel_interleaved) >= 14) {
+    return false;
+  }
+
+  return true;
+}
+
+
+std::unique_ptr<const unc_encoder> unc_encoder_factory_rgb_block_pixel_interleave::create(const std::shared_ptr<const HeifPixelImage>& image,
+                                                                                         const heif_encoding_options& options) const
+{
+  return std::make_unique<unc_encoder_rgb_block_pixel_interleave>(image, options);
+}
+
+
+unc_encoder_rgb_block_pixel_interleave::unc_encoder_rgb_block_pixel_interleave(const std::shared_ptr<const HeifPixelImage>& image,
+                                                                             const heif_encoding_options& options)
+    : unc_encoder(image)
+{
+  auto cmpd_idx = image->get_component_cmpd_indices_interleaved();
+  assert(cmpd_idx.size() == 3);
+
+  uint8_t bpp = image->get_bits_per_pixel(heif_channel_interleaved);
+
+  uint8_t nBits = static_cast<uint8_t>(3 * bpp);
+  m_bytes_per_pixel = static_cast<uint8_t>((nBits + 7) / 8);
+
+  m_uncC->set_interleave_type(interleave_mode_pixel);
+  m_uncC->set_pixel_size(m_bytes_per_pixel);
+  m_uncC->set_block_size(m_bytes_per_pixel);
+  m_uncC->set_sampling_type(sampling_mode_no_subsampling);
+  m_uncC->set_block_little_endian(true);
+
+  m_uncC->add_component({cmpd_idx[0], bpp, component_format_unsigned, 0});
+  m_uncC->add_component({cmpd_idx[1], bpp, component_format_unsigned, 0});
+  m_uncC->add_component({cmpd_idx[2], bpp, component_format_unsigned, 0});
+}
+
+
+uint64_t unc_encoder_rgb_block_pixel_interleave::compute_tile_data_size_bytes(uint32_t tile_width, uint32_t tile_height) const
+{
+  return tile_width * tile_height * m_bytes_per_pixel;
+}
+
+
+std::vector<uint8_t> unc_encoder_rgb_block_pixel_interleave::encode_tile(const std::shared_ptr<const HeifPixelImage>& src_image) const
+{
+  std::vector<uint8_t> data;
+
+  uint8_t bpp = src_image->get_bits_per_pixel(heif_channel_interleaved);
+
+  size_t src_stride;
+  const auto* src_data = reinterpret_cast<const uint16_t*>(src_image->get_plane(heif_channel_interleaved, &src_stride));
+  src_stride /= 2;
+
+  uint64_t out_size = static_cast<uint64_t>(src_image->get_height()) * src_image->get_width() * m_bytes_per_pixel;
+  data.resize(out_size);
+
+  uint8_t* p = data.data();
+
+  for (uint32_t y = 0; y < src_image->get_height(); y++) {
+    for (uint32_t x = 0; x < src_image->get_width(); x++) {
+      uint16_t r = src_data[src_stride * y + 3 * x + 0];
+      uint16_t g = src_data[src_stride * y + 3 * x + 1];
+      uint16_t b = src_data[src_stride * y + 3 * x + 2];
+
+      uint64_t combined_pixel = (static_cast<uint64_t>(r) << (2 * bpp)) | (static_cast<uint64_t>(g) << bpp) | b;
+
+      *p++ = static_cast<uint8_t>(combined_pixel & 0xFF);
+      *p++ = static_cast<uint8_t>((combined_pixel >> 8) & 0xFF);
+      *p++ = static_cast<uint8_t>((combined_pixel >> 16) & 0xFF);
+      *p++ = static_cast<uint8_t>((combined_pixel >> 24) & 0xFF);
+
+      if (m_bytes_per_pixel > 4) {
+        *p++ = static_cast<uint8_t>((combined_pixel >> 32) & 0xFF);
+      }
+    }
+  }
+
+  return data;
+}
diff --git a/libheif/codecs/uncompressed/unc_encoder_rgb_block_pixel_interleave.h b/libheif/codecs/uncompressed/unc_encoder_rgb_block_pixel_interleave.h
new file mode 100644
index 0000000000..085c9f3d5e
--- /dev/null
+++ b/libheif/codecs/uncompressed/unc_encoder_rgb_block_pixel_interleave.h
@@ -0,0 +1,56 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2026 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_UNC_ENCODER_RGB_BLOCK_PIXEL_INTERLEAVE_H
+#define LIBHEIF_UNC_ENCODER_RGB_BLOCK_PIXEL_INTERLEAVE_H
+
+#include "unc_encoder.h"
+
+#include <memory>
+#include <vector>
+
+class unc_encoder_rgb_block_pixel_interleave : public unc_encoder
+{
+public:
+  unc_encoder_rgb_block_pixel_interleave(const std::shared_ptr<const HeifPixelImage>& image,
+                                        const heif_encoding_options& options);
+
+  uint64_t compute_tile_data_size_bytes(uint32_t tile_width, uint32_t tile_height) const override;
+
+  [[nodiscard]] std::vector<uint8_t> encode_tile(const std::shared_ptr<const HeifPixelImage>& image) const override;
+
+private:
+  uint8_t m_bytes_per_pixel = 0;
+};
+
+
+class unc_encoder_factory_rgb_block_pixel_interleave : public unc_encoder_factory
+{
+public:
+
+private:
+  [[nodiscard]] bool can_encode(const std::shared_ptr<const HeifPixelImage>& image,
+                                const heif_encoding_options& options) const override;
+
+  std::unique_ptr<const unc_encoder> create(const std::shared_ptr<const HeifPixelImage>& image,
+                                            const heif_encoding_options& options) const override;
+};
+
+#endif //LIBHEIF_UNC_ENCODER_RGB_BLOCK_PIXEL_INTERLEAVE_H
diff --git a/libheif/codecs/uncompressed/unc_encoder_rgb_bytealign_pixel_interleave.cc b/libheif/codecs/uncompressed/unc_encoder_rgb_bytealign_pixel_interleave.cc
new file mode 100644
index 0000000000..64cf744496
--- /dev/null
+++ b/libheif/codecs/uncompressed/unc_encoder_rgb_bytealign_pixel_interleave.cc
@@ -0,0 +1,136 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2026 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "unc_encoder_rgb_bytealign_pixel_interleave.h"
+
+#include <cstring>
+
+#include "pixelimage.h"
+#include "unc_boxes.h"
+#include "unc_types.h"
+
+
+bool unc_encoder_factory_rgb_bytealign_pixel_interleave::can_encode(const std::shared_ptr<const HeifPixelImage>& image,
+                                            const heif_encoding_options& options) const
+{
+  if (image->get_colorspace() != heif_colorspace_RGB) {
+    return false;
+  }
+
+  switch (image->get_chroma_format()) {
+    case heif_chroma_interleaved_RRGGBB_LE:
+    case heif_chroma_interleaved_RRGGBB_BE:
+    case heif_chroma_interleaved_RRGGBBAA_LE:
+    case heif_chroma_interleaved_RRGGBBAA_BE:
+      break;
+    default:
+      return false;
+  }
+
+  return true;
+}
+
+
+std::unique_ptr<const unc_encoder> unc_encoder_factory_rgb_bytealign_pixel_interleave::create(const std::shared_ptr<const HeifPixelImage>& image,
+                                                                      const heif_encoding_options& options) const
+{
+  return std::make_unique<unc_encoder_rgb_bytealign_pixel_interleave>(image, options);
+}
+
+
+unc_encoder_rgb_bytealign_pixel_interleave::unc_encoder_rgb_bytealign_pixel_interleave(const std::shared_ptr<const HeifPixelImage>& image,
+                                       const heif_encoding_options& options)
+    : unc_encoder(image)
+{
+  auto cmpd_idx = image->get_component_cmpd_indices_interleaved();
+
+  bool save_alpha = image->has_alpha();
+
+  m_bytes_per_pixel = save_alpha ? 8 : 6;
+  assert(cmpd_idx.size() == m_bytes_per_pixel/2);
+
+  bool little_endian = (image->get_chroma_format() == heif_chroma_interleaved_RRGGBB_LE ||
+                        image->get_chroma_format() == heif_chroma_interleaved_RRGGBBAA_LE);
+
+  uint8_t bpp = image->get_bits_per_pixel(heif_channel_interleaved);
+
+  uint8_t component_align_size = 2;
+  if (bpp == 16) {
+    component_align_size = 0;
+  }
+
+  // make sure that we always save as big-endian so that we can read it with out own reader (unc_decoder_pixel_interleave, which only supports big-endian)
+  m_swap_endianess = little_endian;
+
+  m_uncC->set_interleave_type(interleave_mode_pixel);
+  m_uncC->set_sampling_type(sampling_mode_no_subsampling);
+  m_uncC->set_components_little_endian(false); // little_endian);
+  m_uncC->set_pixel_size(m_bytes_per_pixel);
+
+  m_uncC->add_component({cmpd_idx[0], bpp, component_format_unsigned, component_align_size});
+  m_uncC->add_component({cmpd_idx[1], bpp, component_format_unsigned, component_align_size});
+  m_uncC->add_component({cmpd_idx[2], bpp, component_format_unsigned, component_align_size});
+  if (save_alpha) {
+    m_uncC->add_component({cmpd_idx[3], bpp, component_format_unsigned, component_align_size});
+  }
+}
+
+
+uint64_t unc_encoder_rgb_bytealign_pixel_interleave::compute_tile_data_size_bytes(uint32_t tile_width, uint32_t tile_height) const
+{
+  return tile_width * tile_height * m_bytes_per_pixel;
+}
+
+
+void *memcpy_swap16(uint8_t *dst, const uint8_t *src, size_t n)
+{
+  assert(n % 2 == 0);
+
+  /* swap pairs */
+  for (size_t i = 0; i + 1 < n; i += 2) {
+    dst[i] = src[i + 1];
+    dst[i + 1] = src[i];
+  }
+
+  return dst;
+}
+
+
+std::vector<uint8_t> unc_encoder_rgb_bytealign_pixel_interleave::encode_tile(const std::shared_ptr<const HeifPixelImage>& src_image) const
+{
+  std::vector<uint8_t> data;
+
+  size_t src_stride;
+  const uint8_t* src_data = src_image->get_plane(heif_channel_interleaved, &src_stride);
+
+  uint64_t out_size = static_cast<uint64_t>(src_image->get_height()) * src_image->get_width() * m_bytes_per_pixel;
+  data.resize(out_size);
+
+  for (uint32_t y = 0; y < src_image->get_height(); y++) {
+    if (m_swap_endianess) {
+      memcpy_swap16(data.data() + y * src_image->get_width() * m_bytes_per_pixel, src_data + src_stride * y, src_image->get_width() * m_bytes_per_pixel);
+    }
+    else {
+      memcpy(data.data() + y * src_image->get_width() * m_bytes_per_pixel, src_data + src_stride * y, src_image->get_width() * m_bytes_per_pixel);
+    }
+  }
+
+  return data;
+}
diff --git a/libheif/codecs/uncompressed/unc_encoder_rgb_bytealign_pixel_interleave.h b/libheif/codecs/uncompressed/unc_encoder_rgb_bytealign_pixel_interleave.h
new file mode 100644
index 0000000000..7ada28fd3f
--- /dev/null
+++ b/libheif/codecs/uncompressed/unc_encoder_rgb_bytealign_pixel_interleave.h
@@ -0,0 +1,58 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2026 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_UNC_ENCODER_RGB_BYTEALIGN_PIXEL_INTERLEAVE_H
+#define LIBHEIF_UNC_ENCODER_RGB_BYTEALIGN_PIXEL_INTERLEAVE_H
+
+#include "unc_encoder.h"
+
+#include <memory>
+#include <vector>
+
+class unc_encoder_rgb_bytealign_pixel_interleave : public unc_encoder
+{
+public:
+  unc_encoder_rgb_bytealign_pixel_interleave(const std::shared_ptr<const HeifPixelImage>& image,
+                                             const heif_encoding_options& options);
+
+  uint64_t compute_tile_data_size_bytes(uint32_t tile_width, uint32_t tile_height) const override;
+
+  [[nodiscard]] std::vector<uint8_t> encode_tile(const std::shared_ptr<const HeifPixelImage>& image) const override;
+
+private:
+  uint8_t m_bytes_per_pixel = 0;
+  bool m_swap_endianess = false;
+};
+
+
+class unc_encoder_factory_rgb_bytealign_pixel_interleave : public unc_encoder_factory
+{
+public:
+
+private:
+  [[nodiscard]] bool can_encode(const std::shared_ptr<const HeifPixelImage>& image,
+                                const heif_encoding_options& options) const override;
+
+  std::unique_ptr<const unc_encoder> create(const std::shared_ptr<const HeifPixelImage>& image,
+                                            const heif_encoding_options& options) const override;
+};
+
+
+#endif //LIBHEIF_UNC_ENCODER_RGB_BYTEALIGN_PIXEL_INTERLEAVE_H
diff --git a/libheif/codecs/uncompressed/unc_encoder_rgb_pixel_interleave.cc b/libheif/codecs/uncompressed/unc_encoder_rgb_pixel_interleave.cc
new file mode 100644
index 0000000000..bfac3a46db
--- /dev/null
+++ b/libheif/codecs/uncompressed/unc_encoder_rgb_pixel_interleave.cc
@@ -0,0 +1,113 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2026 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "unc_encoder_rgb_pixel_interleave.h"
+
+#include <cstring>
+
+#include "pixelimage.h"
+#include "unc_boxes.h"
+#include "unc_types.h"
+
+
+bool unc_encoder_factory_rgb_pixel_interleave::can_encode(const std::shared_ptr<const HeifPixelImage>& image,
+                                               const heif_encoding_options& options) const
+{
+  if (image->get_colorspace() != heif_colorspace_RGB) {
+    return false;
+  }
+
+  switch (image->get_chroma_format()) {
+    case heif_chroma_interleaved_RGB:
+    case heif_chroma_interleaved_RGBA:
+      return true;
+    default:
+      return false;
+  }
+}
+
+
+std::unique_ptr<const unc_encoder> unc_encoder_factory_rgb_pixel_interleave::create(const std::shared_ptr<const HeifPixelImage>& image,
+                                                                         const heif_encoding_options& options) const
+{
+  return std::make_unique<unc_encoder_rgb_pixel_interleave>(image, options);
+}
+
+
+unc_encoder_rgb_pixel_interleave::unc_encoder_rgb_pixel_interleave(const std::shared_ptr<const HeifPixelImage>& image,
+                                             const heif_encoding_options& options)
+    : unc_encoder(image)
+{
+  auto cmpd_idx = image->get_component_cmpd_indices_interleaved();
+  bool save_alpha = image->has_alpha();
+
+  m_bytes_per_pixel = save_alpha ? 4 : 3;
+  assert(cmpd_idx.size() == m_bytes_per_pixel);
+
+  uint8_t bpp = image->get_bits_per_pixel(heif_channel_interleaved);
+
+  if (bpp == 8) {
+    if (save_alpha) {
+      m_uncC->set_profile(fourcc("rgba"));
+    }
+    else {
+      m_uncC->set_profile(fourcc("rgb3"));
+    }
+  }
+
+  uint8_t component_align_size = 0;
+  if (bpp != 8) {
+    component_align_size = 1;
+  }
+
+  m_uncC->set_interleave_type(interleave_mode_pixel);
+  m_uncC->set_sampling_type(sampling_mode_no_subsampling);
+  m_uncC->add_component({cmpd_idx[0], bpp, component_format_unsigned, component_align_size});
+  m_uncC->add_component({cmpd_idx[1], bpp, component_format_unsigned, component_align_size});
+  m_uncC->add_component({cmpd_idx[2], bpp, component_format_unsigned, component_align_size});
+  if (save_alpha) {
+    m_uncC->add_component({cmpd_idx[3], bpp, component_format_unsigned, component_align_size});
+  }
+}
+
+
+
+uint64_t unc_encoder_rgb_pixel_interleave::compute_tile_data_size_bytes(uint32_t tile_width, uint32_t tile_height) const
+{
+  return tile_width * tile_height * m_bytes_per_pixel;
+}
+
+
+std::vector<uint8_t> unc_encoder_rgb_pixel_interleave::encode_tile(const std::shared_ptr<const HeifPixelImage>& src_image) const
+{
+  std::vector<uint8_t> data;
+
+  size_t src_stride;
+  const uint8_t* src_data = src_image->get_plane(heif_channel_interleaved, &src_stride);
+
+  uint64_t out_size = static_cast<uint64_t>(src_image->get_height()) * src_image->get_width() * m_bytes_per_pixel;
+  data.resize(out_size);
+
+  for (uint32_t y = 0; y < src_image->get_height(); y++) {
+    memcpy(data.data() + y * src_image->get_width() * m_bytes_per_pixel, src_data + src_stride * y, src_image->get_width() * m_bytes_per_pixel);
+  }
+
+  return data;
+}
diff --git a/libheif/codecs/uncompressed/unc_encoder_rgb_pixel_interleave.h b/libheif/codecs/uncompressed/unc_encoder_rgb_pixel_interleave.h
new file mode 100644
index 0000000000..e96ba4af23
--- /dev/null
+++ b/libheif/codecs/uncompressed/unc_encoder_rgb_pixel_interleave.h
@@ -0,0 +1,56 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2026 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_UNC_ENCODER_RGB_PIXEL_INTERLEAVE_H
+#define LIBHEIF_UNC_ENCODER_RGB_PIXEL_INTERLEAVE_H
+
+#include "unc_encoder.h"
+
+#include <memory>
+#include <vector>
+
+class unc_encoder_rgb_pixel_interleave : public unc_encoder
+{
+public:
+  unc_encoder_rgb_pixel_interleave(const std::shared_ptr<const HeifPixelImage>& image,
+                                   const heif_encoding_options& options);
+
+  uint64_t compute_tile_data_size_bytes(uint32_t tile_width, uint32_t tile_height) const override;
+
+  [[nodiscard]] std::vector<uint8_t> encode_tile(const std::shared_ptr<const HeifPixelImage>& image) const override;
+
+private:
+  uint8_t m_bytes_per_pixel = 0;
+};
+
+
+class unc_encoder_factory_rgb_pixel_interleave : public unc_encoder_factory
+{
+public:
+
+private:
+  [[nodiscard]] bool can_encode(const std::shared_ptr<const HeifPixelImage>& image,
+                                const heif_encoding_options& options) const override;
+
+  std::unique_ptr<const unc_encoder> create(const std::shared_ptr<const HeifPixelImage>& image,
+                                            const heif_encoding_options& options) const override;
+};
+
+#endif //LIBHEIF_UNC_ENCODER_RGB_PIXEL_INTERLEAVE_H
diff --git a/libheif/codecs/uncompressed/unc_types.h b/libheif/codecs/uncompressed/unc_types.h
new file mode 100644
index 0000000000..7dfb16c011
--- /dev/null
+++ b/libheif/codecs/uncompressed/unc_types.h
@@ -0,0 +1,194 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef LIBHEIF_UNC_TYPES_H
+#define LIBHEIF_UNC_TYPES_H
+
+#include <cstdint>
+#include <libheif/heif_uncompressed.h>
+
+// Update this when adding new values to heif_uncompressed_component_type.
+#define heif_uncompressed_component_type_max_valid heif_uncompressed_component_type_key_black
+
+/**
+ * HEIF uncompressed component format.
+ *
+ * The binary representation of a component is determined by the
+ * {@code component_bit_depth} and the component format.
+ *
+ * See ISO/IEC 23001-17 Table 2.
+ */
+enum heif_uncompressed_component_format : uint8_t
+{
+  /**
+   * Unsigned integer.
+   *
+   * The component value is an unsigned integer.
+   */
+  component_format_unsigned = 0,
+
+  /**
+   * Floating point value.
+   *
+   * The component value is an IEEE 754 binary float.
+   * Valid bit depths for this format are:
+   * <ul>
+   *  <li>16 (half precision)
+   *  <li>32 (single precision)
+   *  <li>64 (double precision)
+   *  <li>128 (quadruple precision)
+   *  <li>256 (octuple precision)
+   * </ul>
+   */
+  component_format_float = 1,
+
+  /**
+   * Complex value.
+   *
+   * The component value is two IEEE 754 binary float numbers
+   * where the first part is the real part of the value and
+   * the second part is the imaginary part of the value.
+   *
+   * Each part has the same number of bits, which is half
+   * the component bit depth value. Valid bit depths for this
+   * format are:
+   * <ul>
+   *  <li>32 - each part is 16 bits (half precision)
+   *  <li>64 - each part is 32 bits (single precision)
+   *  <li>128 - each part is 64 bits (double precision)
+   *  <li>256 - each part is 128 bits (quadruple precision)
+   * </ul>
+   */
+  component_format_complex = 2,
+
+  /**
+   * Signed integer.
+   *
+   * The component value is a two's complement signed integer.
+   */
+  component_format_signed = 3,
+
+  /**
+   * Maximum valid component format identifier.
+   */
+  component_format_max_valid = component_format_signed
+};
+
+
+/**
+ * HEIF uncompressed sampling mode.
+ *
+ * All components in a frame use the same dimensions, or use pre-defined
+ * sampling modes. This is only valid for YCbCr formats.
+ *
+ * See ISO/IEC 23001-17 Table 3.
+ */
+enum heif_uncompressed_sampling_mode
+{
+  /**
+   * No subsampling.
+   */
+  sampling_mode_no_subsampling = 0,
+
+  /**
+   * YCbCr 4:2:2 subsampling.
+   *
+   * Y dimensions are the same as the dimensions of the frame.
+   * Cb (U) and Cr (V) have the same height as the frame, but only have
+   * half the width.
+   */
+  sampling_mode_422 = 1,
+
+  /**
+   * YCbCr 4:2:0 subsampling.
+   *
+   * Y dimensions are the same as the dimensions of the frame.
+   * Cb (U) and Cr (V) have the half the height and half the width of
+   * the frame.
+   */
+  sampling_mode_420 = 2,
+
+  /**
+   * YCbCr 4:1:1 subsampling.
+   *
+   * Y dimensions are the same as the dimensions of the frame.
+   * Cb (U) and Cr (V) have the same height as the frame, but only have
+   * one quarter the width.
+   */
+  sampling_mode_411 = 3,
+
+  /**
+   * Maximum valid sampling mode identifier.
+   */
+  sampling_mode_max_valid = sampling_mode_411
+};
+
+
+/**
+ * HEIF uncompressed interleaving mode.
+ *
+ * See ISO/IEC 23001-17 Table 4.
+ */
+enum heif_uncompressed_interleave_mode
+{
+  /**
+   * Component interleaving.
+   */
+  interleave_mode_component = 0,
+
+  /**
+   * Pixel interleaving.
+   */
+  interleave_mode_pixel = 1,
+
+  /**
+   * Mixed interleaving.
+   *
+   * This is associated with YCbCr images, with subsampling
+   * and "semi-planar" interleave.
+   */
+  interleave_mode_mixed = 2,
+
+  /**
+   * Row interleaving.
+   */
+  interleave_mode_row = 3,
+
+  /**
+   * Tile-component interleaving.
+   */
+  interleave_mode_tile_component = 4,
+
+  /**
+   * Multi-Y pixel interleaving.
+   *
+   * This is only valid with 4:2:2 and 4:1:1 subsampling.
+  */
+  interleave_mode_multi_y = 5,
+
+  /**
+   * Maximum valid interleave mode identifier.
+   */
+  interleave_mode_max_valid = interleave_mode_multi_y
+};
+
+
+#endif //LIBHEIF_UNC_TYPES_H
diff --git a/libheif/codecs/vvc_boxes.cc b/libheif/codecs/vvc_boxes.cc
new file mode 100644
index 0000000000..44b6b5ec6b
--- /dev/null
+++ b/libheif/codecs/vvc_boxes.cc
@@ -0,0 +1,539 @@
+/*
+ * HEIF VVC codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "vvc_boxes.h"
+#include "hevc_boxes.h"
+#include "file.h"
+#include <cstring>
+#include <string>
+#include <cassert>
+#include <iomanip>
+#include <utility>
+#include "api_structs.h"
+
+
+Error Box_vvcC::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  parse_full_box_header(range);
+
+  uint8_t byte;
+
+  auto& c = m_configuration; // abbreviation
+
+  byte = range.read8();
+
+  c.LengthSizeMinusOne = (byte >> 1) & 3;
+  c.ptl_present_flag = !!(byte & 1);
+
+  if (c.ptl_present_flag) {
+    uint16_t word = range.read16();
+    c.ols_idx = (word >> 7) & 0x1FF;
+    c.num_sublayers = (word >> 4) & 0x07;
+    c.constant_frame_rate = (word >> 2) & 0x03;
+    c.chroma_format_idc = word & 0x03;
+
+    byte = range.read8();
+    c.bit_depth_minus8 = (byte >> 5) & 0x07;
+
+    // VvcPTLRecord
+
+    auto& ptl = c.native_ptl; // abbreviation
+
+    byte = range.read8();
+    ptl.num_bytes_constraint_info = byte & 0x3f;
+
+    if (ptl.num_bytes_constraint_info == 0) {
+      return {heif_error_Invalid_input,
+              heif_suberror_Invalid_parameter_value,
+              "vvcC with num_bytes_constraint_info==0 is not allowed."};
+    }
+
+    byte = range.read8();
+    ptl.general_profile_idc = (byte >> 1) & 0x7f;
+    ptl.general_tier_flag = (byte & 1);
+
+    ptl.general_level_idc = range.read8();
+
+    for (int i = 0; i < ptl.num_bytes_constraint_info; i++) {
+      byte = range.read8();
+      if (i == 0) {
+        ptl.ptl_frame_only_constraint_flag = (byte >> 7) & 1;
+        ptl.ptl_multi_layer_enabled_flag = (byte >> 6) & 1;
+        byte &= 0x3f;
+      }
+
+      ptl.general_constraint_info.push_back(byte);
+    }
+
+    if (c.num_sublayers > 1) {
+      ptl.ptl_sublayer_level_present_flag.resize(c.num_sublayers - 1);
+
+      byte = range.read8();
+      uint8_t mask = 0x80;
+
+      for (int i = c.num_sublayers - 2; i >= 0; i--) {
+        ptl.ptl_sublayer_level_present_flag[i] = !!(byte & mask);
+        mask >>= 1;
+      }
+    }
+
+    ptl.sublayer_level_idc.resize(c.num_sublayers);
+    if (c.num_sublayers > 0) {
+      ptl.sublayer_level_idc[c.num_sublayers - 1] = ptl.general_level_idc;
+
+      for (int i = c.num_sublayers - 2; i >= 0; i--) {
+        if (ptl.ptl_sublayer_level_present_flag[i]) {
+          ptl.sublayer_level_idc[i] = range.read8();
+        }
+        else {
+          ptl.sublayer_level_idc[i] = ptl.sublayer_level_idc[i + 1];
+        }
+      }
+    }
+
+    uint8_t ptl_num_sub_profiles = range.read8();
+    for (int j=0; j < ptl_num_sub_profiles; j++) {
+      ptl.general_sub_profile_idc.push_back(range.read32());
+    }
+
+
+    // remaining fields
+
+    c.max_picture_width = range.read16();
+    c.max_picture_height = range.read16();
+    c.avg_frame_rate = range.read16();
+  }
+  else {
+    return Error{
+      heif_error_Unsupported_feature,
+      heif_suberror_Unspecified,
+      "Reading vvcC configuration with ptl_present_flag=0 is not supported."
+    };
+  }
+
+  // read NAL arrays
+
+  int nArrays = range.read8();
+
+  for (int i = 0; i < nArrays && !range.error(); i++) {
+    byte = range.read8();
+
+    NalArray array;
+
+    array.m_array_completeness = (byte >> 7) & 1;
+    array.m_NAL_unit_type = (byte & 0x3F);
+
+    int nUnits = range.read16();
+    for (int u = 0; u < nUnits && !range.error(); u++) {
+
+      std::vector<uint8_t> nal_unit;
+      int size = range.read16();
+      if (!size) {
+        // Ignore empty NAL units.
+        continue;
+      }
+
+      if (range.prepare_read(size)) {
+        nal_unit.resize(size);
+        bool success = range.get_istream()->read((char*) nal_unit.data(), size);
+        if (!success) {
+          return Error{heif_error_Invalid_input, heif_suberror_End_of_data, "error while reading hvcC box"};
+        }
+      }
+
+      array.m_nal_units.push_back(std::move(nal_unit));
+    }
+
+    m_nal_array.push_back(std::move(array));
+  }
+
+  return range.get_error();
+}
+
+
+bool Box_vvcC::get_headers(std::vector<uint8_t>* dest) const
+{
+  for (const auto& nal_array : m_nal_array) {
+    for (const auto& nal : nal_array.m_nal_units) {
+      assert(nal.size() <= 0xFFFF);
+      auto size = static_cast<uint16_t>(nal.size());
+
+      dest->push_back(0);
+      dest->push_back(0);
+      dest->push_back(static_cast<uint8_t>(size >> 8));
+      dest->push_back(static_cast<uint8_t>(size & 0xFF));
+
+      dest->insert(dest->end(), nal.begin(), nal.end());
+    }
+  }
+
+  return true;
+}
+
+
+void Box_vvcC::append_nal_data(const std::vector<uint8_t>& nal)
+{
+  assert(nal.size()>=2);
+  uint8_t nal_type = (nal[1] >> 3) & 0x1F;
+
+  // insert into existing array if it exists
+
+  for (auto& nalarray : m_nal_array) {
+    if (nalarray.m_NAL_unit_type == nal_type) {
+      nalarray.m_nal_units.push_back(nal);
+      return;
+    }
+  }
+
+  // generate new NAL array
+
+  NalArray array;
+  array.m_array_completeness = true;
+  array.m_NAL_unit_type = uint8_t((nal[1] >> 3) & 0x1F);
+  array.m_nal_units.push_back(nal);
+
+  m_nal_array.push_back(array);
+}
+
+
+void Box_vvcC::append_nal_data(const uint8_t* data, size_t size)
+{
+  std::vector<uint8_t> nal;
+  nal.resize(size);
+  memcpy(nal.data(), data, size);
+
+  append_nal_data(nal);
+}
+
+
+Error Box_vvcC::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  const auto& c = m_configuration;
+
+  uint8_t byte;
+
+  byte = uint8_t(0xF8 | (c.LengthSizeMinusOne<<1) | (c.ptl_present_flag ? 1 : 0));
+  writer.write8(byte);
+
+  if (c.ptl_present_flag) {
+    assert(c.ols_idx <= 0x1FF);
+    assert(c.num_sublayers <= 7);
+    assert(c.constant_frame_rate <= 3);
+    assert(c.chroma_format_idc <= 3);
+    assert(c.bit_depth_minus8 <= 7);
+
+    auto word = uint16_t((c.ols_idx << 7) | (c.num_sublayers << 4) | (c.constant_frame_rate << 2) | (c.chroma_format_idc));
+    writer.write16(word);
+
+    writer.write8(uint8_t((c.bit_depth_minus8<<5) | 0x1F));
+
+    const auto& ptl = c.native_ptl;
+
+    assert(ptl.general_profile_idc <= 0x7F);
+
+    writer.write8(ptl.num_bytes_constraint_info & 0x3f);
+    writer.write8(static_cast<uint8_t>((ptl.general_profile_idc<<1) | ptl.general_tier_flag));
+    writer.write8(ptl.general_level_idc);
+
+    for (int i=0;i<ptl.num_bytes_constraint_info;i++) {
+      if (i==0) {
+        assert(ptl.ptl_frame_only_constraint_flag <= 1);
+        assert(ptl.ptl_multi_layer_enabled_flag <= 1);
+        assert(ptl.general_constraint_info[0] <= 0x3F);
+        byte = static_cast<uint8_t>((ptl.ptl_frame_only_constraint_flag << 7) | (ptl.ptl_multi_layer_enabled_flag << 6) | ptl.general_constraint_info[0]);
+      }
+      else {
+        byte = ptl.general_constraint_info[i];
+      }
+
+      writer.write8(byte);
+    }
+
+    byte = 0;
+    if (c.num_sublayers > 1) {
+      uint8_t mask = 0x80;
+
+      for (int i = c.num_sublayers - 2; i >= 0; i--) {
+        if (ptl.ptl_sublayer_level_present_flag[i]) {
+          byte |= mask;
+        }
+        mask >>= 1;
+      }
+
+      writer.write8(byte);
+    }
+
+    for (int i=c.num_sublayers-2; i >= 0; i--) {
+      if (ptl.ptl_sublayer_level_present_flag[i]) {
+        writer.write8(ptl.sublayer_level_idc[i]);
+      }
+    }
+
+    assert(ptl.general_sub_profile_idc.size() <= 0xFF);
+    byte = static_cast<uint8_t>(ptl.general_sub_profile_idc.size());
+    writer.write8(byte);
+
+    for (int j=0; j < byte; j++) {
+      writer.write32(ptl.general_sub_profile_idc[j]);
+    }
+
+    writer.write16(c.max_picture_width);
+    writer.write16(c.max_picture_height);
+    writer.write16(c.avg_frame_rate);
+  }
+
+  // --- write configuration NALs
+
+  if (m_nal_array.size() > 255) {
+    return {heif_error_Encoding_error, heif_suberror_Unspecified, "Too many VVC NAL arrays."};
+  }
+
+  writer.write8((uint8_t)m_nal_array.size());
+  for (const NalArray& nal_array : m_nal_array) {
+    uint8_t v2 = (nal_array.m_array_completeness ? 0x80 : 0);
+    v2 |= nal_array.m_NAL_unit_type;
+    writer.write8(v2);
+
+    if (nal_array.m_nal_units.size() > 0xFFFF) {
+      return {heif_error_Encoding_error, heif_suberror_Unspecified, "Too many VVC NAL units."};
+    }
+
+    writer.write16((uint16_t)nal_array.m_nal_units.size());
+    for (const auto& nal : nal_array.m_nal_units) {
+
+      if (nal.size() > 0xFFFF) {
+        return {heif_error_Encoding_error, heif_suberror_Unspecified, "VVC NAL too large."};
+      }
+
+      writer.write16((uint16_t)nal.size());
+      writer.write(nal);
+    }
+  }
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+
+static const char* vvc_chroma_names[4] = {"mono", "4:2:0", "4:2:2", "4:4:4"};
+
+const char* NAL_name(uint8_t nal_type)
+{
+  switch (nal_type) {
+    case 12: return "OPI";
+    case 13: return "DCI";
+    case 14: return "VPS";
+    case 15: return "SPS";
+    case 16: return "PPS";
+    case 17: return "PREFIX_APS";
+    case 18: return "SUFFIX_APS";
+    case 19: return "PH";
+    default: return "?";
+  }
+}
+
+
+std::string Box_vvcC::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << FullBox::dump(indent);
+
+  const auto& c = m_configuration; // abbreviation
+
+  sstr << indent << "NAL length size: " << ((int) c.LengthSizeMinusOne + 1) << "\n";
+  if (c.ptl_present_flag) {
+    const auto& ptl = c.native_ptl;
+    sstr << indent << "ols-index: " << c.ols_idx << "\n"
+         << indent << "num sublayers: " << ((int) c.num_sublayers) << "\n"
+         << indent << "constant frame rate: " << (c.constant_frame_rate == 1 ? "constant" : (c.constant_frame_rate == 2 ? "multi-layer" : "unknown")) << "\n"
+         << indent << "chroma-format: " << vvc_chroma_names[c.chroma_format_idc] << "\n"
+         << indent << "bit-depth: " << ((int) c.bit_depth_minus8 + 8) << "\n"
+         << indent << "max picture width:  " << c.max_picture_width << "\n"
+         << indent << "max picture height: " << c.max_picture_height << "\n";
+
+    sstr << indent << "general profile: " << ((int)ptl.general_profile_idc) << "\n"
+         << indent << "tier flag: " << ((int)ptl.general_tier_flag) << "\n"
+         << indent << "general level:" << ((int)ptl.general_level_idc) << "\n"
+         << indent << "ptl frame only constraint flag: " << ((int)ptl.ptl_frame_only_constraint_flag) << "\n"
+         << indent << "ptl multi layer enabled flag: " << ((int)ptl.ptl_multi_layer_enabled_flag) << "\n";
+  }
+
+
+  sstr << indent << "num of arrays: " << m_nal_array.size() << "\n";
+
+  sstr << indent << "config NALs:\n";
+  for (const auto& nal_array : m_nal_array) {
+    indent++;
+    sstr << indent << "NAL type: " << ((int)nal_array.m_NAL_unit_type) << " (" << NAL_name(nal_array.m_NAL_unit_type) << ")\n";
+    sstr << indent << "array completeness: " << ((int)nal_array.m_array_completeness) << "\n";
+
+    for (const auto& nal : nal_array.m_nal_units) {
+      indent++;
+      std::string ind = indent.get_string();
+      sstr << write_raw_data_as_hex(nal.data(), nal.size(), ind, ind);
+      indent--;
+    }
+    indent--;
+  }
+
+  return sstr.str();
+}
+
+
+Error parse_sps_for_vvcC_configuration(const uint8_t* sps, size_t size,
+                                       Box_vvcC::configuration* config,
+                                       int* width, int* height)
+{
+  // remove start-code emulation bytes from SPS header stream
+
+  std::vector<uint8_t> sps_no_emul = remove_start_code_emulation(sps, size);
+
+  sps = sps_no_emul.data();
+  size = sps_no_emul.size();
+
+  BitReader reader(sps, (int) size);
+
+  // skip NAL header
+  reader.skip_bits(2 * 8);
+
+  // skip SPS ID
+  reader.skip_bits(4);
+
+  // skip VPS ID
+  reader.skip_bits(4);
+
+  config->ols_idx = 0;
+  config->num_sublayers = reader.get_bits8(3) + 1;
+  config->chroma_format_idc = reader.get_bits8(2);
+  reader.skip_bits(2);
+
+  bool sps_ptl_dpb_hrd_params_present_flag = reader.get_bits(1);
+  if (sps_ptl_dpb_hrd_params_present_flag) {
+    // profile_tier_level( 1, sps_max_sublayers_minus1 )
+
+    auto& ptl = config->native_ptl;
+
+    if (true /*profileTierPresentFlag*/) {
+      ptl.general_profile_idc = reader.get_bits8(7);
+      ptl.general_tier_flag = reader.get_bits8(1);
+    }
+    ptl.general_level_idc = reader.get_bits8(8);
+    ptl.ptl_frame_only_constraint_flag = reader.get_bits8(1);
+    ptl.ptl_multi_layer_enabled_flag = reader.get_bits8(1);
+
+    if (true /* profileTierPresentFlag*/ ) {
+      // general_constraints_info()
+
+      bool gci_present_flag = reader.get_bits(1);
+      if (gci_present_flag) {
+        assert(false);
+      }
+      else {
+        ptl.num_bytes_constraint_info = 1;
+        ptl.general_constraint_info.push_back(0);
+      }
+
+      reader.skip_to_byte_boundary();
+    }
+
+    ptl.ptl_sublayer_level_present_flag.resize(config->num_sublayers);
+    for (int i = config->num_sublayers-2; i >= 0; i--) {
+      ptl.ptl_sublayer_level_present_flag[i] = reader.get_bits(1);
+    }
+
+    reader.skip_to_byte_boundary();
+
+    ptl.sublayer_level_idc.resize(config->num_sublayers);
+    for (int i = config->num_sublayers-2; i >= 0; i--) {
+      if (ptl.ptl_sublayer_level_present_flag[i]) {
+        ptl.sublayer_level_idc[i] = reader.get_bits8(8);
+      }
+    }
+
+    if (true /*profileTierPresentFlag*/) {
+      int ptl_num_sub_profiles = reader.get_bits(8);
+      ptl.general_sub_profile_idc.resize(ptl_num_sub_profiles);
+
+      for (int i = 0; i < ptl_num_sub_profiles; i++) {
+        ptl.general_sub_profile_idc[i] = reader.get_bits(32);
+      }
+    }
+  }
+
+  reader.skip_bits(1); // sps_gdr_enabled_flag
+  bool sps_ref_pic_resampling_enabled_flag = reader.get_bits(1);
+  if (sps_ref_pic_resampling_enabled_flag) {
+    reader.skip_bits(1); // sps_res_change_in_clvs_allowed_flag
+  }
+
+  int sps_pic_width_max_in_luma_samples;
+  int sps_pic_height_max_in_luma_samples;
+
+  bool success;
+  success = reader.get_uvlc(&sps_pic_width_max_in_luma_samples);
+  (void)success;
+  success = reader.get_uvlc(&sps_pic_height_max_in_luma_samples);
+  (void)success;
+
+  *width = sps_pic_width_max_in_luma_samples;
+  *height = sps_pic_height_max_in_luma_samples;
+
+  if (sps_pic_width_max_in_luma_samples > 0xFFFF ||
+      sps_pic_height_max_in_luma_samples > 0xFFFF) {
+    return {heif_error_Encoding_error,
+            heif_suberror_Invalid_parameter_value,
+            "SPS max picture width or height exceeds maximum (65535)"};
+  }
+
+  config->max_picture_width = static_cast<uint16_t>(sps_pic_width_max_in_luma_samples);
+  config->max_picture_height = static_cast<uint16_t>(sps_pic_height_max_in_luma_samples);
+
+  int sps_conformance_window_flag = reader.get_bits(1);
+  if (sps_conformance_window_flag) {
+    int left,right,top,bottom;
+    reader.get_uvlc(&left);
+    reader.get_uvlc(&right);
+    reader.get_uvlc(&top);
+    reader.get_uvlc(&bottom);
+  }
+
+  bool sps_subpic_info_present_flag = reader.get_bits(1);
+  if (sps_subpic_info_present_flag) {
+    assert(false); // TODO
+  }
+
+  int bitDepth_minus8;
+  success = reader.get_uvlc(&bitDepth_minus8);
+  (void)success;
+
+  if (bitDepth_minus8 > 0xFF - 8) {
+    return {heif_error_Encoding_error, heif_suberror_Unspecified, "VCC bit depth out of range."};
+  }
+
+  config->bit_depth_minus8 = static_cast<uint8_t>(bitDepth_minus8);
+
+  config->constant_frame_rate = 1; // is constant (TODO: where do we get this from)
+
+  return Error::Ok;
+}
+
diff --git a/libheif/codecs/vvc_boxes.h b/libheif/codecs/vvc_boxes.h
new file mode 100644
index 0000000000..fa67d7655e
--- /dev/null
+++ b/libheif/codecs/vvc_boxes.h
@@ -0,0 +1,121 @@
+/*
+ * HEIF VVC codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_VVC_BOXES_H
+#define LIBHEIF_VVC_BOXES_H
+
+#include "box.h"
+#include <string>
+#include <vector>
+#include "image-items/image_item.h"
+#include <memory>
+#include "sequences/seq_boxes.h"
+
+
+class Box_vvcC : public FullBox
+{
+public:
+  Box_vvcC()
+  {
+    set_short_type(fourcc("vvcC"));
+  }
+
+  bool is_essential() const override { return true; }
+
+  struct VvcPTLRecord {
+    uint8_t num_bytes_constraint_info; // 6 bits
+    uint8_t general_profile_idc; // 7 bits
+    uint8_t general_tier_flag; // 1 bit
+    uint8_t general_level_idc; // 8 bits
+    uint8_t ptl_frame_only_constraint_flag; // 1 bit
+    uint8_t ptl_multi_layer_enabled_flag; // 1 bit
+    std::vector<uint8_t> general_constraint_info;
+
+    std::vector<bool> ptl_sublayer_level_present_flag; // TODO: should we save this here or can we simply derive it on the fly?
+
+    std::vector<uint8_t> sublayer_level_idc;
+    std::vector<uint32_t> general_sub_profile_idc;
+  };
+
+  struct configuration
+  {
+    uint8_t LengthSizeMinusOne = 3;  // 0,1,3   default: 4 bytes for NAL unit lengths
+    bool ptl_present_flag = true;
+
+    // only if PTL present
+    uint16_t ols_idx; // 9 bits
+    uint8_t num_sublayers; // 3 bits
+    uint8_t constant_frame_rate; // 2 bits
+    uint8_t chroma_format_idc; // 2 bits
+    uint8_t bit_depth_minus8; // 3 bits
+    struct VvcPTLRecord native_ptl;
+    uint16_t max_picture_width;
+    uint16_t max_picture_height;
+    uint16_t avg_frame_rate;
+  };
+
+
+  std::string dump(Indent&) const override;
+
+  bool get_headers(std::vector<uint8_t>* dest) const;
+
+  void set_configuration(const configuration& config) { m_configuration = config; }
+
+  const configuration& get_configuration() const { return m_configuration; }
+
+  configuration& get_configuration() { return m_configuration; }
+
+  void append_nal_data(const std::vector<uint8_t>& nal);
+  void append_nal_data(const uint8_t* data, size_t size);
+
+  Error write(StreamWriter& writer) const override;
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits* limits) override;
+
+private:
+    struct NalArray
+    {
+      bool m_array_completeness;
+      uint8_t m_NAL_unit_type;
+
+      std::vector<std::vector<uint8_t> > m_nal_units; // only one NAL item for DCI and OPI
+    };
+
+  configuration m_configuration;
+  std::vector<NalArray> m_nal_array;
+};
+
+
+class Box_vvc1 : public Box_VisualSampleEntry
+{
+public:
+  Box_vvc1()
+  {
+    set_short_type(fourcc("vvc1"));
+  }
+};
+
+
+Error parse_sps_for_vvcC_configuration(const uint8_t* sps, size_t size,
+                                       Box_vvcC::configuration* inout_config,
+                                       int* width, int* height);
+
+#endif // LIBHEIF_VVC_BOXES_H
diff --git a/libheif/codecs/vvc_dec.cc b/libheif/codecs/vvc_dec.cc
new file mode 100644
index 0000000000..3c929713a9
--- /dev/null
+++ b/libheif/codecs/vvc_dec.cc
@@ -0,0 +1,71 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "vvc_dec.h"
+#include "vvc_boxes.h"
+#include "error.h"
+#include "context.h"
+
+#include <string>
+
+
+Result<std::vector<uint8_t>> Decoder_VVC::read_bitstream_configuration_data() const
+{
+  std::vector<uint8_t> data;
+  if (!m_vvcC->get_headers(&data)) {
+    return Error{heif_error_Invalid_input,
+                 heif_suberror_No_item_data};
+  }
+
+  return data;
+}
+
+
+int Decoder_VVC::get_luma_bits_per_pixel() const
+{
+  const Box_vvcC::configuration& config = m_vvcC->get_configuration();
+  if (config.ptl_present_flag) {
+    return config.bit_depth_minus8 + 8;
+  }
+  else {
+    return 8; // TODO: what shall we do if the bit-depth is unknown? Use PIXI?
+  }
+}
+
+
+int Decoder_VVC::get_chroma_bits_per_pixel() const
+{
+  return get_luma_bits_per_pixel();
+}
+
+
+Error Decoder_VVC::get_coded_image_colorspace(heif_colorspace* out_colorspace, heif_chroma* out_chroma) const
+{
+  *out_chroma = (heif_chroma) (m_vvcC->get_configuration().chroma_format_idc);
+
+  if (*out_chroma == heif_chroma_monochrome) {
+    *out_colorspace = heif_colorspace_monochrome;
+  }
+  else {
+    *out_colorspace = heif_colorspace_YCbCr;
+  }
+
+  return Error::Ok;
+}
diff --git a/libheif/codecs/vvc_dec.h b/libheif/codecs/vvc_dec.h
new file mode 100644
index 0000000000..0d55b1c39a
--- /dev/null
+++ b/libheif/codecs/vvc_dec.h
@@ -0,0 +1,54 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef HEIF_VVC_DEC_H
+#define HEIF_VVC_DEC_H
+
+#include "libheif/heif.h"
+#include "box.h"
+#include "error.h"
+
+#include <memory>
+#include <vector>
+#include <codecs/decoder.h>
+
+class Box_vvcC;
+
+
+class Decoder_VVC : public Decoder
+{
+public:
+  explicit Decoder_VVC(const std::shared_ptr<const Box_vvcC>& vvcC) : m_vvcC(vvcC) {}
+
+  heif_compression_format get_compression_format() const override { return heif_compression_VVC; }
+
+  int get_luma_bits_per_pixel() const override;
+
+  int get_chroma_bits_per_pixel() const override;
+
+  Error get_coded_image_colorspace(heif_colorspace*, heif_chroma*) const override;
+
+  Result<std::vector<uint8_t>> read_bitstream_configuration_data() const override;
+
+private:
+  const std::shared_ptr<const Box_vvcC> m_vvcC;
+};
+
+#endif
diff --git a/libheif/codecs/vvc_enc.cc b/libheif/codecs/vvc_enc.cc
new file mode 100644
index 0000000000..35bed60e1d
--- /dev/null
+++ b/libheif/codecs/vvc_enc.cc
@@ -0,0 +1,294 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "vvc_enc.h"
+#include "vvc_boxes.h"
+#include "error.h"
+#include "context.h"
+#include "api_structs.h"
+
+#include <string>
+
+#include "plugins/nalu_utils.h"
+
+
+Result<Encoder::CodedImageData> Encoder_VVC::encode(const std::shared_ptr<HeifPixelImage>& image,
+                                                    struct heif_encoder* encoder,
+                                                    const struct heif_encoding_options& options,
+                                                    enum heif_image_input_class input_class)
+{
+  Encoder::CodedImageData codedImage;
+
+  auto vvcC = std::make_shared<Box_vvcC>();
+  codedImage.properties.push_back(vvcC);
+
+
+  heif_image c_api_image;
+  c_api_image.image = image;
+
+  struct heif_error err = encoder->plugin->encode_image(encoder->encoder, &c_api_image, input_class);
+  if (err.code) {
+    return Error(err.code,
+                 err.subcode,
+                 err.message);
+  }
+
+  int encoded_width = 0;
+  int encoded_height = 0;
+
+  for (;;) {
+    uint8_t* data;
+    int size;
+
+    err = encoder->plugin->get_compressed_data(encoder->encoder, &data, &size, NULL);
+    if (err.code) {
+      return Error(err.code, err.subcode, err.message);
+    }
+
+    if (data == NULL) {
+      break;
+    }
+
+
+    const uint8_t NAL_SPS = 15;
+
+    uint8_t nal_type = 0;
+    if (size>=2) {
+      nal_type = (data[1] >> 3) & 0x1F;
+    }
+
+    if (nal_type == NAL_SPS) {
+      Box_vvcC::configuration config;
+
+      parse_sps_for_vvcC_configuration(data, size, &config, &encoded_width, &encoded_height);
+
+      vvcC->set_configuration(config);
+    }
+
+    switch (nal_type) {
+      case 14: // VPS
+      case 15: // SPS
+      case 16: // PPS
+        vvcC->append_nal_data(data, size);
+        break;
+
+      default:
+        codedImage.append_with_4bytes_size(data, size);
+    }
+  }
+
+  codedImage.codingConstraints.intra_pred_used = true;
+  codedImage.codingConstraints.all_ref_pics_intra = true; // TODO: change when we use predicted frames
+  codedImage.codingConstraints.max_ref_per_pic = 0;
+
+  return codedImage;
+}
+
+
+std::shared_ptr<class Box_VisualSampleEntry> Encoder_VVC::get_sample_description_box(const CodedImageData& data) const
+{
+  auto vvc1 = std::make_shared<Box_vvc1>();
+  vvc1->get_VisualSampleEntry().compressorname = "VVC";
+
+  for (auto prop : data.properties) {
+    if (prop->get_short_type() == fourcc("vvcC")) {
+      vvc1->append_child_box(prop);
+      return vvc1;
+    }
+  }
+
+  // box not yet available
+  return nullptr;
+}
+
+
+Error Encoder_VVC::encode_sequence_frame(const std::shared_ptr<HeifPixelImage>& image,
+                                         heif_encoder* encoder,
+                                         const heif_sequence_encoding_options& options,
+                                         heif_image_input_class input_class,
+                                         uint32_t framerate_num, uint32_t framerate_denom,
+                                         uintptr_t frame_number)
+{
+  heif_image c_api_image;
+  c_api_image.image = image;
+
+  if (!m_encoder_active) {
+    heif_error err = encoder->plugin->start_sequence_encoding(encoder->encoder, &c_api_image, input_class,
+                                                              framerate_num, framerate_denom,
+                                                              &options);
+    if (err.code) {
+      return {
+        err.code,
+        err.subcode,
+        err.message
+      };
+    }
+
+    m_vvcC = std::make_shared<Box_vvcC>();
+    m_encoder_active = true;
+  }
+
+  Error dataErr = get_data(encoder);
+  if (dataErr) {
+    return dataErr;
+  }
+
+  heif_error err = encoder->plugin->encode_sequence_frame(encoder->encoder, &c_api_image, frame_number);
+  if (err.code) {
+    return {
+      err.code,
+      err.subcode,
+      err.message
+    };
+  }
+
+  return get_data(encoder);
+}
+
+
+Error Encoder_VVC::encode_sequence_flush(heif_encoder* encoder)
+{
+  encoder->plugin->end_sequence_encoding(encoder->encoder);
+  m_encoder_active = false;
+  m_end_of_sequence_reached = true;
+
+  return get_data(encoder);
+}
+
+
+std::optional<Encoder::CodedImageData> Encoder_VVC::encode_sequence_get_data()
+{
+  return std::move(m_current_output_data);
+}
+
+Error Encoder_VVC::get_data(heif_encoder* encoder)
+{
+  //CodedImageData codedImage;
+
+  bool got_some_data = false;
+
+  for (;;) {
+    uint8_t* data;
+    int size;
+
+    uintptr_t frameNr=0;
+    int more_frame_packets = 1;
+    struct heif_error err = encoder->plugin->get_compressed_data2(encoder->encoder, &data, &size, &frameNr, nullptr, &more_frame_packets);
+    if (err.code) {
+      return Error(err.code, err.subcode, err.message);
+    }
+
+    if (data == nullptr) {
+      break;
+    }
+
+    got_some_data = true;
+
+    const uint8_t nal_type = (data[1] >> 3);
+    const bool is_sync = (nal_type == 7 || nal_type == 8 || nal_type == 9);
+    const bool is_image_data = (nal_type >= 0 && nal_type <= VVC_NAL_UNIT_MAX_VCL);
+
+    // std::cout << "received frameNr=" << frameNr << " nal_type:" << ((int)nal_type) << " size: " << size << "\n";
+
+    if (nal_type == VVC_NAL_UNIT_SPS_NUT && m_vvcC) {
+      parse_sps_for_vvcC_configuration(data, size,
+                                       &m_vvcC->get_configuration(),
+                                       &m_encoded_image_width, &m_encoded_image_height);
+    }
+
+    switch (nal_type) {
+      case VVC_NAL_UNIT_VPS_NUT:
+        if (m_vvcC && !m_vvcC_has_VPS) m_vvcC->append_nal_data(data, size);
+        m_vvcC_has_VPS = true;
+        break;
+
+      case VVC_NAL_UNIT_SPS_NUT:
+        if (m_vvcC && !m_vvcC_has_SPS) m_vvcC->append_nal_data(data, size);
+        m_vvcC_has_SPS = true;
+        break;
+
+      case VVC_NAL_UNIT_PPS_NUT:
+        if (m_vvcC && !m_vvcC_has_PPS) m_vvcC->append_nal_data(data, size);
+        m_vvcC_has_PPS = true;
+        break;
+
+      default:
+        if (!m_current_output_data) {
+          m_current_output_data = CodedImageData{};
+        }
+        m_current_output_data->append_with_4bytes_size(data, size);
+
+        if (is_image_data) {
+          m_current_output_data->is_sync_frame = is_sync;
+          m_current_output_data->frame_nr = frameNr;
+        }
+    }
+
+    if (!more_frame_packets) {
+      break;
+    }
+  }
+
+  if (!got_some_data) {
+    return {};
+  }
+
+  if (!m_encoded_image_width || !m_encoded_image_height) {
+    return Error(heif_error_Encoder_plugin_error,
+                 heif_suberror_Invalid_image_size);
+  }
+
+
+  // --- return hvcC when all headers are included and it was not returned yet
+  //     TODO: it's maybe better to return this at the end so that we are sure to have all headers
+  //           and also complete codingConstraints.
+
+  //if (hvcC_has_VPS && m_hvcC_has_SPS && m_hvcC_has_PPS && !m_hvcC_returned) {
+  if (m_end_of_sequence_reached && m_vvcC && !m_vvcC_sent) {
+    m_current_output_data->properties.push_back(m_vvcC);
+    m_vvcC = nullptr;
+    m_vvcC_sent = true;
+  }
+
+  m_current_output_data->encoded_image_width = m_encoded_image_width;
+  m_current_output_data->encoded_image_height = m_encoded_image_height;
+
+
+  // Make sure that the encoder plugin works correctly and the encoded image has the correct size.
+#if 0
+  if (encoder->plugin->plugin_api_version >= 3 &&
+      encoder->plugin->query_encoded_size != nullptr) {
+    uint32_t check_encoded_width = image->get_width(), check_encoded_height = image->get_height();
+
+    encoder->plugin->query_encoded_size(encoder->encoder,
+                                        image->get_width(), image->get_height(),
+                                        &check_encoded_width,
+                                        &check_encoded_height);
+
+    assert((int)check_encoded_width == encoded_width);
+    assert((int)check_encoded_height == encoded_height);
+      }
+#endif
+
+  m_current_output_data->codingConstraints.intra_pred_used = true;
+  m_current_output_data->codingConstraints.all_ref_pics_intra = true; // TODO: change when we use predicted frames
+
+  return {};
+}
diff --git a/libheif/codecs/vvc_enc.h b/libheif/codecs/vvc_enc.h
new file mode 100644
index 0000000000..40b3b24fc3
--- /dev/null
+++ b/libheif/codecs/vvc_enc.h
@@ -0,0 +1,79 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef HEIF_ENCODER_VVC_H
+#define HEIF_ENCODER_VVC_H
+
+#include "libheif/heif.h"
+#include "box.h"
+#include "error.h"
+#include "file.h"
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+#include "codecs/encoder.h"
+
+
+class Encoder_VVC : public Encoder {
+public:
+  Result<CodedImageData> encode(const std::shared_ptr<HeifPixelImage>& image,
+                                heif_encoder* encoder,
+                                const heif_encoding_options& options,
+                                heif_image_input_class input_class) override;
+
+  std::shared_ptr<Box_VisualSampleEntry> get_sample_description_box(const CodedImageData&) const override;
+
+
+  bool encode_sequence_started() const override { return m_encoder_active; }
+
+  Error encode_sequence_frame(const std::shared_ptr<HeifPixelImage>& image,
+                              heif_encoder* encoder,
+                              const heif_sequence_encoding_options& options,
+                              heif_image_input_class input_class,
+                              uint32_t framerate_num, uint32_t framerate_denom,
+                              uintptr_t frame_number) override;
+
+  Error encode_sequence_flush(heif_encoder* encoder) override;
+
+  std::optional<CodedImageData> encode_sequence_get_data() override;
+
+private:
+  bool m_encoder_active = false;
+  bool m_end_of_sequence_reached = false;
+
+  // Whether the vvcC is complete and was returned in an encode_sequence_get_data() call.
+  bool m_vvcC_has_VPS = false;
+  bool m_vvcC_has_SPS = false;
+  bool m_vvcC_has_PPS = false;
+  std::shared_ptr<class Box_vvcC> m_vvcC;
+  bool m_vvcC_sent = false;
+
+  int m_encoded_image_width = 0;
+  int m_encoded_image_height = 0;
+
+  std::optional<CodedImageData> m_current_output_data;
+
+  Error get_data(heif_encoder*);
+};
+
+
+#endif
diff --git a/libheif/color-conversion/alpha.cc b/libheif/color-conversion/alpha.cc
new file mode 100644
index 0000000000..08651b0b97
--- /dev/null
+++ b/libheif/color-conversion/alpha.cc
@@ -0,0 +1,287 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <cstdint>
+#include "alpha.h"
+
+
+std::vector<ColorStateWithCost>
+Op_drop_alpha_plane::state_after_conversion(const ColorState& input_state,
+                                            const ColorState& target_state,
+                                            const heif_color_conversion_options& options,
+                                            const heif_color_conversion_options_ext& options_ext) const
+{
+  // only drop alpha plane if it is not needed in output
+
+  if ((input_state.chroma != heif_chroma_monochrome &&
+       input_state.chroma != heif_chroma_420 &&
+       input_state.chroma != heif_chroma_422 &&
+       input_state.chroma != heif_chroma_444) ||
+      input_state.has_alpha == false ||
+      target_state.has_alpha == true) {
+    return {};
+  }
+
+  if (options_ext.alpha_composition_mode != heif_alpha_composition_mode_none) {
+    return {};
+  }
+
+  std::vector<ColorStateWithCost> states;
+
+  ColorState output_state;
+
+  // --- drop alpha plane
+
+  output_state = input_state;
+  output_state.has_alpha = false;
+
+  states.emplace_back(output_state, SpeedCosts_Trivial);
+
+  return states;
+}
+
+
+Result<std::shared_ptr<HeifPixelImage>>
+Op_drop_alpha_plane::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                                        const ColorState& input_state,
+                                        const ColorState& target_state,
+                                        const heif_color_conversion_options& options,
+                                        const heif_color_conversion_options_ext& options_ext,
+                                        const heif_security_limits* limits) const
+{
+  uint32_t width = input->get_width();
+  uint32_t height = input->get_height();
+
+  auto outimg = std::make_shared<HeifPixelImage>();
+
+  outimg->create(width, height,
+                 input->get_colorspace(),
+                 input->get_chroma_format());
+
+  for (heif_channel channel : {heif_channel_Y,
+                               heif_channel_Cb,
+                               heif_channel_Cr,
+                               heif_channel_R,
+                               heif_channel_G,
+                               heif_channel_B}) {
+    if (input->has_channel(channel)) {
+      outimg->copy_new_plane_from(input, channel, channel, limits);
+    }
+  }
+
+  return outimg;
+}
+
+
+template<class Pixel>
+std::vector<ColorStateWithCost>
+Op_flatten_alpha_plane<Pixel>::state_after_conversion(const ColorState& input_state,
+                                                      const ColorState& target_state,
+                                                      const heif_color_conversion_options& options,
+                                                      const heif_color_conversion_options_ext& options_ext) const
+{
+  bool hdr = !std::is_same<Pixel, uint8_t>::value;
+
+  // TODO: this Op only works when all channels are either HDR or all are SDR.
+  //       But there is currently no easy way to check that.
+
+  if ((input_state.bits_per_pixel > 8) != hdr) {
+    return {};
+  }
+
+  // only drop alpha plane if it is not needed in output
+
+  if ((input_state.chroma != heif_chroma_monochrome &&
+       input_state.chroma != heif_chroma_420 &&
+       input_state.chroma != heif_chroma_422 &&
+       input_state.chroma != heif_chroma_444) ||
+      input_state.has_alpha == false ||
+      target_state.has_alpha == true) {
+    return {};
+  }
+
+  if (options_ext.alpha_composition_mode == heif_alpha_composition_mode_none) {
+    return {};
+  }
+
+  std::vector<ColorStateWithCost> states;
+
+  ColorState output_state;
+
+  // --- drop alpha plane
+
+  output_state = input_state;
+  output_state.has_alpha = false;
+
+  states.emplace_back(output_state, SpeedCosts_Trivial);
+
+  return states;
+}
+
+
+template<class Pixel>
+Result<std::shared_ptr<HeifPixelImage>>
+Op_flatten_alpha_plane<Pixel>::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input_raw,
+                                                  const ColorState& input_state,
+                                                  const ColorState& target_state,
+                                                  const heif_color_conversion_options& options,
+                                                  const heif_color_conversion_options_ext& options_ext,
+                                                  const heif_security_limits* limits) const
+{
+  std::shared_ptr<const HeifPixelImage> input = input_raw;
+
+  heif_color_conversion_options_ext options_ext_skip_alpha = options_ext;
+  options_ext_skip_alpha.alpha_composition_mode = heif_alpha_composition_mode_none;
+
+  if (options_ext.alpha_composition_mode != heif_alpha_composition_mode_none) {
+    Result<std::shared_ptr<const HeifPixelImage>> convInput = ::convert_colorspace(input,
+                                                                                   heif_colorspace_RGB,
+                                                                                   heif_chroma_444,
+                                                                                   input_state.nclx,
+                                                                                   input_state.bits_per_pixel,
+                                                                                   options, &options_ext_skip_alpha,
+                                                                                   limits);
+    if (!convInput) {
+      return convInput.error();
+    }
+    else {
+      input = *convInput;
+    }
+  }
+
+  uint32_t width = input->get_width();
+  uint32_t height = input->get_height();
+
+  auto outimg = std::make_shared<HeifPixelImage>();
+
+  outimg->create(width, height,
+                 input->get_colorspace(),
+                 input->get_chroma_format());
+
+  for (heif_channel channel : {heif_channel_R,
+                               heif_channel_G,
+                               heif_channel_B}) {
+    outimg->add_plane(channel, width, height, target_state.bits_per_pixel, limits);
+
+    const Pixel* p_alpha;
+    size_t stride_alpha;
+    p_alpha = (const Pixel*)input->get_plane(heif_channel_Alpha, &stride_alpha);
+    int bpp_alpha = input->get_bits_per_pixel(heif_channel_Alpha);
+    Pixel alpha_max = (Pixel)((1 << bpp_alpha) - 1);
+
+    const Pixel* p_in;
+    size_t stride_in;
+    p_in = (const Pixel*)input->get_plane(channel, &stride_in);
+
+    Pixel* p_out;
+    size_t stride_out;
+    p_out = (Pixel*)outimg->get_plane(channel, &stride_out);
+
+    if (sizeof(Pixel) == 2) {
+      stride_alpha /= 2;
+      stride_in /= 2;
+      stride_out /= 2;
+    }
+
+    if (options_ext.alpha_composition_mode == heif_alpha_composition_mode_solid_color ||
+        (options_ext.alpha_composition_mode == heif_alpha_composition_mode_checkerboard && options_ext.checkerboard_square_size == 0)) {
+      uint16_t bkg16;
+
+      switch (channel) {
+        case heif_channel_R:
+          bkg16 = options_ext.background_red;
+          break;
+        case heif_channel_G:
+          bkg16 = options_ext.background_green;
+          break;
+        case heif_channel_B:
+          bkg16 = options_ext.background_blue;
+          break;
+        default:
+          assert(false);
+          bkg16 = 0;
+      }
+
+      Pixel bkg = static_cast<Pixel>(bkg16 >> (16 - input->get_bits_per_pixel(channel)));
+
+      for (uint32_t y = 0; y < height; y++)
+        for (uint32_t x = 0; x < width; x++) {
+          int a = p_alpha[y * stride_alpha + x];
+          p_out[y * stride_out + x] = static_cast<Pixel>((p_in[y * stride_in + x] * a + bkg * (alpha_max - a)) >> bpp_alpha);
+        }
+    }
+    else {
+      uint16_t bkg16_1, bkg16_2;
+
+      switch (channel) {
+        case heif_channel_R:
+          bkg16_1 = options_ext.background_red;
+          bkg16_2 = options_ext.secondary_background_red;
+          break;
+        case heif_channel_G:
+          bkg16_1 = options_ext.background_green;
+          bkg16_2 = options_ext.secondary_background_green;
+          break;
+        case heif_channel_B:
+          bkg16_1 = options_ext.background_blue;
+          bkg16_2 = options_ext.secondary_background_blue;
+          break;
+        default:
+          assert(false);
+          bkg16_1 = bkg16_2 = 0;
+      }
+
+      Pixel bkg1 = static_cast<Pixel>(bkg16_1 >> (16 - input->get_bits_per_pixel(channel)));
+      Pixel bkg2 = static_cast<Pixel>(bkg16_2 >> (16 - input->get_bits_per_pixel(channel)));
+
+      for (uint32_t y = 0; y < height; y++)
+        for (uint32_t x = 0; x < width; x++) {
+          uint8_t parity = (x / options_ext.checkerboard_square_size + y / options_ext.checkerboard_square_size) % 2;
+          Pixel bkg = parity ? bkg1 : bkg2;
+
+          int a = p_alpha[y * stride_alpha + x];
+          p_out[y * stride_out + x] = static_cast<Pixel>((p_in[y * stride_in + x] * a + bkg * (alpha_max - a)) >> bpp_alpha);
+        }
+    }
+
+  }
+
+  if (options_ext.alpha_composition_mode != heif_alpha_composition_mode_none) {
+    Result<std::shared_ptr<HeifPixelImage>> convOutput = ::convert_colorspace(outimg,
+                                                                              input_raw->get_colorspace(),
+                                                                              input_raw->get_chroma_format(),
+                                                                              input_state.nclx,
+                                                                              input_state.bits_per_pixel,
+                                                                              options, &options_ext_skip_alpha,
+                                                                              limits);
+    if (!convOutput) {
+      return convOutput.error();
+    }
+    else {
+      return convOutput;
+    }
+  }
+  else {
+    return outimg;
+  }
+}
+
+template class Op_flatten_alpha_plane<uint8_t>;
+template class Op_flatten_alpha_plane<uint16_t>;
diff --git a/libheif/color-conversion/alpha.h b/libheif/color-conversion/alpha.h
new file mode 100644
index 0000000000..60ad84e6d2
--- /dev/null
+++ b/libheif/color-conversion/alpha.h
@@ -0,0 +1,67 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_COLORCONVERSION_ALPHA_H
+#define LIBHEIF_COLORCONVERSION_ALPHA_H
+
+#include "colorconversion.h"
+#include <vector>
+#include <memory>
+
+
+class Op_drop_alpha_plane : public ColorConversionOperation
+{
+public:
+  std::vector<ColorStateWithCost>
+  state_after_conversion(const ColorState& input_state,
+                         const ColorState& target_state,
+                         const heif_color_conversion_options& options,
+                         const heif_color_conversion_options_ext& options_ext) const override;
+
+  Result<std::shared_ptr<HeifPixelImage>>
+  convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                     const ColorState& input_state,
+                     const ColorState& target_state,
+                     const heif_color_conversion_options& options,
+                     const heif_color_conversion_options_ext& options_ext,
+                     const heif_security_limits* limits) const override;
+};
+
+
+template<class Pixel>
+class Op_flatten_alpha_plane : public ColorConversionOperation
+{
+public:
+  std::vector<ColorStateWithCost>
+  state_after_conversion(const ColorState& input_state,
+                         const ColorState& target_state,
+                         const heif_color_conversion_options& options,
+                         const heif_color_conversion_options_ext& options_ext) const override;
+
+  Result<std::shared_ptr<HeifPixelImage>>
+  convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                     const ColorState& input_state,
+                     const ColorState& target_state,
+                     const heif_color_conversion_options& options,
+                     const heif_color_conversion_options_ext& options_ext,
+                     const heif_security_limits* limits) const override;
+};
+
+#endif //LIBHEIF_COLORCONVERSION_ALPHA_H
diff --git a/libheif/color-conversion/bayer_bilinear.cc b/libheif/color-conversion/bayer_bilinear.cc
new file mode 100644
index 0000000000..9e0ef30945
--- /dev/null
+++ b/libheif/color-conversion/bayer_bilinear.cc
@@ -0,0 +1,213 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2026 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "bayer_bilinear.h"
+#include <libheif/heif_uncompressed.h>
+#include <array>
+#include <cassert>
+#include <utility>
+
+
+std::vector<ColorStateWithCost>
+Op_bayer_bilinear_to_RGB24_32::state_after_conversion(const ColorState& input_state,
+                                             const ColorState& target_state,
+                                             const heif_color_conversion_options& options,
+                                             const heif_color_conversion_options_ext& options_ext) const
+{
+  if (input_state.colorspace != heif_colorspace_filter_array ||
+      input_state.chroma != heif_chroma_monochrome) {
+    return {};
+  }
+
+  std::vector<ColorStateWithCost> states;
+
+  ColorState output_state;
+  output_state.colorspace = heif_colorspace_RGB;
+  output_state.has_alpha = false;
+
+  if (input_state.bits_per_pixel == 8) {
+    output_state.chroma = heif_chroma_interleaved_RGB;
+    output_state.bits_per_pixel = 8;
+  }
+  else if (input_state.bits_per_pixel > 8 && input_state.bits_per_pixel <= 16) {
+    output_state.chroma = heif_chroma_interleaved_RRGGBB_LE;
+    output_state.bits_per_pixel = input_state.bits_per_pixel;
+  }
+  else {
+    return {};
+  }
+
+  states.emplace_back(output_state, SpeedCosts_Unoptimized);
+
+  return states;
+}
+
+
+// Map uncompressed component types to R/G/B output channel indices.
+// Returns -1 for unknown component types.
+static int component_type_to_rgb_index(uint16_t component_type)
+{
+  switch (component_type) {
+    case heif_uncompressed_component_type_red:
+      return 0;
+    case heif_uncompressed_component_type_green:
+      return 1;
+    case heif_uncompressed_component_type_blue:
+      return 2;
+    default:
+      return -1;
+  }
+}
+
+
+Result<std::shared_ptr<HeifPixelImage>>
+Op_bayer_bilinear_to_RGB24_32::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                                         const ColorState& input_state,
+                                         const ColorState& target_state,
+                                         const heif_color_conversion_options& options,
+                                         const heif_color_conversion_options_ext& options_ext,
+                                         const heif_security_limits* limits) const
+{
+  uint32_t width = input->get_width();
+  uint32_t height = input->get_height();
+
+  if (!input->has_bayer_pattern()) {
+    return Error::InternalError;
+  }
+
+  const BayerPattern& pattern = input->get_bayer_pattern();
+  uint16_t pw = pattern.pattern_width;
+  uint16_t ph = pattern.pattern_height;
+
+  if (pw == 0 || ph == 0) {
+    return Error::InternalError;
+  }
+
+  int bpp = input->get_bits_per_pixel(heif_channel_filter_array);
+  bool hdr = bpp > 8;
+
+  heif_chroma out_chroma = hdr ? heif_chroma_interleaved_RRGGBB_LE : heif_chroma_interleaved_RGB;
+
+  auto outimg = std::make_shared<HeifPixelImage>();
+
+  outimg->create(width, height, heif_colorspace_RGB, out_chroma);
+
+  if (auto err = outimg->add_plane(heif_channel_interleaved, width, height, bpp, limits)) {
+    return err;
+  }
+
+  size_t in_stride = 0;
+  const uint8_t* in_p = input->get_plane(heif_channel_filter_array, &in_stride);
+
+  size_t out_stride = 0;
+  uint8_t* out_p = outimg->get_plane(heif_channel_interleaved, &out_stride);
+
+  // Build a lookup table: for each pattern position, which RGB channel (0=R,1=G,2=B) does it provide?
+  std::vector<int> pattern_channel(pw * ph);
+  for (int i = 0; i < pw * ph; i++) {
+    uint16_t comp_type = input->get_component_type(pattern.pixels[i].component_index);
+    pattern_channel[i] = component_type_to_rgb_index(comp_type);
+    if (pattern_channel[i] < 0) {
+      return Error(heif_error_Unsupported_feature,
+                   heif_suberror_Unsupported_data_version,
+                   "Bayer pattern contains component types that we currently cannot convert to RGB");
+    }
+  }
+
+  // Precompute neighbor offset tables for each pattern position and channel.
+  // neighbor_offsets[py * pw + px][ch] = list of (dx, dy) offsets to average.
+  // For the channel this position directly provides: single entry (0, 0).
+  // For other channels: all neighbor offsets within the search radius that provide that channel.
+  std::vector<std::array<std::vector<std::pair<int, int>>, 3>> neighbor_offsets(pw * ph);
+
+  for (int py = 0; py < ph; py++) {
+    for (int px = 0; px < pw; px++) {
+      int this_ch = pattern_channel[py * pw + px];
+      auto& offsets = neighbor_offsets[py * pw + px];
+
+      // The channel this position directly provides: just read from (0,0)
+      offsets[this_ch].emplace_back(0, 0);
+
+      // For the other two channels: collect neighbor offsets
+      int search_radius_x = pw - 1;
+      int search_radius_y = ph - 1;
+
+      for (int dy = -search_radius_y; dy <= search_radius_y; dy++) {
+        for (int dx = -search_radius_x; dx <= search_radius_x; dx++) {
+          if (dx == 0 && dy == 0) {
+            continue;
+          }
+
+          int npx = (((px + dx) % pw) + pw) % pw;
+          int npy = (((py + dy) % ph) + ph) % ph;
+          int neighbor_ch = pattern_channel[npy * pw + npx];
+
+          if (neighbor_ch != this_ch) {
+            offsets[neighbor_ch].emplace_back(dx, dy);
+          }
+        }
+      }
+    }
+  }
+
+  // Bilinear demosaicing using precomputed offset tables.
+  auto demosaic = [&]<typename Pixel>(const Pixel* in, Pixel* out,
+                                      size_t in_str, size_t out_str) {
+    for (uint32_t y = 0; y < height; y++) {
+      for (uint32_t x = 0; x < width; x++) {
+        const auto& offsets = neighbor_offsets[(y % ph) * pw + (x % pw)];
+
+        Pixel* out_pixel = &out[y * out_str + x * 3];
+
+        for (int ch = 0; ch < 3; ch++) {
+          const auto& ch_offsets = offsets[ch];
+          int sum = 0;
+          int count = 0;
+
+          for (const auto& [dx, dy] : ch_offsets) {
+            int nx = static_cast<int>(x) + dx;
+            int ny = static_cast<int>(y) + dy;
+
+            if (nx < 0 || nx >= static_cast<int>(width) ||
+                ny < 0 || ny >= static_cast<int>(height)) {
+              continue;
+            }
+
+            sum += in[ny * in_str + nx];
+            count++;
+          }
+
+          out_pixel[ch] = count > 0 ? static_cast<Pixel>((sum + count / 2) / count) : 0;
+        }
+      }
+    }
+  };
+
+  if (hdr) {
+    demosaic(reinterpret_cast<const uint16_t*>(in_p),
+             reinterpret_cast<uint16_t*>(out_p),
+             in_stride / 2, out_stride / 2);
+  }
+  else {
+    demosaic(in_p, out_p, in_stride, out_stride);
+  }
+
+  return outimg;
+}
diff --git a/libheif/color-conversion/bayer_bilinear.h b/libheif/color-conversion/bayer_bilinear.h
new file mode 100644
index 0000000000..53b228538f
--- /dev/null
+++ b/libheif/color-conversion/bayer_bilinear.h
@@ -0,0 +1,47 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2026 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_COLORCONVERSION_BAYER_BILINEAR_H
+#define LIBHEIF_COLORCONVERSION_BAYER_BILINEAR_H
+
+#include "colorconversion.h"
+#include <vector>
+#include <memory>
+
+
+class Op_bayer_bilinear_to_RGB24_32 : public ColorConversionOperation
+{
+public:
+  std::vector<ColorStateWithCost>
+  state_after_conversion(const ColorState& input_state,
+                         const ColorState& target_state,
+                         const heif_color_conversion_options& options,
+                         const heif_color_conversion_options_ext& options_ext) const override;
+
+  Result<std::shared_ptr<HeifPixelImage>>
+  convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                     const ColorState& input_state,
+                     const ColorState& target_state,
+                     const heif_color_conversion_options& options,
+                     const heif_color_conversion_options_ext& options_ext,
+                     const heif_security_limits* limits) const override;
+};
+
+#endif //LIBHEIF_COLORCONVERSION_BAYER_BILINEAR_H
diff --git a/libheif/color-conversion/chroma_sampling.cc b/libheif/color-conversion/chroma_sampling.cc
new file mode 100644
index 0000000000..9bafdff89e
--- /dev/null
+++ b/libheif/color-conversion/chroma_sampling.cc
@@ -0,0 +1,950 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "chroma_sampling.h"
+#include <cstring>
+
+
+template<class Pixel>
+std::vector<ColorStateWithCost>
+Op_YCbCr444_to_YCbCr420_average<Pixel>::state_after_conversion(const ColorState& input_state,
+                                                               const ColorState& target_state,
+                                                               const heif_color_conversion_options& options,
+                                                               const heif_color_conversion_options_ext& options_ext) const
+{
+  if (input_state.colorspace != heif_colorspace_YCbCr) {
+    return {};
+  }
+
+  if (input_state.chroma != heif_chroma_444) {
+    return {};
+  }
+
+  // this Op only implements the averaging algorithm
+
+  if (options.preferred_chroma_downsampling_algorithm != heif_chroma_downsampling_average) {
+    return {};
+  }
+
+  bool hdr = !std::is_same<Pixel, uint8_t>::value;
+
+  if ((input_state.bits_per_pixel > 8) != hdr) {
+    return {};
+  }
+
+  if (input_state.nclx.get_matrix_coefficients() == 0) {
+    return {};
+  }
+
+  if (target_state.chroma != heif_chroma_420) {
+    return {};
+  }
+
+  std::vector<ColorStateWithCost> states;
+
+  ColorState output_state;
+
+  // --- convert to 4:2:0
+
+  output_state.colorspace = heif_colorspace_YCbCr;
+  output_state.chroma = heif_chroma_420;
+  output_state.has_alpha = input_state.has_alpha;  // we simply keep the old alpha plane
+  output_state.bits_per_pixel = input_state.bits_per_pixel;
+  output_state.nclx = input_state.nclx;
+
+  states.emplace_back(output_state, SpeedCosts_Unoptimized);
+
+  return states;
+}
+
+
+template<class Pixel>
+Result<std::shared_ptr<HeifPixelImage>>
+Op_YCbCr444_to_YCbCr420_average<Pixel>::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                                                           const ColorState& input_state,
+                                                           const ColorState& target_state,
+                                                           const heif_color_conversion_options& options,
+                                                           const heif_color_conversion_options_ext& options_ext,
+                                                           const heif_security_limits* limits) const
+{
+  bool hdr = !std::is_same<Pixel, uint8_t>::value;
+
+  int bpp_y = input->get_bits_per_pixel(heif_channel_Y);
+  int bpp_cb = input->get_bits_per_pixel(heif_channel_Cb);
+  int bpp_cr = input->get_bits_per_pixel(heif_channel_Cr);
+  int bpp_a = 0;
+
+  bool has_alpha = input->has_channel(heif_channel_Alpha);
+
+  if (has_alpha) {
+    bpp_a = input->get_bits_per_pixel(heif_channel_Alpha);
+  }
+
+  if (!hdr) {
+    if (bpp_y > 8 ||
+        bpp_cb > 8 ||
+        bpp_cr > 8) {
+      return Error::InternalError;
+    }
+  }
+  else {
+    if (bpp_y <= 8 ||
+        bpp_cb <= 8 ||
+        bpp_cr <= 8) {
+      return Error::InternalError;
+    }
+  }
+
+
+  if (bpp_y != bpp_cb ||
+      bpp_y != bpp_cr) {
+    // TODO: test with varying bit depths when we have a test image
+    return Error::InternalError;
+  }
+
+
+  uint32_t width = input->get_width();
+  uint32_t height = input->get_height();
+
+  auto outimg = std::make_shared<HeifPixelImage>();
+
+  outimg->create(width, height, heif_colorspace_YCbCr, heif_chroma_420);
+
+  uint32_t cwidth = (width + 1) / 2;
+  uint32_t cheight = (height + 1) / 2;
+
+  if (auto err = outimg->add_plane(heif_channel_Y, width, height, bpp_y, limits) ||
+                 outimg->add_plane(heif_channel_Cb, cwidth, cheight, bpp_cb, limits) ||
+                 outimg->add_plane(heif_channel_Cr, cwidth, cheight, bpp_cr, limits)) {
+    return err;
+  }
+
+  if (has_alpha) {
+    if (auto err = outimg->add_plane(heif_channel_Alpha, width, height, bpp_a, limits)) {
+      return err;
+    }
+  }
+
+  const Pixel* in_y, * in_cb, * in_cr;
+  size_t in_y_stride = 0, in_cb_stride = 0, in_cr_stride = 0, in_a_stride = 0;
+
+  Pixel* out_y, * out_cb, * out_cr;
+  size_t out_y_stride = 0, out_cb_stride = 0, out_cr_stride = 0, out_a_stride = 0;
+
+  in_y = (const Pixel*) input->get_plane(heif_channel_Y, &in_y_stride);
+  in_cb = (const Pixel*) input->get_plane(heif_channel_Cb, &in_cb_stride);
+  in_cr = (const Pixel*) input->get_plane(heif_channel_Cr, &in_cr_stride);
+  out_y = (Pixel*) outimg->get_plane(heif_channel_Y, &out_y_stride);
+  out_cb = (Pixel*) outimg->get_plane(heif_channel_Cb, &out_cb_stride);
+  out_cr = (Pixel*) outimg->get_plane(heif_channel_Cr, &out_cr_stride);
+
+  if (hdr) {
+    in_y_stride /= 2;
+    in_cb_stride /= 2;
+    in_cr_stride /= 2;
+    out_y_stride /= 2;
+    out_cb_stride /= 2;
+    out_cr_stride /= 2;
+  }
+
+
+  // We only copy the alpha, do not access it as 16 bit
+  const uint8_t* in_a;
+  uint8_t* out_a;
+
+  if (has_alpha) {
+    in_a = input->get_plane(heif_channel_Alpha, &in_a_stride);
+    out_a = outimg->get_plane(heif_channel_Alpha, &out_a_stride);
+  }
+  else {
+    in_a = nullptr;
+    out_a = nullptr;
+  }
+
+
+  // --- fill right and bottom borders if the image size is odd
+
+  if (height & 1) {
+    for (uint32_t x = 0; x < width - 1; x += 2) {
+      out_cb[(cheight - 1) * out_cb_stride + x / 2] = (Pixel) ((in_cb[(height - 1) * in_cb_stride + x] +
+                                                                in_cb[(height - 1) * in_cb_stride + x + 1] + 1) / 2);
+      out_cr[(cheight - 1) * out_cr_stride + x / 2] = (Pixel) ((in_cr[(height - 1) * in_cr_stride + x] +
+                                                                in_cr[(height - 1) * in_cr_stride + x + 1] + 1) / 2);
+    }
+  }
+
+  if (width & 1) {
+    for (uint32_t y = 0; y < height - 1; y += 2) {
+      out_cb[(y / 2) * out_cb_stride + cwidth - 1] = (Pixel) ((in_cb[(y + 0) * in_cb_stride + width - 1] +
+                                                               in_cb[(y + 1) * in_cb_stride + width - 1] + 1) / 2);
+      out_cr[(y / 2) * out_cr_stride + cwidth - 1] = (Pixel) ((in_cr[(y + 0) * in_cr_stride + width - 1] +
+                                                               in_cr[(y + 1) * in_cr_stride + width - 1] + 1) / 2);
+    }
+  }
+
+  if ((width & 1) && (height & 1)) {
+    out_cb[(cheight - 1) * out_cb_stride + cwidth - 1] = in_cb[(height - 1) * in_cb_stride + width - 1];
+    out_cr[(cheight - 1) * out_cr_stride + cwidth - 1] = in_cr[(height - 1) * in_cr_stride + width - 1];
+  }
+
+
+  // --- averaging filter
+
+  uint32_t x, y;
+  for (y = 0; y < height - 1; y += 2) {
+    for (x = 0; x < width - 1; x += 2) {
+      Pixel cb00 = in_cb[y * in_cb_stride + x];
+      Pixel cr00 = in_cr[y * in_cr_stride + x];
+      Pixel cb01 = in_cb[y * in_cb_stride + x + 1];
+      Pixel cr01 = in_cr[y * in_cr_stride + x + 1];
+      Pixel cb10 = in_cb[(y + 1) * in_cb_stride + x];
+      Pixel cr10 = in_cr[(y + 1) * in_cr_stride + x];
+      Pixel cb11 = in_cb[(y + 1) * in_cb_stride + x + 1];
+      Pixel cr11 = in_cr[(y + 1) * in_cr_stride + x + 1];
+
+      out_cb[(y / 2) * out_cb_stride + x / 2] = (Pixel) ((cb00 + cb01 + cb10 + cb11 + 2) / 4);
+      out_cr[(y / 2) * out_cr_stride + x / 2] = (Pixel) ((cr00 + cr01 + cr10 + cr11 + 2) / 4);
+    }
+  }
+
+  // TODO: check whether we can use HeifPixelImage::transfer_plane_from_image_as() instead of copying Y and Alpha
+
+  for (y = 0; y < height; y++) {
+    uint32_t copyWidth = (hdr ? width * 2 : width);
+
+    memcpy(&out_y[y * out_y_stride], &in_y[y * in_y_stride], copyWidth);
+
+    if (has_alpha) {
+      uint32_t alphaCopyWidth = (bpp_a > 8 ? width * 2 : width);
+      memcpy(&out_a[y * out_a_stride], &in_a[y * in_a_stride], alphaCopyWidth);
+    }
+  }
+
+  return outimg;
+}
+
+template class Op_YCbCr444_to_YCbCr420_average<uint8_t>;
+template class Op_YCbCr444_to_YCbCr420_average<uint16_t>;
+
+
+
+template<class Pixel>
+std::vector<ColorStateWithCost>
+Op_YCbCr444_to_YCbCr422_average<Pixel>::state_after_conversion(const ColorState& input_state,
+                                                               const ColorState& target_state,
+                                                               const heif_color_conversion_options& options,
+                                                               const heif_color_conversion_options_ext& options_ext) const
+{
+  if (input_state.colorspace != heif_colorspace_YCbCr) {
+    return {};
+  }
+
+  if (input_state.chroma != heif_chroma_444) {
+    return {};
+  }
+
+  // this Op only implements the averaging algorithm
+
+  if (options.preferred_chroma_downsampling_algorithm != heif_chroma_downsampling_average) {
+    return {};
+  }
+
+  bool hdr = !std::is_same<Pixel, uint8_t>::value;
+
+  if ((input_state.bits_per_pixel > 8) != hdr) {
+    return {};
+  }
+
+  if (input_state.nclx.get_matrix_coefficients() == 0) {
+    return {};
+  }
+
+  if (target_state.chroma != heif_chroma_422) {
+    return {};
+  }
+
+  std::vector<ColorStateWithCost> states;
+
+  ColorState output_state;
+
+  // --- convert to 4:2:0
+
+  output_state.colorspace = heif_colorspace_YCbCr;
+  output_state.chroma = heif_chroma_422;
+  output_state.has_alpha = input_state.has_alpha;  // we simply keep the old alpha plane
+  output_state.bits_per_pixel = input_state.bits_per_pixel;
+  output_state.nclx = input_state.nclx;
+
+  states.emplace_back(output_state, SpeedCosts_Unoptimized);
+
+  return states;
+}
+
+
+template<class Pixel>
+Result<std::shared_ptr<HeifPixelImage>>
+Op_YCbCr444_to_YCbCr422_average<Pixel>::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                                                           const ColorState& input_state,
+                                                           const ColorState& target_state,
+                                                           const heif_color_conversion_options& options,
+                                                           const heif_color_conversion_options_ext& options_ext,
+                                                           const heif_security_limits* limits) const
+{
+  bool hdr = !std::is_same<Pixel, uint8_t>::value;
+
+  int bpp_y = input->get_bits_per_pixel(heif_channel_Y);
+  int bpp_cb = input->get_bits_per_pixel(heif_channel_Cb);
+  int bpp_cr = input->get_bits_per_pixel(heif_channel_Cr);
+  int bpp_a = 0;
+
+  bool has_alpha = input->has_channel(heif_channel_Alpha);
+
+  if (has_alpha) {
+    bpp_a = input->get_bits_per_pixel(heif_channel_Alpha);
+  }
+
+  if (!hdr) {
+    if (bpp_y > 8 ||
+        bpp_cb > 8 ||
+        bpp_cr > 8) {
+      return Error::InternalError;
+    }
+  }
+  else {
+    if (bpp_y <= 8 ||
+        bpp_cb <= 8 ||
+        bpp_cr <= 8) {
+      return Error::InternalError;
+    }
+  }
+
+
+  if (bpp_y != bpp_cb ||
+      bpp_y != bpp_cr) {
+    // TODO: test with varying bit depths when we have a test image
+    return Error::InternalError;
+  }
+
+
+  uint32_t width = input->get_width();
+  uint32_t height = input->get_height();
+
+  auto outimg = std::make_shared<HeifPixelImage>();
+
+  outimg->create(width, height, heif_colorspace_YCbCr, heif_chroma_422);
+
+  uint32_t cwidth = (width + 1) / 2;
+  uint32_t cheight = height;
+
+  if (auto err = outimg->add_plane(heif_channel_Y, width, height, bpp_y, limits) ||
+                 outimg->add_plane(heif_channel_Cb, cwidth, cheight, bpp_cb, limits) ||
+                 outimg->add_plane(heif_channel_Cr, cwidth, cheight, bpp_cr, limits)) {
+    return err;
+  }
+
+  if (has_alpha) {
+    if (auto err = outimg->add_plane(heif_channel_Alpha, width, height, bpp_a, limits)) {
+      return err;
+    }
+  }
+
+  const Pixel* in_y, * in_cb, * in_cr;
+  size_t in_y_stride = 0, in_cb_stride = 0, in_cr_stride = 0, in_a_stride = 0;
+
+  Pixel* out_y, * out_cb, * out_cr;
+  size_t out_y_stride = 0, out_cb_stride = 0, out_cr_stride = 0, out_a_stride = 0;
+
+  in_y = (const Pixel*) input->get_plane(heif_channel_Y, &in_y_stride);
+  in_cb = (const Pixel*) input->get_plane(heif_channel_Cb, &in_cb_stride);
+  in_cr = (const Pixel*) input->get_plane(heif_channel_Cr, &in_cr_stride);
+  out_y = (Pixel*) outimg->get_plane(heif_channel_Y, &out_y_stride);
+  out_cb = (Pixel*) outimg->get_plane(heif_channel_Cb, &out_cb_stride);
+  out_cr = (Pixel*) outimg->get_plane(heif_channel_Cr, &out_cr_stride);
+
+  const uint8_t* in_a;
+  uint8_t* out_a;
+
+  if (has_alpha) {
+    in_a = input->get_plane(heif_channel_Alpha, &in_a_stride);
+    out_a = outimg->get_plane(heif_channel_Alpha, &out_a_stride);
+  }
+  else {
+    in_a = nullptr;
+    out_a = nullptr;
+  }
+
+
+  if (hdr) {
+    in_y_stride /= 2;
+    in_cb_stride /= 2;
+    in_cr_stride /= 2;
+    out_y_stride /= 2;
+    out_cb_stride /= 2;
+    out_cr_stride /= 2;
+  }
+
+  // --- fill right border if the image size is odd
+
+  if (width & 1) {
+    for (uint32_t y = 0; y < height - 1; y++) {
+      out_cb[y * out_cb_stride + cwidth - 1] = (Pixel) in_cb[y * in_cb_stride + width - 1];
+      out_cr[y * out_cr_stride + cwidth - 1] = (Pixel) in_cr[y * in_cr_stride + width - 1];
+    }
+  }
+
+
+  // --- averaging filter
+
+  uint32_t x, y;
+  for (y = 0; y < height; y++) {
+    for (x = 0; x < width - 1; x += 2) {
+      Pixel cb00 = in_cb[y * in_cb_stride + x];
+      Pixel cr00 = in_cr[y * in_cr_stride + x];
+      Pixel cb01 = in_cb[y * in_cb_stride + x + 1];
+      Pixel cr01 = in_cr[y * in_cr_stride + x + 1];
+
+      out_cb[y * out_cb_stride + x / 2] = (Pixel) ((cb00 + cb01 + 1) / 2);
+      out_cr[y * out_cr_stride + x / 2] = (Pixel) ((cr00 + cr01 + 1) / 2);
+    }
+  }
+
+  // TODO: check whether we can use HeifPixelImage::transfer_plane_from_image_as() instead of copying Y and Alpha
+
+  for (y = 0; y < height; y++) {
+    uint32_t copyWidth = (hdr ? width * 2 : width);
+
+    memcpy(&out_y[y * out_y_stride], &in_y[y * in_y_stride], copyWidth);
+
+    if (has_alpha) {
+      uint32_t alphaCopyWidth = (bpp_a>8 ? width * 2 : width);
+      memcpy(&out_a[y * out_a_stride], &in_a[y * in_a_stride], alphaCopyWidth);
+    }
+  }
+
+  return outimg;
+}
+
+template class Op_YCbCr444_to_YCbCr422_average<uint8_t>;
+template class Op_YCbCr444_to_YCbCr422_average<uint16_t>;
+
+
+
+template<class Pixel>
+std::vector<ColorStateWithCost>
+Op_YCbCr420_bilinear_to_YCbCr444<Pixel>::state_after_conversion(const ColorState& input_state,
+                                                                const ColorState& target_state,
+                                                                const heif_color_conversion_options& options,
+                                                                const heif_color_conversion_options_ext& options_ext) const
+{
+  if (input_state.colorspace != heif_colorspace_YCbCr) {
+    return {};
+  }
+
+  if (input_state.chroma != heif_chroma_420) {
+    return {};
+  }
+
+  // this Op only implements the bilinear algorithm
+
+  if (options.preferred_chroma_upsampling_algorithm != heif_chroma_upsampling_bilinear) {
+    return {};
+  }
+
+  bool hdr = !std::is_same<Pixel, uint8_t>::value;
+
+  if ((input_state.bits_per_pixel > 8) != hdr) {
+    return {};
+  }
+
+  if (input_state.nclx.get_matrix_coefficients() == 0) {
+    return {};
+  }
+
+  std::vector<ColorStateWithCost> states;
+
+  ColorState output_state;
+
+  // --- convert to 4:4:4
+
+  output_state.colorspace = heif_colorspace_YCbCr;
+  output_state.chroma = heif_chroma_444;
+  output_state.has_alpha = input_state.has_alpha;  // we simply keep the old alpha plane
+  output_state.bits_per_pixel = input_state.bits_per_pixel;
+  output_state.nclx = input_state.nclx;
+
+  states.emplace_back(output_state, SpeedCosts_Unoptimized);
+
+  return states;
+}
+
+
+template<class Pixel>
+Result<std::shared_ptr<HeifPixelImage>>
+Op_YCbCr420_bilinear_to_YCbCr444<Pixel>::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                                                            const ColorState& input_state,
+                                                            const ColorState& target_state,
+                                                            const heif_color_conversion_options& options,
+                                                            const heif_color_conversion_options_ext& options_ext,
+                                                            const heif_security_limits* limits) const
+{
+  bool hdr = !std::is_same<Pixel, uint8_t>::value;
+
+  int bpp_y = input->get_bits_per_pixel(heif_channel_Y);
+  int bpp_cb = input->get_bits_per_pixel(heif_channel_Cb);
+  int bpp_cr = input->get_bits_per_pixel(heif_channel_Cr);
+  int bpp_a = 0;
+
+  bool has_alpha = input->has_channel(heif_channel_Alpha);
+
+  if (has_alpha) {
+    bpp_a = input->get_bits_per_pixel(heif_channel_Alpha);
+  }
+
+  if (!hdr) {
+    if (bpp_y > 8 ||
+        bpp_cb > 8 ||
+        bpp_cr > 8) {
+      return Error::InternalError;
+    }
+  }
+  else {
+    if (bpp_y <= 8 ||
+        bpp_cb <= 8 ||
+        bpp_cr <= 8) {
+      return Error::InternalError;
+    }
+  }
+
+
+  if (bpp_y != bpp_cb ||
+      bpp_y != bpp_cr) {
+    // TODO: test with varying bit depths when we have a test image
+    return Error::InternalError;
+  }
+
+
+  uint32_t width = input->get_width();
+  uint32_t height = input->get_height();
+
+  auto outimg = std::make_shared<HeifPixelImage>();
+
+  outimg->create(width, height, heif_colorspace_YCbCr, heif_chroma_444);
+
+  if (auto err = outimg->add_plane(heif_channel_Y, width, height, bpp_y, limits) ||
+                 outimg->add_plane(heif_channel_Cb, width, height, bpp_cb, limits) ||
+                 outimg->add_plane(heif_channel_Cr, width, height, bpp_cr, limits)) {
+    return err;
+  }
+
+  if (has_alpha) {
+    if (auto err = outimg->add_plane(heif_channel_Alpha, width, height, bpp_a, limits)) {
+      return err;
+    }
+  }
+
+  const Pixel* in_y, * in_cb, * in_cr;
+  size_t in_y_stride = 0, in_cb_stride = 0, in_cr_stride = 0, in_a_stride = 0;
+
+  Pixel* out_y, * out_cb, * out_cr;
+  size_t out_y_stride = 0, out_cb_stride = 0, out_cr_stride = 0, out_a_stride = 0;
+
+  in_y = (const Pixel*) input->get_plane(heif_channel_Y, &in_y_stride);
+  in_cb = (const Pixel*) input->get_plane(heif_channel_Cb, &in_cb_stride);
+  in_cr = (const Pixel*) input->get_plane(heif_channel_Cr, &in_cr_stride);
+  out_y = (Pixel*) outimg->get_plane(heif_channel_Y, &out_y_stride);
+  out_cb = (Pixel*) outimg->get_plane(heif_channel_Cb, &out_cb_stride);
+  out_cr = (Pixel*) outimg->get_plane(heif_channel_Cr, &out_cr_stride);
+
+  const uint8_t* in_a;
+  uint8_t* out_a;
+
+  if (has_alpha) {
+    in_a = input->get_plane(heif_channel_Alpha, &in_a_stride);
+    out_a = outimg->get_plane(heif_channel_Alpha, &out_a_stride);
+  }
+  else {
+    in_a = nullptr;
+    out_a = nullptr;
+  }
+
+
+  if (hdr) {
+    in_y_stride /= 2;
+    in_cb_stride /= 2;
+    in_cr_stride /= 2;
+    out_y_stride /= 2;
+    out_cb_stride /= 2;
+    out_cr_stride /= 2;
+  }
+
+  /*
+   *  We assume that chroma pixels are located in the center of 2x2 luma pixels.
+   *  The image border 'b' is handled separately.
+   *  The right and bottom border are not processed when the size is odd.
+   *  Then, each 2x2 square between 4 chroma samples is computed in one iteration.
+   *
+   *  Upsampling weights are 3/4, 1/4. For example:
+   *    A = 3/4*3/4 * C1 + 3/4*1/4 * C2 + 1/4*3/4 * C3 + 1/4*1/4 * C4
+   *
+   *    +---+---+---+---+
+   *    | b | b | b | b |
+   *    +---C1--+---C2--+
+   *    | b | A |   | b |
+   *    +---+---+---+---+
+   *    | b |   |   | b |
+   *    +---C3--+---C4--+
+   *    | b | b | b | b |
+   *    +---+---+---+---+
+   */
+
+  // --- fill borders
+
+  // top left corner
+  out_cb[0] = in_cb[0];
+  out_cr[0] = in_cr[0];
+
+  // top border
+  for (uint32_t cx = 0; cx < (width - 1) / 2; cx++) {
+    out_cb[0 * out_cb_stride + 2 * cx + 1] = (Pixel) ((3 * in_cb[cx / 2] + 1 * in_cb[cx / 2 + 1] + 2) / 4);
+    out_cb[0 * out_cb_stride + 2 * cx + 2] = (Pixel) ((1 * in_cb[cx / 2] + 3 * in_cb[cx / 2 + 1] + 2) / 4);
+    out_cr[0 * out_cr_stride + 2 * cx + 1] = (Pixel) ((3 * in_cr[cx / 2] + 1 * in_cr[cx / 2 + 1] + 2) / 4);
+    out_cr[0 * out_cr_stride + 2 * cx + 2] = (Pixel) ((1 * in_cr[cx / 2] + 3 * in_cr[cx / 2 + 1] + 2) / 4);
+  }
+
+  // top right corner
+  if (width % 2 == 0) {
+    out_cb[width - 1] = in_cb[width / 2 - 1];
+    out_cr[width - 1] = in_cr[width / 2 - 1];
+  }
+
+  // left border
+  for (uint32_t cy = 0; cy < (height - 1) / 2; cy++) {
+    out_cb[(2 * cy + 1) * out_cb_stride + 0] = (Pixel) ((3 * in_cb[cy / 2 * in_cb_stride] + 1 * in_cb[(cy / 2 + 1) * in_cb_stride] + 2) / 4);
+    out_cb[(2 * cy + 2) * out_cb_stride + 0] = (Pixel) ((1 * in_cb[cy / 2 * in_cb_stride] + 3 * in_cb[(cy / 2 + 1) * in_cb_stride] + 2) / 4);
+    out_cr[(2 * cy + 1) * out_cr_stride + 0] = (Pixel) ((3 * in_cr[cy / 2 * in_cr_stride] + 1 * in_cr[(cy / 2 + 1) * in_cr_stride] + 2) / 4);
+    out_cr[(2 * cy + 2) * out_cr_stride + 0] = (Pixel) ((1 * in_cr[cy / 2 * in_cr_stride] + 3 * in_cr[(cy / 2 + 1) * in_cr_stride] + 2) / 4);
+  }
+
+  // bottom left corner
+  if (height % 2 == 0) {
+    out_cb[(height - 1) * out_cb_stride] = in_cb[(height / 2 - 1) * in_cb_stride];
+    out_cr[(height - 1) * out_cr_stride] = in_cr[(height / 2 - 1) * in_cr_stride];
+  }
+
+  // right border
+  if (width % 2 == 0) {
+    for (uint32_t cy = 0; cy < (height - 1) / 2; cy++) {
+      out_cb[(2 * cy + 1) * out_cb_stride + width - 1] = (Pixel) ((3 * in_cb[cy / 2 * in_cb_stride + width / 2 - 1] + 1 * in_cb[(cy / 2 + 1) * in_cb_stride + width / 2 - 1] + 2) / 4);
+      out_cb[(2 * cy + 2) * out_cb_stride + width - 1] = (Pixel) ((1 * in_cb[cy / 2 * in_cb_stride + width / 2 - 1] + 3 * in_cb[(cy / 2 + 1) * in_cb_stride + width / 2 - 1] + 2) / 4);
+      out_cr[(2 * cy + 1) * out_cr_stride + width - 1] = (Pixel) ((3 * in_cr[cy / 2 * in_cr_stride + width / 2 - 1] + 1 * in_cr[(cy / 2 + 1) * in_cr_stride + width / 2 - 1] + 2) / 4);
+      out_cr[(2 * cy + 2) * out_cr_stride + width - 1] = (Pixel) ((1 * in_cr[cy / 2 * in_cr_stride + width / 2 - 1] + 3 * in_cr[(cy / 2 + 1) * in_cr_stride + width / 2 - 1] + 2) / 4);
+    }
+  }
+
+  // bottom border
+  if (height % 2 == 0) {
+    for (uint32_t cx = 0; cx < (width - 1) / 2; cx++) {
+      out_cb[(height - 1) * out_cb_stride + 2 * cx + 1] = (Pixel) ((3 * in_cb[(height / 2 - 1) * in_cb_stride + cx / 2] + 1 * in_cb[(height / 2 - 1) * in_cb_stride + cx / 2 + 1] + 2) / 4);
+      out_cb[(height - 1) * out_cb_stride + 2 * cx + 2] = (Pixel) ((1 * in_cb[(height / 2 - 1) * in_cb_stride + cx / 2] + 3 * in_cb[(height / 2 - 1) * in_cb_stride + cx / 2 + 1] + 2) / 4);
+      out_cr[(height - 1) * out_cr_stride + 2 * cx + 1] = (Pixel) ((3 * in_cr[(height / 2 - 1) * in_cr_stride + cx / 2] + 1 * in_cr[(height / 2 - 1) * in_cr_stride + cx / 2 + 1] + 2) / 4);
+      out_cr[(height - 1) * out_cr_stride + 2 * cx + 2] = (Pixel) ((1 * in_cr[(height / 2 - 1) * in_cr_stride + cx / 2] + 3 * in_cr[(height / 2 - 1) * in_cr_stride + cx / 2 + 1] + 2) / 4);
+    }
+  }
+
+  // bottom right corner
+  if (width % 2 == 0 && height % 2 == 0) {
+    out_cb[(height - 1) * out_cb_stride + width - 1] = in_cb[(height / 2 - 1) * in_cb_stride + width / 2 - 1];
+    out_cr[(height - 1) * out_cr_stride + width - 1] = in_cr[(height / 2 - 1) * in_cr_stride + width / 2 - 1];
+  }
+
+
+  // --- bilinear filtering of inner part
+
+  uint32_t x, y;
+  for (y = 1; y < height - 1; y += 2) {
+    for (x = 1; x < width - 1; x += 2) {
+      uint32_t cx = x / 2;
+      uint32_t cy = y / 2;
+
+      Pixel cb00 = in_cb[cy * in_cb_stride + cx];
+      Pixel cr00 = in_cr[cy * in_cr_stride + cx];
+      Pixel cb01 = in_cb[cy * in_cb_stride + cx + 1];
+      Pixel cr01 = in_cr[cy * in_cr_stride + cx + 1];
+      Pixel cb10 = in_cb[(cy + 1) * in_cb_stride + cx];
+      Pixel cr10 = in_cr[(cy + 1) * in_cr_stride + cx];
+      Pixel cb11 = in_cb[(cy + 1) * in_cb_stride + cx + 1];
+      Pixel cr11 = in_cr[(cy + 1) * in_cr_stride + cx + 1];
+
+      out_cb[(y + 0) * out_cb_stride + x + 0] = (Pixel) ((cb00 * 3 * 3 + cb01 * 1 * 3 + cb10 * 3 * 1 + cb11 * 1 * 1 + 8) / 16);
+      out_cb[(y + 0) * out_cb_stride + x + 1] = (Pixel) ((cb00 * 1 * 3 + cb01 * 3 * 3 + cb10 * 1 * 1 + cb11 * 3 * 1 + 8) / 16);
+      out_cb[(y + 1) * out_cb_stride + x + 0] = (Pixel) ((cb00 * 3 * 1 + cb01 * 1 * 1 + cb10 * 3 * 3 + cb11 * 1 * 3 + 8) / 16);
+      out_cb[(y + 1) * out_cb_stride + x + 1] = (Pixel) ((cb00 * 1 * 1 + cb01 * 3 * 1 + cb10 * 1 * 3 + cb11 * 3 * 3 + 8) / 16);
+
+      out_cr[(y + 0) * out_cr_stride + x + 0] = (Pixel) ((cr00 * 3 * 3 + cr01 * 1 * 3 + cr10 * 3 * 1 + cr11 * 1 * 1 + 8) / 16);
+      out_cr[(y + 0) * out_cr_stride + x + 1] = (Pixel) ((cr00 * 1 * 3 + cr01 * 3 * 3 + cr10 * 1 * 1 + cr11 * 3 * 1 + 8) / 16);
+      out_cr[(y + 1) * out_cr_stride + x + 0] = (Pixel) ((cr00 * 3 * 1 + cr01 * 1 * 1 + cr10 * 3 * 3 + cr11 * 1 * 3 + 8) / 16);
+      out_cr[(y + 1) * out_cr_stride + x + 1] = (Pixel) ((cr00 * 1 * 1 + cr01 * 3 * 1 + cr10 * 1 * 3 + cr11 * 3 * 3 + 8) / 16);
+    }
+  }
+
+  // TODO: check whether we can use HeifPixelImage::transfer_plane_from_image_as() instead of copying Y and Alpha
+
+  for (y = 0; y < height; y++) {
+    uint32_t copyWidth = (hdr ? width * 2 : width);
+
+    memcpy(&out_y[y * out_y_stride], &in_y[y * in_y_stride], copyWidth);
+
+    if (has_alpha) {
+      uint32_t alphaCopyWidth = (bpp_a > 8 ? width * 2 : width);
+      memcpy(&out_a[y * out_a_stride], &in_a[y * in_a_stride], alphaCopyWidth);
+    }
+  }
+
+  return outimg;
+}
+
+template class Op_YCbCr420_bilinear_to_YCbCr444<uint8_t>;
+template class Op_YCbCr420_bilinear_to_YCbCr444<uint16_t>;
+
+
+
+
+template<class Pixel>
+std::vector<ColorStateWithCost>
+Op_YCbCr422_bilinear_to_YCbCr444<Pixel>::state_after_conversion(const ColorState& input_state,
+                                                                const ColorState& target_state,
+                                                                const heif_color_conversion_options& options,
+                                                                const heif_color_conversion_options_ext& options_ext) const
+{
+  if (input_state.colorspace != heif_colorspace_YCbCr) {
+    return {};
+  }
+
+  if (input_state.chroma != heif_chroma_422) {
+    return {};
+  }
+
+  // this Op only implements the bilinear algorithm
+
+  if (options.preferred_chroma_upsampling_algorithm != heif_chroma_upsampling_bilinear) {
+    return {};
+  }
+
+  bool hdr = !std::is_same<Pixel, uint8_t>::value;
+
+  if ((input_state.bits_per_pixel > 8) != hdr) {
+    return {};
+  }
+
+  if (input_state.nclx.get_matrix_coefficients() == 0) {
+    return {};
+  }
+
+  std::vector<ColorStateWithCost> states;
+
+  ColorState output_state;
+
+  // --- convert to 4:4:4
+
+  output_state.colorspace = heif_colorspace_YCbCr;
+  output_state.chroma = heif_chroma_444;
+  output_state.has_alpha = input_state.has_alpha;  // we simply keep the old alpha plane
+  output_state.bits_per_pixel = input_state.bits_per_pixel;
+  output_state.nclx = input_state.nclx;
+
+  states.emplace_back(output_state, SpeedCosts_Unoptimized);
+
+  return states;
+}
+
+
+template<class Pixel>
+Result<std::shared_ptr<HeifPixelImage>>
+Op_YCbCr422_bilinear_to_YCbCr444<Pixel>::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                                                            const ColorState& input_state,
+                                                            const ColorState& target_state,
+                                                            const heif_color_conversion_options& options,
+                                                            const heif_color_conversion_options_ext& options_ext,
+                                                            const heif_security_limits* limits) const
+{
+  bool hdr = !std::is_same<Pixel, uint8_t>::value;
+
+  int bpp_y = input->get_bits_per_pixel(heif_channel_Y);
+  int bpp_cb = input->get_bits_per_pixel(heif_channel_Cb);
+  int bpp_cr = input->get_bits_per_pixel(heif_channel_Cr);
+  int bpp_a = 0;
+
+  bool has_alpha = input->has_channel(heif_channel_Alpha);
+
+  if (has_alpha) {
+    bpp_a = input->get_bits_per_pixel(heif_channel_Alpha);
+  }
+
+  if (!hdr) {
+    if (bpp_y > 8 ||
+        bpp_cb > 8 ||
+        bpp_cr > 8) {
+      return Error::InternalError;
+    }
+  }
+  else {
+    if (bpp_y <= 8 ||
+        bpp_cb <= 8 ||
+        bpp_cr <= 8) {
+      return Error::InternalError;
+    }
+  }
+
+
+  if (bpp_y != bpp_cb ||
+      bpp_y != bpp_cr) {
+    // TODO: test with varying bit depths when we have a test image
+    return Error::InternalError;
+  }
+
+
+  uint32_t width = input->get_width();
+  uint32_t height = input->get_height();
+
+  auto outimg = std::make_shared<HeifPixelImage>();
+
+  outimg->create(width, height, heif_colorspace_YCbCr, heif_chroma_444);
+
+  if (auto err = outimg->add_plane(heif_channel_Y, width, height, bpp_y, limits) ||
+                 outimg->add_plane(heif_channel_Cb, width, height, bpp_cb, limits) ||
+                 outimg->add_plane(heif_channel_Cr, width, height, bpp_cr, limits)) {
+    return err;
+  }
+
+  if (has_alpha) {
+    if (auto err = outimg->add_plane(heif_channel_Alpha, width, height, bpp_a, limits)) {
+      return err;
+    }
+  }
+
+  const Pixel* in_y, * in_cb, * in_cr;
+  size_t in_y_stride = 0, in_cb_stride = 0, in_cr_stride = 0, in_a_stride = 0;
+
+  Pixel* out_y, * out_cb, * out_cr;
+  size_t out_y_stride = 0, out_cb_stride = 0, out_cr_stride = 0, out_a_stride = 0;
+
+  in_y = (const Pixel*) input->get_plane(heif_channel_Y, &in_y_stride);
+  in_cb = (const Pixel*) input->get_plane(heif_channel_Cb, &in_cb_stride);
+  in_cr = (const Pixel*) input->get_plane(heif_channel_Cr, &in_cr_stride);
+  out_y = (Pixel*) outimg->get_plane(heif_channel_Y, &out_y_stride);
+  out_cb = (Pixel*) outimg->get_plane(heif_channel_Cb, &out_cb_stride);
+  out_cr = (Pixel*) outimg->get_plane(heif_channel_Cr, &out_cr_stride);
+
+  const uint8_t* in_a;
+  uint8_t* out_a;
+
+  if (has_alpha) {
+    in_a = input->get_plane(heif_channel_Alpha, &in_a_stride);
+    out_a = outimg->get_plane(heif_channel_Alpha, &out_a_stride);
+  }
+  else {
+    in_a = nullptr;
+    out_a = nullptr;
+  }
+
+
+  if (hdr) {
+    in_y_stride /= 2;
+    in_cb_stride /= 2;
+    in_cr_stride /= 2;
+    out_y_stride /= 2;
+    out_cb_stride /= 2;
+    out_cr_stride /= 2;
+  }
+
+  /*
+   *  We assume that chroma pixels are located in the center of 2x1 luma pixels.
+   *  The image border 'b' is handled separately.
+   *  The right border is not processed when the size is odd.
+   *
+   *  Upsampling weights are 3/4, 1/4. For example:
+   *    A = 3/4 * X + 1/4 * Y
+   *
+   *  X,Y,Z are the chroma samples
+   *
+   *    +---+---+---+---+
+   *    | b X A | B Y b |    even image width
+   *    +---+---+---+---+
+   *
+   *    +---+---+---+---+---+
+   *    | b X A | B Y b | b Z    odd image width
+   *    +---+---+---+---+---+
+   */
+
+  // --- fill borders
+
+  // left border
+  for (uint32_t cy = 0; cy < height; cy++) {
+    out_cb[cy * out_cb_stride] = in_cb[cy * in_cb_stride];
+    out_cr[cy * out_cr_stride] = in_cr[cy * in_cr_stride];
+  }
+
+  // right border
+  if (width % 2 == 0) {
+    for (uint32_t cy = 0; cy < height; cy++) {
+      out_cb[cy * out_cb_stride + width - 1] = in_cb[cy * in_cb_stride + width / 2 - 1];
+      out_cr[cy * out_cr_stride + width - 1] = in_cr[cy * in_cr_stride + width / 2 - 1];
+    }
+  }
+
+
+  // --- bilinear filtering of inner part
+
+  uint32_t x, y;
+  for (y = 0; y < height; y++) {
+    for (x = 1; x < width - 1; x += 2) {
+      int cx = x / 2;
+
+      Pixel cb00 = in_cb[y * in_cb_stride + cx];
+      Pixel cr00 = in_cr[y * in_cr_stride + cx];
+      Pixel cb01 = in_cb[y * in_cb_stride + cx + 1];
+      Pixel cr01 = in_cr[y * in_cr_stride + cx + 1];
+
+      out_cb[y * out_cb_stride + x + 0] = (Pixel) ((cb00 * 3 + cb01 * 1 + 2) / 4);
+      out_cb[y * out_cb_stride + x + 1] = (Pixel) ((cb00 * 1 + cb01 * 3 + 2) / 4);
+
+      out_cr[y * out_cr_stride + x + 0] = (Pixel) ((cr00 * 3 + cr01 * 1 + 2) / 4);
+      out_cr[y * out_cr_stride + x + 1] = (Pixel) ((cr00 * 1 + cr01 * 3 + 2) / 4);
+    }
+  }
+
+  // TODO: check whether we can use HeifPixelImage::transfer_plane_from_image_as() instead of copying Y and Alpha
+
+  for (y = 0; y < height; y++) {
+    uint32_t copyWidth = (hdr ? width * 2 : width);
+
+    memcpy(&out_y[y * out_y_stride], &in_y[y * in_y_stride], copyWidth);
+
+    if (has_alpha) {
+      uint32_t alphaCopyWidth = (bpp_a > 8 ? width * 2 : width);
+      memcpy(&out_a[y * out_a_stride], &in_a[y * in_a_stride], alphaCopyWidth);
+    }
+  }
+
+  return outimg;
+}
+
+template class Op_YCbCr422_bilinear_to_YCbCr444<uint8_t>;
+template class Op_YCbCr422_bilinear_to_YCbCr444<uint16_t>;
diff --git a/libheif/color-conversion/chroma_sampling.h b/libheif/color-conversion/chroma_sampling.h
new file mode 100644
index 0000000000..4f90719290
--- /dev/null
+++ b/libheif/color-conversion/chroma_sampling.h
@@ -0,0 +1,111 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_CHROMA_SAMPLING_H
+#define LIBHEIF_CHROMA_SAMPLING_H
+
+#include "color-conversion/colorconversion.h"
+#include <memory>
+#include <vector>
+
+
+// --- downsampling ---
+
+template <class Pixel>
+class Op_YCbCr444_to_YCbCr420_average : public ColorConversionOperation
+{
+public:
+  std::vector<ColorStateWithCost>
+  state_after_conversion(const ColorState& input_state,
+                         const ColorState& target_state,
+                         const heif_color_conversion_options& options,
+                         const heif_color_conversion_options_ext& options_ext) const override;
+
+  Result<std::shared_ptr<HeifPixelImage>>
+  convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                     const ColorState& input_state,
+                     const ColorState& target_state,
+                     const heif_color_conversion_options& options,
+                     const heif_color_conversion_options_ext& options_ext,
+                     const heif_security_limits* limits) const override;
+};
+
+
+template <class Pixel>
+class Op_YCbCr444_to_YCbCr422_average : public ColorConversionOperation
+{
+public:
+  std::vector<ColorStateWithCost>
+  state_after_conversion(const ColorState& input_state,
+                         const ColorState& target_state,
+                         const heif_color_conversion_options& options,
+                         const heif_color_conversion_options_ext& options_ext) const override;
+
+  Result<std::shared_ptr<HeifPixelImage>>
+  convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                     const ColorState& input_state,
+                     const ColorState& target_state,
+                     const heif_color_conversion_options& options,
+                     const heif_color_conversion_options_ext& options_ext,
+                     const heif_security_limits* limits) const override;
+};
+
+
+// --- upsampling ---
+
+template <class Pixel>
+class Op_YCbCr420_bilinear_to_YCbCr444 : public ColorConversionOperation
+{
+public:
+  std::vector<ColorStateWithCost>
+  state_after_conversion(const ColorState& input_state,
+                         const ColorState& target_state,
+                         const heif_color_conversion_options& options,
+                         const heif_color_conversion_options_ext& options_ext) const override;
+
+  Result<std::shared_ptr<HeifPixelImage>>
+  convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                     const ColorState& input_state,
+                     const ColorState& target_state,
+                     const heif_color_conversion_options& options,
+                     const heif_color_conversion_options_ext& options_ext,
+                     const heif_security_limits* limits) const override;
+};
+
+template <class Pixel>
+class Op_YCbCr422_bilinear_to_YCbCr444 : public ColorConversionOperation
+{
+public:
+  std::vector<ColorStateWithCost>
+  state_after_conversion(const ColorState& input_state,
+                         const ColorState& target_state,
+                         const heif_color_conversion_options& options,
+                         const heif_color_conversion_options_ext& options_ext) const override;
+
+  Result<std::shared_ptr<HeifPixelImage>>
+  convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                     const ColorState& input_state,
+                     const ColorState& target_state,
+                     const heif_color_conversion_options& options,
+                     const heif_color_conversion_options_ext& options_ext,
+                     const heif_security_limits* limits) const override;
+};
+
+#endif //LIBHEIF_CHROMA_SAMPLING_H
diff --git a/libheif/color-conversion/colorconversion.cc b/libheif/color-conversion/colorconversion.cc
new file mode 100644
index 0000000000..1c0be8a5fa
--- /dev/null
+++ b/libheif/color-conversion/colorconversion.cc
@@ -0,0 +1,628 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+
+#include "colorconversion.h"
+#include "common_utils.h"
+#include "nclx.h"
+#include <typeinfo>
+#include <algorithm>
+#include <cstring>
+#include <cassert>
+#include <iostream>
+#include <set>
+#include <cmath>
+#include <limits>
+#include <string>
+#include "rgb2yuv.h"
+#include "rgb2yuv_sharp.h"
+#include "yuv2rgb.h"
+#include "rgb2rgb.h"
+#include "monochrome.h"
+#include "alpha.h"
+#include "hdr_sdr.h"
+#include "chroma_sampling.h"
+#include "bayer_bilinear.h"
+
+#if ENABLE_MULTITHREADING_SUPPORT
+
+#include <mutex>
+
+#endif
+
+#define DEBUG_ME 0
+#define DEBUG_PIPELINE_CREATION 0
+
+#define USE_CENTER_CHROMA_422 0
+
+
+std::ostream& operator<<(std::ostream& ostr, heif_colorspace c)
+{
+  switch (c) {
+    case heif_colorspace_RGB:
+      ostr << "RGB";
+      break;
+    case heif_colorspace_YCbCr:
+      ostr << "YCbCr";
+      break;
+    case heif_colorspace_monochrome:
+      ostr << "mono";
+      break;
+    case heif_colorspace_undefined:
+      ostr << "undefined";
+      break;
+    case heif_colorspace_filter_array:
+      ostr << "filter_array";
+      break;
+    default:
+      assert(false);
+  }
+
+  return ostr;
+}
+
+std::ostream& operator<<(std::ostream& ostr, heif_chroma c)
+{
+  switch (c) {
+    case heif_chroma_420:
+      ostr << "420";
+      break;
+    case heif_chroma_422:
+      ostr << "422";
+      break;
+    case heif_chroma_444:
+      ostr << "444";
+      break;
+    case heif_chroma_monochrome:
+      ostr << "mono";
+      break;
+    case heif_chroma_interleaved_RGB:
+      ostr << "RGB";
+      break;
+    case heif_chroma_interleaved_RGBA:
+      ostr << "RGBA";
+      break;
+    case heif_chroma_interleaved_RRGGBB_BE:
+      ostr << "RRGGBB_BE";
+      break;
+    case heif_chroma_interleaved_RRGGBB_LE:
+      ostr << "RRGGBBB_LE";
+      break;
+    case heif_chroma_interleaved_RRGGBBAA_BE:
+      ostr << "RRGGBBAA_BE";
+      break;
+    case heif_chroma_interleaved_RRGGBBAA_LE:
+      ostr << "RRGGBBBAA_LE";
+      break;
+    case heif_chroma_undefined:
+      ostr << "undefined";
+      break;
+    default:
+      assert(false);
+  }
+
+  return ostr;
+}
+
+#if DEBUG_ME
+
+static void __attribute__ ((unused)) print_spec(std::ostream& ostr, const std::shared_ptr<HeifPixelImage>& img)
+{
+  ostr << "colorspace=" << img->get_colorspace()
+       << " chroma=" << img->get_chroma_format();
+
+  if (img->get_colorspace() == heif_colorspace_RGB) {
+    if (img->get_chroma_format() == heif_chroma_444) {
+      ostr << " bpp(R)=" << ((int) img->get_bits_per_pixel(heif_channel_R));
+    }
+    else {
+      ostr << " bpp(interleaved)=" << ((int) img->get_bits_per_pixel(heif_channel_interleaved));
+    }
+  }
+  else if (img->get_colorspace() == heif_colorspace_YCbCr ||
+           img->get_colorspace() == heif_colorspace_monochrome) {
+    ostr << " bpp(Y)=" << ((int) img->get_bits_per_pixel(heif_channel_Y));
+  }
+
+  ostr << "\n";
+}
+
+#endif
+
+
+bool ColorState::operator==(const ColorState& b) const
+{
+  bool mainParamsMatch = (colorspace == b.colorspace &&
+                          chroma == b.chroma &&
+                          has_alpha == b.has_alpha &&
+                          bits_per_pixel == b.bits_per_pixel);
+
+  if (!mainParamsMatch) {
+    return false;
+  }
+
+  if (colorspace == heif_colorspace_YCbCr) {
+    bool ycbcr_parameters_match = nclx.equal_except_transfer_curve(b.nclx);
+
+    if (!ycbcr_parameters_match) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+
+struct Node
+{
+  Node() = default;
+
+  Node(int prev,
+       const std::shared_ptr<ColorConversionOperation>& _op,
+      //const ColorState& _input_state,
+       const ColorState& _output_state,
+       int _speed_cost)
+  {
+    prev_processed_idx = prev;
+    op = _op;
+    //input_state = _input_state;
+    output_state = _output_state;
+    speed_costs = _speed_cost;
+  }
+
+  int prev_processed_idx = -1;
+  std::shared_ptr<ColorConversionOperation> op;
+  //ColorState input_state;
+  ColorState output_state;
+  int speed_costs;
+};
+
+std::ostream& operator<<(std::ostream& ostr, const ColorState& state)
+{
+  ostr << "colorspace=" << state.colorspace << " chroma=" << state.chroma
+           << " bpp(R)=" << state.bits_per_pixel
+              << " alpha=" << (state.has_alpha ? "yes" : "no");
+
+  if (state.colorspace == heif_colorspace_YCbCr) {
+    ostr << " matrix-coefficients=" << state.nclx.get_matrix_coefficients()
+         << " colour-primaries=" << state.nclx.get_colour_primaries()
+         << " transfer-characteristics=" << state.nclx.get_transfer_characteristics()
+         << " full-range=" << (state.nclx.get_full_range_flag() ? "yes" : "no");
+  }
+
+  return ostr;
+}
+
+std::vector<std::shared_ptr<ColorConversionOperation>> ColorConversionPipeline::m_operation_pool;
+
+void ColorConversionPipeline::init_ops()
+{
+#if ENABLE_MULTITHREADING_SUPPORT
+  static std::mutex init_ops_mutex;
+  std::lock_guard<std::mutex> lock(init_ops_mutex);
+#endif
+  if (!m_operation_pool.empty()) {
+    return;
+  }
+
+  std::vector<std::shared_ptr<ColorConversionOperation>>& ops = m_operation_pool;
+  ops.emplace_back(std::make_shared<Op_RGB_to_RGB24_32>());
+  ops.emplace_back(std::make_shared<Op_RGB24_32_to_RGB>());
+  ops.emplace_back(std::make_shared<Op_YCbCr_to_RGB<uint16_t>>());
+  ops.emplace_back(std::make_shared<Op_YCbCr_to_RGB<uint8_t>>());
+  ops.emplace_back(std::make_shared<Op_YCbCr420_to_RGB24>());
+  ops.emplace_back(std::make_shared<Op_YCbCr420_to_RGB32>());
+  ops.emplace_back(std::make_shared<Op_YCbCr420_to_RRGGBBaa>());
+  ops.emplace_back(std::make_shared<Op_RGB_HDR_to_RRGGBBaa_BE>());
+  ops.emplace_back(std::make_shared<Op_RGB_to_RRGGBBaa_BE>());
+  ops.emplace_back(std::make_shared<Op_mono_to_YCbCr420>());
+  ops.emplace_back(std::make_shared<Op_mono_to_RGB24_32>());
+  ops.emplace_back(std::make_shared<Op_bayer_bilinear_to_RGB24_32>());
+  ops.emplace_back(std::make_shared<Op_RRGGBBaa_swap_endianness>());
+  ops.emplace_back(std::make_shared<Op_RRGGBBaa_BE_to_RGB_HDR>());
+  ops.emplace_back(std::make_shared<Op_RGB24_32_to_YCbCr>());
+  ops.emplace_back(std::make_shared<Op_RGB_to_YCbCr<uint8_t>>());
+  ops.emplace_back(std::make_shared<Op_RGB_to_YCbCr<uint16_t>>());
+  ops.emplace_back(std::make_shared<Op_RRGGBBxx_HDR_to_YCbCr420>());
+  ops.emplace_back(std::make_shared<Op_RGB24_32_to_YCbCr444_GBR>());
+  ops.emplace_back(std::make_shared<Op_drop_alpha_plane>());
+  ops.emplace_back(std::make_shared<Op_flatten_alpha_plane<uint8_t>>());
+  ops.emplace_back(std::make_shared<Op_flatten_alpha_plane<uint16_t>>());
+  ops.emplace_back(std::make_shared<Op_to_hdr_planes>());
+  ops.emplace_back(std::make_shared<Op_to_sdr_planes>());
+  ops.emplace_back(std::make_shared<Op_YCbCr420_bilinear_to_YCbCr444<uint8_t>>());
+  ops.emplace_back(std::make_shared<Op_YCbCr420_bilinear_to_YCbCr444<uint16_t>>());
+  ops.emplace_back(std::make_shared<Op_YCbCr422_bilinear_to_YCbCr444<uint8_t>>());
+  ops.emplace_back(std::make_shared<Op_YCbCr422_bilinear_to_YCbCr444<uint16_t>>());
+  ops.emplace_back(std::make_shared<Op_YCbCr444_to_YCbCr420_average<uint8_t>>());
+  ops.emplace_back(std::make_shared<Op_YCbCr444_to_YCbCr420_average<uint16_t>>());
+  ops.emplace_back(std::make_shared<Op_YCbCr444_to_YCbCr422_average<uint8_t>>());
+  ops.emplace_back(std::make_shared<Op_YCbCr444_to_YCbCr422_average<uint16_t>>());
+  ops.emplace_back(std::make_shared<Op_Any_RGB_to_YCbCr_420_Sharp>());
+}
+
+
+void ColorConversionPipeline::release_ops()
+{
+  m_operation_pool.clear();
+}
+
+
+bool ColorConversionPipeline::construct_pipeline(const ColorState& input_state,
+                                                 const ColorState& target_state,
+                                                 const heif_color_conversion_options& options,
+                                                 const heif_color_conversion_options_ext& options_ext)
+{
+  m_conversion_steps.clear();
+
+  m_options = options;
+  m_options_ext = options_ext;
+
+  if (input_state == target_state) {
+    return true;
+  }
+
+#if DEBUG_ME
+  std::cerr << "--- construct_pipeline\n";
+  std::cerr << "from: " << input_state << "\nto: " << target_state << "\n";
+#endif
+
+  init_ops(); // to be sure these are initialized even without heif_init()
+
+  std::vector<std::shared_ptr<ColorConversionOperation>>& ops = m_operation_pool;
+
+  // --- Dijkstra search for the minimum-cost conversion pipeline
+
+  std::vector<Node> processed_states;
+  std::vector<Node> border_states;
+  border_states.emplace_back(-1, nullptr, input_state, 0);
+
+  while (!border_states.empty()) {
+    int minIdx = -1;
+    int minCost = std::numeric_limits<int>::max();
+    for (int i = 0; i < (int) border_states.size(); i++) {
+      int cost = border_states[i].speed_costs;
+      if (cost < minCost) {
+        minIdx = i;
+        minCost = cost;
+      }
+    }
+
+    assert(minIdx >= 0);
+
+
+    // move minimum-cost border_state into processed_states
+
+    processed_states.push_back(border_states[minIdx]);
+
+    border_states[minIdx] = border_states.back();
+    border_states.pop_back();
+
+#if DEBUG_PIPELINE_CREATION
+    std::cerr << "- expand node: " << processed_states.back().output_state
+        << " with cost " << processed_states.back().speed_costs << " \n";
+#endif
+
+    if (processed_states.back().output_state == target_state) {
+      // end-state found, backtrack path to find conversion pipeline
+
+      size_t idx = processed_states.size() - 1;
+      int len = 0;
+      while (idx > 0) {
+        idx = processed_states[idx].prev_processed_idx;
+        len++;
+      }
+
+      m_conversion_steps.resize(len);
+
+      idx = processed_states.size() - 1;
+      int step = 0;
+      while (idx > 0) {
+        m_conversion_steps[len - 1 - step].operation = processed_states[idx].op;
+        m_conversion_steps[len - 1 - step].output_state = processed_states[idx].output_state;
+        if (step > 0) {
+          m_conversion_steps[len - step].input_state = m_conversion_steps[len - 1 - step].output_state;
+        }
+
+        //printf("cost: %f\n",processed_states[idx].color_state.costs.total(options.criterion));
+        idx = processed_states[idx].prev_processed_idx;
+        step++;
+      }
+
+      m_conversion_steps[0].input_state = input_state;
+
+      assert(m_conversion_steps.back().output_state == target_state);
+
+#if DEBUG_ME
+      std::cerr << debug_dump_pipeline();
+#endif
+
+      return true;
+    }
+
+
+    // expand the node with minimum cost
+
+    for (const auto& op_ptr : ops) {
+
+#if DEBUG_PIPELINE_CREATION
+      auto& op = *op_ptr;
+      std::cerr << "-- apply op: " << typeid(op).name() << "\n";
+#endif
+
+      auto out_states = op_ptr->state_after_conversion(processed_states.back().output_state,
+                                                       target_state,
+                                                       options, options_ext);
+      for (const auto& out_state : out_states) {
+        int new_op_costs = out_state.speed_costs + processed_states.back().speed_costs;
+#if DEBUG_PIPELINE_CREATION
+        std::cerr << "--- " << out_state.color_state << " with cost " << new_op_costs << "\n";
+#endif
+
+        bool state_exists = false;
+        for (const auto& s : processed_states) {
+          if (s.output_state == out_state.color_state) {
+            state_exists = true;
+            break;
+          }
+        }
+
+        if (!state_exists) {
+          for (auto& s : border_states) {
+            if (s.output_state == out_state.color_state) {
+              state_exists = true;
+
+              // if we reached the same border node with a lower cost, replace the border node
+
+              if (s.speed_costs > new_op_costs) {
+                s = {(int) (processed_states.size() - 1),
+                     op_ptr,
+                     out_state.color_state,
+                     out_state.speed_costs};
+
+                s.speed_costs = new_op_costs;
+              }
+              break;
+            }
+          }
+        }
+
+
+        // enter the new output state into the list of border states
+
+        if (!state_exists) {
+          ColorStateWithCost s = out_state;
+          s.speed_costs = s.speed_costs + processed_states.back().speed_costs;
+
+          border_states.emplace_back((int) (processed_states.size() - 1),
+                                     op_ptr,
+                                     s.color_state,
+                                     s.speed_costs);
+        }
+      }
+    }
+  }
+
+  return false;
+}
+
+
+std::string ColorConversionPipeline::debug_dump_pipeline() const
+{
+  std::ostringstream ostr;
+  ostr << "final pipeline has " << m_conversion_steps.size() << " steps:\n";
+  for (const auto& step : m_conversion_steps) {
+    auto& op = *step.operation;
+    ostr << "> " << typeid(op).name() << "\n";
+  }
+  return ostr.str();
+}
+
+
+Result<std::shared_ptr<HeifPixelImage>> ColorConversionPipeline::convert_image(const std::shared_ptr<HeifPixelImage>& input,
+                                                                               const heif_security_limits* limits)
+{
+  std::shared_ptr<HeifPixelImage> in = input;
+  std::shared_ptr<HeifPixelImage> out = in;
+
+  for (const auto& step : m_conversion_steps) {
+
+#if DEBUG_ME
+    std::cerr << "input spec: ";
+    print_spec(std::cerr, in);
+#endif
+
+    auto outResult = step.operation->convert_colorspace(in, step.input_state, step.output_state, m_options, m_options_ext, limits);
+    if (!outResult) {
+      return outResult.error();
+    }
+    else {
+      out = *outResult;
+    }
+
+    // copy metadata over to new image
+    out->forward_all_metadata_from(in);
+
+    // overwrite color profile nclx from color conversion
+    out->set_color_profile_nclx(step.output_state.nclx);
+
+
+    const auto& warnings = in->get_warnings();
+    for (const auto& warning : warnings) {
+      out->add_warning(warning);
+    }
+
+    in = out;
+  }
+
+  return out;
+}
+
+
+Result<std::shared_ptr<HeifPixelImage>> convert_colorspace(const std::shared_ptr<HeifPixelImage>& input,
+                                                           heif_colorspace target_colorspace,
+                                                           heif_chroma target_chroma,
+                                                           const nclx_profile& target_profile,
+                                                           int output_bpp,
+                                                           const heif_color_conversion_options& options,
+                                                           const heif_color_conversion_options_ext* options_ext_optional,
+                                                           const heif_security_limits* limits)
+{
+  std::unique_ptr<heif_color_conversion_options_ext, void(*)(heif_color_conversion_options_ext*)>
+      options_ext(heif_color_conversion_options_ext_alloc(), heif_color_conversion_options_ext_free);
+
+  heif_color_conversion_options_ext_copy(options_ext.get(), options_ext_optional);
+
+
+  // --- check that input image is valid
+
+  uint32_t width = input->get_width();
+  uint32_t height = input->get_height();
+
+  // alpha image should have full image resolution
+
+  if (input->has_channel(heif_channel_Alpha)) {
+    if (input->get_width(heif_channel_Alpha) != width ||
+        input->get_height(heif_channel_Alpha) != height) {
+      return Error::InternalError;
+    }
+  }
+
+  // check for valid target YCbCr chroma formats
+
+  if (target_colorspace == heif_colorspace_YCbCr) {
+    if (target_chroma != heif_chroma_420 &&
+        target_chroma != heif_chroma_422 &&
+        target_chroma != heif_chroma_444) {
+      return Error::InternalError;
+    }
+  }
+
+  // --- prepare conversion
+
+  ColorState input_state;
+  input_state.colorspace = input->get_colorspace();
+  input_state.chroma = input->get_chroma_format();
+  input_state.has_alpha = input->has_channel(heif_channel_Alpha) || is_interleaved_with_alpha(input->get_chroma_format());
+  if (input->has_nclx_color_profile()) {
+    input_state.nclx = input->get_color_profile_nclx();
+  }
+
+  input_state.nclx.replace_undefined_values_with_sRGB_defaults();
+
+  std::set<enum heif_channel> channels = input->get_channel_set();
+  assert(!channels.empty());
+  input_state.bits_per_pixel = input->get_bits_per_pixel(*(channels.begin()));
+
+  ColorState output_state = input_state;
+  output_state.colorspace = target_colorspace;
+  output_state.chroma = target_chroma;
+  output_state.nclx = target_profile;
+
+  // If some output nclx values are unspecified, set them to the same as the input.
+
+  if (output_state.nclx.get_matrix_coefficients() == heif_matrix_coefficients_unspecified) {
+    output_state.nclx.set_matrix_coefficients(input_state.nclx.get_matrix_coefficients());
+  }
+
+  if (output_state.nclx.get_colour_primaries() == heif_color_primaries_unspecified) {
+    output_state.nclx.set_colour_primaries(input_state.nclx.get_colour_primaries());
+  }
+
+  if (output_state.nclx.get_transfer_characteristics() == heif_transfer_characteristic_unspecified) {
+    output_state.nclx.set_transfer_characteristics(input_state.nclx.get_transfer_characteristics());
+  }
+
+  // If we convert to an interleaved format, we want alpha only if present in the
+  // interleaved output format.
+  // For planar formats, we include an alpha plane when included in the input.
+
+  if (num_interleaved_components_per_plane(target_chroma) > 1) {
+    output_state.has_alpha = is_interleaved_with_alpha(target_chroma);
+  }
+  else {
+    if (options_ext->alpha_composition_mode != heif_alpha_composition_mode_none) {
+      output_state.has_alpha = false;
+    }
+    else {
+      output_state.has_alpha = input_state.has_alpha;
+    }
+  }
+
+  if (output_bpp) {
+    output_state.bits_per_pixel = output_bpp;
+  }
+
+
+  // interleaved RGB formats always have to be 8-bit
+
+  if (target_chroma == heif_chroma_interleaved_RGB ||
+      target_chroma == heif_chroma_interleaved_RGBA) {
+    output_state.bits_per_pixel = 8;
+  }
+
+  // interleaved RRGGBB formats have to be >8-bit.
+  // If we don't know a target bit-depth, use 10 bit.
+
+  if ((target_chroma == heif_chroma_interleaved_RRGGBB_LE ||
+       target_chroma == heif_chroma_interleaved_RRGGBB_BE ||
+       target_chroma == heif_chroma_interleaved_RRGGBBAA_LE ||
+       target_chroma == heif_chroma_interleaved_RRGGBBAA_BE) &&
+      output_state.bits_per_pixel <= 8) {
+    output_state.bits_per_pixel = 10;
+  }
+
+  ColorConversionPipeline pipeline;
+  bool success = pipeline.construct_pipeline(input_state, output_state, options, *options_ext);
+  if (!success) {
+    return Error{heif_error_Unsupported_feature,
+                 heif_suberror_Unsupported_color_conversion};
+  }
+
+  if (pipeline.is_nop()) {
+    return input;
+  }
+  else {
+    return pipeline.convert_image(input, limits);
+  }
+}
+
+
+Result<std::shared_ptr<const HeifPixelImage>> convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                                                                 heif_colorspace colorspace,
+                                                                 heif_chroma chroma,
+                                                                 const nclx_profile& target_profile,
+                                                                 int output_bpp,
+                                                                 const heif_color_conversion_options& options,
+                                                                 const heif_color_conversion_options_ext* options_ext,
+                                                                 const heif_security_limits* limits)
+{
+  std::shared_ptr<HeifPixelImage> non_const_input = std::const_pointer_cast<HeifPixelImage>(input);
+
+  auto result = convert_colorspace(non_const_input, colorspace, chroma, target_profile, output_bpp, options, options_ext, limits);
+  if (!result) {
+    return result.error();
+  }
+  else {
+    // TODO: can we simplify this? It's a bit awkward to do these assignments just to get a "const HeifPixelImage".
+    std::shared_ptr<const HeifPixelImage> constImage = *result;
+    return constImage;
+  }
+}
diff --git a/libheif/color-conversion/colorconversion.h b/libheif/color-conversion/colorconversion.h
new file mode 100644
index 0000000000..bc000eba0a
--- /dev/null
+++ b/libheif/color-conversion/colorconversion.h
@@ -0,0 +1,153 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef LIBHEIF_COLORCONVERSION_H
+#define LIBHEIF_COLORCONVERSION_H
+
+#include "pixelimage.h"
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+
+struct ColorState
+{
+  heif_colorspace colorspace = heif_colorspace_undefined;
+  heif_chroma chroma = heif_chroma_undefined;
+  bool has_alpha = false;
+  int bits_per_pixel = 8;
+
+  // ColorConversionOperations can assume that the input and target nclx has no 'unspecified' values
+  // if the colorspace is heif_colorspace_YCbCr. Otherwise, the values should preferably be 'unspecified'.
+  nclx_profile nclx;
+
+  ColorState() = default;
+
+  ColorState(heif_colorspace colorspace, heif_chroma chroma, bool has_alpha, int bits_per_pixel)
+      : colorspace(colorspace), chroma(chroma), has_alpha(has_alpha), bits_per_pixel(bits_per_pixel) {}
+
+  bool operator==(const ColorState&) const;
+};
+
+std::ostream& operator<<(std::ostream& ostr, const ColorState& state);
+
+// These are some integer constants for typical color conversion Op speed costs.
+// The integer value is the speed cost. Any other integer can be assigned to the speed cost.
+enum SpeedCosts
+{
+  SpeedCosts_Trivial = 1,
+  SpeedCosts_Hardware = 2,
+  SpeedCosts_OptimizedSoftware = 5 + 1,
+  SpeedCosts_Unoptimized = 10 + 1,
+  SpeedCosts_Slow = 15 + 1
+};
+
+
+struct ColorStateWithCost
+{
+  ColorStateWithCost(ColorState c, int s) : color_state(std::move(c)), speed_costs(s) {}
+
+  ColorState color_state;
+
+  int speed_costs;
+};
+
+
+class ColorConversionOperation
+{
+public:
+  virtual ~ColorConversionOperation() = default;
+
+  // We specify the target state to control the conversion into a direction that is most
+  // suitable for reaching the target state. That allows one conversion operation to
+  // provide a range of conversion options.
+  // Also returns the cost for this conversion.
+  virtual std::vector<ColorStateWithCost>
+  state_after_conversion(const ColorState& input_state,
+                         const ColorState& target_state,
+                         const heif_color_conversion_options& options,
+                         const heif_color_conversion_options_ext& options_ext) const = 0;
+
+  virtual Result<std::shared_ptr<HeifPixelImage>>
+  convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                     const ColorState& input_state,
+                     const ColorState& target_state,
+                     const heif_color_conversion_options& options,
+                     const heif_color_conversion_options_ext& options_ext,
+                     const heif_security_limits* limits) const = 0;
+};
+
+
+class ColorConversionPipeline
+{
+public:
+  static void init_ops();
+  static void release_ops();
+
+  bool is_nop() const { return m_conversion_steps.empty(); }
+
+  bool construct_pipeline(const ColorState& input_state,
+                          const ColorState& target_state,
+                          const heif_color_conversion_options& options,
+                          const heif_color_conversion_options_ext& options_ext);
+
+  Result<std::shared_ptr<HeifPixelImage>> convert_image(const std::shared_ptr<HeifPixelImage>& input,
+                                                        const heif_security_limits* limits);
+
+  std::string debug_dump_pipeline() const;
+
+private:
+  static std::vector<std::shared_ptr<ColorConversionOperation>> m_operation_pool;
+
+  struct ConversionStep {
+    std::shared_ptr<ColorConversionOperation> operation;
+    ColorState input_state;
+    ColorState output_state;
+  };
+
+  std::vector<ConversionStep> m_conversion_steps;
+
+  heif_color_conversion_options m_options;
+  heif_color_conversion_options_ext m_options_ext;
+};
+
+
+// If no conversion is required, the input is simply passed through without copy.
+// The input image is never modified by this function, but the input is still non-const because we may pass it through.
+Result<std::shared_ptr<HeifPixelImage>> convert_colorspace(const std::shared_ptr<HeifPixelImage>& input,
+                                                           heif_colorspace colorspace,
+                                                           heif_chroma chroma,
+                                                           const nclx_profile& target_profile,
+                                                           int output_bpp,
+                                                           const heif_color_conversion_options& options,
+                                                           const heif_color_conversion_options_ext* options_ext,
+                                                           const heif_security_limits* limits);
+
+Result<std::shared_ptr<const HeifPixelImage>> convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                                                                 heif_colorspace colorspace,
+                                                                 heif_chroma chroma,
+                                                                 const nclx_profile& target_profile,
+                                                                 int output_bpp,
+                                                                 const heif_color_conversion_options& options,
+                                                                 const heif_color_conversion_options_ext* options_ext,
+                                                                 const heif_security_limits* limits);
+
+#endif
diff --git a/libheif/color-conversion/hdr_sdr.cc b/libheif/color-conversion/hdr_sdr.cc
new file mode 100644
index 0000000000..fa8de4f679
--- /dev/null
+++ b/libheif/color-conversion/hdr_sdr.cc
@@ -0,0 +1,243 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <cassert>
+#include "hdr_sdr.h"
+
+
+std::vector<ColorStateWithCost>
+Op_to_hdr_planes::state_after_conversion(const ColorState& input_state,
+                                         const ColorState& target_state,
+                                         const heif_color_conversion_options& options,
+                                         const heif_color_conversion_options_ext& options_ext) const
+{
+  if ((input_state.chroma != heif_chroma_monochrome &&
+       input_state.chroma != heif_chroma_420 &&
+       input_state.chroma != heif_chroma_422 &&
+       input_state.chroma != heif_chroma_444) ||
+      input_state.bits_per_pixel != 8) { // TODO: support for <8 bpp
+    return {};
+  }
+
+  std::vector<ColorStateWithCost> states;
+
+  ColorState output_state;
+
+  // --- increase bit depth
+
+  output_state = input_state;
+  output_state.bits_per_pixel = target_state.bits_per_pixel;
+
+  states.emplace_back(output_state, SpeedCosts_Unoptimized);
+
+  return states;
+}
+
+
+Result<std::shared_ptr<HeifPixelImage>>
+Op_to_hdr_planes::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                                     const ColorState& input_state,
+                                     const ColorState& target_state,
+                                     const heif_color_conversion_options& options,
+                                     const heif_color_conversion_options_ext& options_ext,
+                                     const heif_security_limits* limits) const
+{
+  auto outimg = std::make_shared<HeifPixelImage>();
+
+  outimg->create(input->get_width(),
+                 input->get_height(),
+                 input->get_colorspace(),
+                 input->get_chroma_format());
+
+  for (heif_channel channel : {heif_channel_Y,
+                               heif_channel_Cb,
+                               heif_channel_Cr,
+                               heif_channel_R,
+                               heif_channel_G,
+                               heif_channel_B,
+                               heif_channel_Alpha}) {
+    if (input->has_channel(channel)) {
+      uint32_t width = input->get_width(channel);
+      uint32_t height = input->get_height(channel);
+      if (auto err = outimg->add_plane(channel, width, height, target_state.bits_per_pixel, limits)) {
+        return err;
+      }
+
+      int input_bits = input->get_bits_per_pixel(channel);
+      int output_bits = target_state.bits_per_pixel;
+
+      int shift1 = output_bits - input_bits;
+      int shift2 = 2 * input_bits - output_bits;
+
+      const uint8_t* p_in;
+      size_t stride_in;
+      p_in = input->get_plane(channel, &stride_in);
+
+      uint16_t* p_out;
+      size_t stride_out;
+      p_out = (uint16_t*) outimg->get_plane(channel, &stride_out);
+      stride_out /= 2;
+
+      for (uint32_t y = 0; y < height; y++)
+        for (uint32_t x = 0; x < width; x++) {
+          int in = p_in[y * stride_in + x];
+          // TODO: support for <8 bpp may need more than two copies of the input bit pattern
+          p_out[y * stride_out + x] = (uint16_t) ((in << shift1) | (in >> shift2));
+        }
+    }
+  }
+
+  return outimg;
+}
+
+
+std::vector<ColorStateWithCost>
+Op_to_sdr_planes::state_after_conversion(const ColorState& input_state,
+                                         const ColorState& target_state,
+                                         const heif_color_conversion_options& options,
+                                         const heif_color_conversion_options_ext& options_ext) const
+{
+  if ((input_state.chroma != heif_chroma_monochrome &&
+       input_state.chroma != heif_chroma_420 &&
+       input_state.chroma != heif_chroma_422 &&
+       input_state.chroma != heif_chroma_444) ||
+      input_state.bits_per_pixel == 8) {
+    return {};
+  }
+
+  if (target_state.bits_per_pixel != 8) {
+    return {};
+  }
+
+  std::vector<ColorStateWithCost> states;
+
+  ColorState output_state;
+
+  // --- output bit depth = 8
+
+  output_state = input_state;
+  output_state.bits_per_pixel = 8;
+
+  states.emplace_back(output_state, SpeedCosts_Unoptimized);
+
+  return states;
+}
+
+
+Result<std::shared_ptr<HeifPixelImage>>
+Op_to_sdr_planes::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                                     const ColorState& input_state,
+                                     const ColorState& target_state,
+                                     const heif_color_conversion_options& options,
+                                     const heif_color_conversion_options_ext& options_ext,
+                                     const heif_security_limits* limits) const
+{
+
+  auto outimg = std::make_shared<HeifPixelImage>();
+
+  outimg->create(input->get_width(),
+                 input->get_height(),
+                 input->get_colorspace(),
+                 input->get_chroma_format());
+
+  for (heif_channel channel : {heif_channel_Y,
+                               heif_channel_Cb,
+                               heif_channel_Cr,
+                               heif_channel_R,
+                               heif_channel_G,
+                               heif_channel_B,
+                               heif_channel_Alpha}) {
+    if (input->has_channel(channel)) {
+      int input_bits = input->get_bits_per_pixel(channel);
+
+      if (input_bits > 8) {
+        uint32_t width = input->get_width(channel);
+        uint32_t height = input->get_height(channel);
+        if (auto err = outimg->add_plane(channel, width, height, 8, limits)) {
+          return err;
+        }
+
+        int shift = input_bits - 8;
+
+        const uint16_t* p_in;
+        size_t stride_in;
+        p_in = (uint16_t*) input->get_plane(channel, &stride_in);
+        stride_in /= 2;
+
+        uint8_t* p_out;
+        size_t stride_out;
+        p_out = outimg->get_plane(channel, &stride_out);
+
+        for (uint32_t y = 0; y < height; y++)
+          for (uint32_t x = 0; x < width; x++) {
+            int in = p_in[y * stride_in + x];
+            p_out[y * stride_out + x] = (uint8_t) (in >> shift); // TODO: I think no rounding here, but am not sure.
+          }
+      } else if (input_bits < 8) {
+        uint32_t width = input->get_width(channel);
+        uint32_t height = input->get_height(channel);
+        if (auto err = outimg->add_plane(channel, width, height, 8, limits)) {
+          return err;
+        }
+
+        // We also want to support converting inputs with < 4 bits per pixel covering the whole output range.
+        // E.g. a 1-bit input should map to the output 0x00 / 0xFF.
+        // We do so by constructing a fixed-point multiplication factor that effectively shifts and combines the input to
+        // a string of bits that completely fills the output.
+        //
+        // Example: input 3 bit.
+        // Factor (binary): 00100100|10010010
+        // Input copies:    AAABBBCC|CDDDEEE0
+        //                  \      /
+        //                   output
+
+        assert(input_bits > 0 && input_bits < 8);
+        auto bit = static_cast<uint16_t>(1 << (16 - input_bits));
+        uint16_t mulFactor = bit;
+
+        for (;;) {
+          bit >>= input_bits;
+          if (!bit) {
+            break;
+          }
+
+          mulFactor |= bit;
+        }
+
+        size_t stride_in;
+        const uint8_t* p_in = input->get_plane(channel, &stride_in);
+
+        size_t stride_out;
+        uint8_t* p_out = outimg->get_plane(channel, &stride_out);
+
+        for (uint32_t y = 0; y < height; y++)
+          for (uint32_t x = 0; x < width; x++) {
+            int in = p_in[y * stride_in + x];
+            p_out[y * stride_out + x] = (uint8_t) ((in * mulFactor) >> 8);
+          }
+      } else {
+        outimg->copy_new_plane_from(input, channel, channel, limits);
+      }
+    }
+  }
+
+  return outimg;
+}
+
diff --git a/libheif/color-conversion/hdr_sdr.h b/libheif/color-conversion/hdr_sdr.h
new file mode 100644
index 0000000000..ffb245d661
--- /dev/null
+++ b/libheif/color-conversion/hdr_sdr.h
@@ -0,0 +1,66 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_COLORCONVERSION_HDR_SDR_H
+#define LIBHEIF_COLORCONVERSION_HDR_SDR_H
+
+
+#include "colorconversion.h"
+#include <vector>
+#include <memory>
+
+class Op_to_hdr_planes : public ColorConversionOperation
+{
+public:
+  std::vector<ColorStateWithCost>
+  state_after_conversion(const ColorState& input_state,
+                         const ColorState& target_state,
+                         const heif_color_conversion_options& options,
+                         const heif_color_conversion_options_ext& options_ext) const override;
+
+  Result<std::shared_ptr<HeifPixelImage>>
+  convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                     const ColorState& input_state,
+                     const ColorState& target_state,
+                     const heif_color_conversion_options& options,
+                     const heif_color_conversion_options_ext& options_ext,
+                     const heif_security_limits* limits) const override;
+};
+
+
+class Op_to_sdr_planes : public ColorConversionOperation
+{
+public:
+  std::vector<ColorStateWithCost>
+  state_after_conversion(const ColorState& input_state,
+                         const ColorState& target_state,
+                         const heif_color_conversion_options& options,
+                         const heif_color_conversion_options_ext& options_ext) const override;
+
+  Result<std::shared_ptr<HeifPixelImage>>
+  convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                     const ColorState& input_state,
+                     const ColorState& target_state,
+                     const heif_color_conversion_options& options,
+                     const heif_color_conversion_options_ext& options_ext,
+                     const heif_security_limits* limits) const override;
+};
+
+#endif //LIBHEIF_COLORCONVERSION_HDR_SDR_H
diff --git a/libheif/color-conversion/monochrome.cc b/libheif/color-conversion/monochrome.cc
new file mode 100644
index 0000000000..064e27169e
--- /dev/null
+++ b/libheif/color-conversion/monochrome.cc
@@ -0,0 +1,283 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <cstring>
+#include "monochrome.h"
+
+
+std::vector<ColorStateWithCost>
+Op_mono_to_YCbCr420::state_after_conversion(const ColorState& input_state,
+                                            const ColorState& target_state,
+                                            const heif_color_conversion_options& options,
+                                            const heif_color_conversion_options_ext& options_ext) const
+{
+  if (input_state.colorspace != heif_colorspace_monochrome ||
+      input_state.chroma != heif_chroma_monochrome) {
+    return {};
+  }
+
+  std::vector<ColorStateWithCost> states;
+
+  ColorState output_state;
+
+  // --- convert to YCbCr420
+
+  output_state.colorspace = heif_colorspace_YCbCr;
+  output_state.chroma = heif_chroma_420;
+  output_state.has_alpha = input_state.has_alpha;
+  output_state.bits_per_pixel = input_state.bits_per_pixel;
+
+  states.emplace_back(output_state, SpeedCosts_OptimizedSoftware);
+
+  return states;
+}
+
+
+Result<std::shared_ptr<HeifPixelImage>>
+Op_mono_to_YCbCr420::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                                        const ColorState& input_state,
+                                        const ColorState& target_state,
+                                        const heif_color_conversion_options& options,
+                                        const heif_color_conversion_options_ext& options_ext,
+                                        const heif_security_limits* limits) const
+{
+  auto outimg = std::make_shared<HeifPixelImage>();
+
+  uint32_t width = input->get_width();
+  uint32_t height = input->get_height();
+
+  outimg->create(width, height, heif_colorspace_YCbCr, heif_chroma_420);
+
+  int input_bpp = input->get_bits_per_pixel(heif_channel_Y);
+
+  uint32_t chroma_width = (width + 1) / 2;
+  uint32_t chroma_height = (height + 1) / 2;
+
+  if (auto err = outimg->add_plane(heif_channel_Y, width, height, input_bpp, limits) ||
+                 outimg->add_plane(heif_channel_Cb, chroma_width, chroma_height, input_bpp, limits) ||
+                 outimg->add_plane(heif_channel_Cr, chroma_width, chroma_height, input_bpp, limits)) {
+    return err;
+  }
+
+  int alpha_bpp = 0;
+  bool has_alpha = input->has_channel(heif_channel_Alpha);
+  if (has_alpha) {
+    alpha_bpp = input->get_bits_per_pixel(heif_channel_Alpha);
+    if (auto err = outimg->add_plane(heif_channel_Alpha, width, height, alpha_bpp, limits)) {
+      return err;
+    }
+  }
+
+
+  if (input_bpp <= 8) {
+    uint8_t* out_cb, * out_cr, * out_y;
+    size_t out_cb_stride = 0, out_cr_stride = 0, out_y_stride = 0;
+
+    const uint8_t* in_y;
+    size_t in_y_stride = 0;
+
+    in_y = input->get_plane(heif_channel_Y, &in_y_stride);
+
+    out_y = outimg->get_plane(heif_channel_Y, &out_y_stride);
+    out_cb = outimg->get_plane(heif_channel_Cb, &out_cb_stride);
+    out_cr = outimg->get_plane(heif_channel_Cr, &out_cr_stride);
+
+    auto chroma_value = static_cast<uint8_t>(1 << (input_bpp - 1));
+
+    memset(out_cb, chroma_value, out_cb_stride * chroma_height);
+    memset(out_cr, chroma_value, out_cr_stride * chroma_height);
+
+    for (uint32_t y = 0; y < height; y++) {
+      memcpy(out_y + y * out_y_stride,
+             in_y + y * in_y_stride,
+             width);
+    }
+  }
+  else {
+    uint16_t* out_cb, * out_cr, * out_y;
+    size_t out_cb_stride = 0, out_cr_stride = 0, out_y_stride = 0;
+
+    const uint16_t* in_y;
+    size_t in_y_stride = 0;
+
+    in_y = (const uint16_t*) input->get_plane(heif_channel_Y, &in_y_stride);
+
+    out_y = (uint16_t*) outimg->get_plane(heif_channel_Y, &out_y_stride);
+    out_cb = (uint16_t*) outimg->get_plane(heif_channel_Cb, &out_cb_stride);
+    out_cr = (uint16_t*) outimg->get_plane(heif_channel_Cr, &out_cr_stride);
+
+    in_y_stride /= 2;
+    out_y_stride /= 2;
+    out_cb_stride /= 2;
+    out_cr_stride /= 2;
+
+    for (uint32_t y = 0; y < chroma_height; y++)
+      for (uint32_t x = 0; x < chroma_width; x++) {
+        out_cb[x + y * out_cb_stride] = (uint16_t) (128 << (input_bpp - 8));
+        out_cr[x + y * out_cr_stride] = (uint16_t) (128 << (input_bpp - 8));
+      }
+
+    for (uint32_t y = 0; y < height; y++) {
+      memcpy(out_y + y * out_y_stride,
+             in_y + y * in_y_stride,
+             width * 2);
+    }
+  }
+
+  if (has_alpha) {
+    const uint8_t* in_a;
+    uint8_t* out_a;
+    size_t in_a_stride = 0;
+    size_t out_a_stride = 0;
+
+    in_a = input->get_plane(heif_channel_Alpha, &in_a_stride);
+    out_a = outimg->get_plane(heif_channel_Alpha, &out_a_stride);
+
+    uint32_t memory_width = (alpha_bpp > 8 ? width * 2 : width);
+
+    for (uint32_t y = 0; y < height; y++) {
+      memcpy(&out_a[y * out_a_stride], &in_a[y * in_a_stride], memory_width);
+    }
+  }
+
+  return outimg;
+}
+
+
+std::vector<ColorStateWithCost>
+Op_mono_to_RGB24_32::state_after_conversion(const ColorState& input_state,
+                                            const ColorState& target_state,
+                                            const heif_color_conversion_options& options,
+                                            const heif_color_conversion_options_ext& options_ext) const
+{
+  // Note: no input alpha channel required. It will be filled up with 0xFF.
+
+  if (input_state.colorspace != heif_colorspace_monochrome ||
+      input_state.chroma != heif_chroma_monochrome ||
+      input_state.bits_per_pixel != 8) {
+    return {};
+  }
+
+  std::vector<ColorStateWithCost> states;
+
+  ColorState output_state;
+
+  // --- convert to RGB24
+
+  if (input_state.has_alpha == false) {
+    output_state.colorspace = heif_colorspace_RGB;
+    output_state.chroma = heif_chroma_interleaved_RGB;
+    output_state.has_alpha = false;
+    output_state.bits_per_pixel = 8;
+
+    states.emplace_back(output_state, SpeedCosts_Unoptimized);
+  }
+
+
+  // --- convert to RGB32
+
+  output_state.colorspace = heif_colorspace_RGB;
+  output_state.chroma = heif_chroma_interleaved_RGBA;
+  output_state.has_alpha = true;
+  output_state.bits_per_pixel = 8;
+
+  states.emplace_back(output_state, SpeedCosts_Unoptimized);
+
+  return states;
+}
+
+
+Result<std::shared_ptr<HeifPixelImage>>
+Op_mono_to_RGB24_32::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                                        const ColorState& input_state,
+                                        const ColorState& target_state,
+                                        const heif_color_conversion_options& options,
+                                        const heif_color_conversion_options_ext& options_ext,
+                                        const heif_security_limits* limits) const
+{
+  uint32_t width = input->get_width();
+  uint32_t height = input->get_height();
+
+  if (input->get_bits_per_pixel(heif_channel_Y) != 8) {
+    return Error::InternalError;
+  }
+
+  auto outimg = std::make_shared<HeifPixelImage>();
+
+  bool has_alpha = input->has_channel(heif_channel_Alpha);
+
+  if (target_state.has_alpha) {
+    outimg->create(width, height, heif_colorspace_RGB, heif_chroma_interleaved_32bit);
+  }
+  else {
+    outimg->create(width, height, heif_colorspace_RGB, heif_chroma_interleaved_24bit);
+  }
+
+  if (auto err = outimg->add_plane(heif_channel_interleaved, width, height, 8, limits)) {
+    return err;
+  }
+
+  const uint8_t* in_y, * in_a = nullptr;
+  size_t in_y_stride = 0, in_a_stride = 0;
+
+  uint8_t* out_p;
+  size_t out_p_stride = 0;
+
+  in_y = input->get_plane(heif_channel_Y, &in_y_stride);
+  if (has_alpha) {
+    in_a = input->get_plane(heif_channel_Alpha, &in_a_stride);
+  }
+
+  out_p = outimg->get_plane(heif_channel_interleaved, &out_p_stride);
+
+  uint32_t x, y;
+  for (y = 0; y < height; y++) {
+    if (target_state.has_alpha == false) {
+      for (x = 0; x < width; x++) {
+        uint8_t v = in_y[x + y * in_y_stride];
+        out_p[y * out_p_stride + 3 * x + 0] = v;
+        out_p[y * out_p_stride + 3 * x + 1] = v;
+        out_p[y * out_p_stride + 3 * x + 2] = v;
+      }
+    }
+    else if (has_alpha) {
+      for (x = 0; x < width; x++) {
+        uint8_t v = in_y[x + y * in_y_stride];
+        out_p[y * out_p_stride + 4 * x + 0] = v;
+        out_p[y * out_p_stride + 4 * x + 1] = v;
+        out_p[y * out_p_stride + 4 * x + 2] = v;
+        out_p[y * out_p_stride + 4 * x + 3] = in_a[x + y * in_a_stride];
+      }
+    }
+    else {
+      for (x = 0; x < width; x++) {
+        uint8_t v = in_y[x + y * in_y_stride];
+        out_p[y * out_p_stride + 4 * x + 0] = v;
+        out_p[y * out_p_stride + 4 * x + 1] = v;
+        out_p[y * out_p_stride + 4 * x + 2] = v;
+        out_p[y * out_p_stride + 4 * x + 3] = 0xFF;
+      }
+    }
+  }
+
+  return outimg;
+}
+
+
diff --git a/libheif/color-conversion/monochrome.h b/libheif/color-conversion/monochrome.h
new file mode 100644
index 0000000000..58cc1890e1
--- /dev/null
+++ b/libheif/color-conversion/monochrome.h
@@ -0,0 +1,66 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_COLORCONVERSION_MONOCHROME_H
+#define LIBHEIF_COLORCONVERSION_MONOCHROME_H
+
+#include "colorconversion.h"
+#include <vector>
+#include <memory>
+
+
+class Op_mono_to_YCbCr420 : public ColorConversionOperation
+{
+public:
+  std::vector<ColorStateWithCost>
+  state_after_conversion(const ColorState& input_state,
+                         const ColorState& target_state,
+                         const heif_color_conversion_options& options,
+                         const heif_color_conversion_options_ext& options_ext) const override;
+
+  Result<std::shared_ptr<HeifPixelImage>>
+  convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                     const ColorState& input_state,
+                     const ColorState& target_state,
+                     const heif_color_conversion_options& options,
+                     const heif_color_conversion_options_ext& options_ext,
+                     const heif_security_limits* limits) const override;
+};
+
+
+class Op_mono_to_RGB24_32 : public ColorConversionOperation
+{
+public:
+  std::vector<ColorStateWithCost>
+  state_after_conversion(const ColorState& input_state,
+                         const ColorState& target_state,
+                         const heif_color_conversion_options& options,
+                         const heif_color_conversion_options_ext& options_ext) const override;
+
+  Result<std::shared_ptr<HeifPixelImage>>
+  convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                     const ColorState& input_state,
+                     const ColorState& target_state,
+                     const heif_color_conversion_options& options,
+                     const heif_color_conversion_options_ext& options_ext,
+                     const heif_security_limits* limits) const override;
+};
+
+#endif //LIBHEIF_COLORCONVERSION_MONOCHROME_H
diff --git a/libheif/color-conversion/rgb2rgb.cc b/libheif/color-conversion/rgb2rgb.cc
new file mode 100644
index 0000000000..4e779268fb
--- /dev/null
+++ b/libheif/color-conversion/rgb2rgb.cc
@@ -0,0 +1,750 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <algorithm>
+#include <cassert>
+#include <memory>
+#include <vector>
+#include "rgb2rgb.h"
+
+
+std::vector<ColorStateWithCost>
+Op_RGB_to_RGB24_32::state_after_conversion(const ColorState& input_state,
+                                           const ColorState& target_state,
+                                           const heif_color_conversion_options& options,
+                                           const heif_color_conversion_options_ext& options_ext) const
+{
+  if (input_state.colorspace != heif_colorspace_RGB ||
+      input_state.chroma != heif_chroma_444 ||
+      input_state.bits_per_pixel != 8) {
+    return {};
+  }
+
+  std::vector<ColorStateWithCost> states;
+
+  ColorState output_state;
+  //ColorConversionCosts costs;
+
+  // --- convert to RGBA (with alpha)
+
+  output_state.colorspace = heif_colorspace_RGB;
+  output_state.chroma = heif_chroma_interleaved_RGBA;
+  output_state.has_alpha = true;
+  output_state.bits_per_pixel = 8;
+
+  states.emplace_back(output_state, SpeedCosts_Unoptimized);
+
+  // --- convert to RGB (without alpha)
+
+  output_state.colorspace = heif_colorspace_RGB;
+  output_state.chroma = heif_chroma_interleaved_RGB;
+  output_state.has_alpha = false;
+  output_state.bits_per_pixel = 8;
+
+  states.emplace_back(output_state, SpeedCosts_Unoptimized);
+
+  return states;
+}
+
+
+Result<std::shared_ptr<HeifPixelImage>>
+Op_RGB_to_RGB24_32::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                                       const ColorState& input_state,
+                                       const ColorState& target_state,
+                                       const heif_color_conversion_options& options,
+                                       const heif_color_conversion_options_ext& options_ext,
+                                       const heif_security_limits* limits) const
+{
+  bool has_alpha = input->has_channel(heif_channel_Alpha);
+  bool want_alpha = target_state.has_alpha;
+
+  if (input->get_bits_per_pixel(heif_channel_R) != 8 ||
+      input->get_bits_per_pixel(heif_channel_G) != 8 ||
+      input->get_bits_per_pixel(heif_channel_B) != 8) {
+    return Error::InternalError;
+  }
+
+  if (has_alpha && input->get_bits_per_pixel(heif_channel_Alpha) != 8) {
+    return Error::InternalError;
+  }
+
+  auto outimg = std::make_shared<HeifPixelImage>();
+
+  uint32_t width = input->get_width();
+  uint32_t height = input->get_height();
+
+  outimg->create(width, height, heif_colorspace_RGB,
+                 want_alpha ? heif_chroma_interleaved_32bit : heif_chroma_interleaved_24bit);
+
+  if (auto err = outimg->add_plane(heif_channel_interleaved, width, height, 8, limits)) {
+    return err;
+  }
+
+  const uint8_t* in_r, * in_g, * in_b, * in_a = nullptr;
+  size_t in_r_stride = 0, in_g_stride = 0, in_b_stride = 0, in_a_stride = 0;
+
+  uint8_t* out_p;
+  size_t out_p_stride = 0;
+
+  in_r = input->get_plane(heif_channel_R, &in_r_stride);
+  in_g = input->get_plane(heif_channel_G, &in_g_stride);
+  in_b = input->get_plane(heif_channel_B, &in_b_stride);
+  out_p = outimg->get_plane(heif_channel_interleaved, &out_p_stride);
+
+  if (has_alpha) {
+    in_a = input->get_plane(heif_channel_Alpha, &in_a_stride);
+  }
+
+  uint32_t x, y;
+  for (y = 0; y < height; y++) {
+
+    if (has_alpha && want_alpha) {
+      for (x = 0; x < width; x++) {
+        out_p[y * out_p_stride + 4 * x + 0] = in_r[x + y * in_r_stride];
+        out_p[y * out_p_stride + 4 * x + 1] = in_g[x + y * in_g_stride];
+        out_p[y * out_p_stride + 4 * x + 2] = in_b[x + y * in_b_stride];
+        out_p[y * out_p_stride + 4 * x + 3] = in_a[x + y * in_a_stride];
+      }
+    }
+    else if (!want_alpha) {
+      for (x = 0; x < width; x++) {
+        out_p[y * out_p_stride + 3 * x + 0] = in_r[x + y * in_r_stride];
+        out_p[y * out_p_stride + 3 * x + 1] = in_g[x + y * in_g_stride];
+        out_p[y * out_p_stride + 3 * x + 2] = in_b[x + y * in_b_stride];
+      }
+    }
+    else {
+      assert(want_alpha && !has_alpha);
+
+      for (x = 0; x < width; x++) {
+        out_p[y * out_p_stride + 4 * x + 0] = in_r[x + y * in_r_stride];
+        out_p[y * out_p_stride + 4 * x + 1] = in_g[x + y * in_g_stride];
+        out_p[y * out_p_stride + 4 * x + 2] = in_b[x + y * in_b_stride];
+        out_p[y * out_p_stride + 4 * x + 3] = 0xFF;
+      }
+    }
+  }
+
+  return outimg;
+}
+
+
+std::vector<ColorStateWithCost>
+Op_RGB_HDR_to_RRGGBBaa_BE::state_after_conversion(const ColorState& input_state,
+                                                  const ColorState& target_state,
+                                                  const heif_color_conversion_options& options,
+                                                  const heif_color_conversion_options_ext& options_ext) const
+{
+  // Note: no input alpha channel required. It will be filled up with 0xFF.
+
+  if (input_state.colorspace != heif_colorspace_RGB ||
+      input_state.chroma != heif_chroma_444 ||
+      input_state.bits_per_pixel <= 8) {
+    return {};
+  }
+
+  std::vector<ColorStateWithCost> states;
+
+  ColorState output_state;
+
+  // --- convert to RRGGBB_BE
+
+  if (input_state.has_alpha == false) {
+    output_state.colorspace = heif_colorspace_RGB;
+    output_state.chroma = heif_chroma_interleaved_RRGGBB_BE;
+    output_state.has_alpha = false;
+    output_state.bits_per_pixel = input_state.bits_per_pixel;
+
+    states.emplace_back(output_state, SpeedCosts_Unoptimized);
+  }
+
+
+  // --- convert to RRGGBBAA_BE
+
+  output_state.colorspace = heif_colorspace_RGB;
+  output_state.chroma = heif_chroma_interleaved_RRGGBBAA_BE;
+  output_state.has_alpha = true;
+  output_state.bits_per_pixel = input_state.bits_per_pixel;
+
+  states.emplace_back(output_state, SpeedCosts_Unoptimized);
+
+
+  return states;
+}
+
+
+Result<std::shared_ptr<HeifPixelImage>>
+Op_RGB_HDR_to_RRGGBBaa_BE::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                                              const ColorState& input_state,
+                                              const ColorState& target_state,
+                                              const heif_color_conversion_options& options,
+                                              const heif_color_conversion_options_ext& options_ext,
+                                              const heif_security_limits* limits) const
+{
+  if (input->get_bits_per_pixel(heif_channel_R) <= 8 ||
+      input->get_bits_per_pixel(heif_channel_G) <= 8 ||
+      input->get_bits_per_pixel(heif_channel_B) <= 8) {
+    return Error::InternalError;
+  }
+
+  bool input_has_alpha = input->has_channel(heif_channel_Alpha);
+  bool output_has_alpha = input_has_alpha || target_state.has_alpha;
+
+  if (input_has_alpha) {
+    if (input->get_bits_per_pixel(heif_channel_Alpha) <= 8) {
+      return Error::InternalError;
+    }
+
+    if (input->get_width(heif_channel_Alpha) != input->get_width(heif_channel_G) ||
+        input->get_height(heif_channel_Alpha) != input->get_height(heif_channel_G)) {
+      return Error::InternalError;
+    }
+  }
+  int bpp = input->get_bits_per_pixel(heif_channel_R);
+  if (bpp <= 0) return Error::InternalError;
+
+  auto outimg = std::make_shared<HeifPixelImage>();
+
+  uint32_t width = input->get_width();
+  uint32_t height = input->get_height();
+
+  outimg->create(width, height, heif_colorspace_RGB,
+                 output_has_alpha ? heif_chroma_interleaved_RRGGBBAA_BE : heif_chroma_interleaved_RRGGBB_BE);
+  if (auto err = outimg->add_plane(heif_channel_interleaved, width, height, bpp, limits)) {
+    return err;
+  }
+
+  const uint16_t* in_r, * in_g, * in_b, * in_a = nullptr;
+  size_t in_r_stride = 0, in_g_stride = 0, in_b_stride = 0, in_a_stride = 0;
+
+  uint8_t* out_p;
+  size_t out_p_stride = 0;
+
+  in_r = (uint16_t*) input->get_plane(heif_channel_R, &in_r_stride);
+  in_g = (uint16_t*) input->get_plane(heif_channel_G, &in_g_stride);
+  in_b = (uint16_t*) input->get_plane(heif_channel_B, &in_b_stride);
+  out_p = outimg->get_plane(heif_channel_interleaved, &out_p_stride);
+
+  if (input_has_alpha) {
+    in_a = (uint16_t*) input->get_plane(heif_channel_Alpha, &in_a_stride);
+    assert(in_a != nullptr);
+
+    // should never happen, but makes clang-tidy happy
+    if (in_a == nullptr) {
+      return Error::InternalError;
+    }
+  }
+
+  in_r_stride /= 2;
+  in_g_stride /= 2;
+  in_b_stride /= 2;
+  in_a_stride /= 2;
+
+  const int pixelsize = (output_has_alpha ? 8 : 6);
+
+  uint32_t x, y;
+  auto alpha_max = static_cast<uint16_t>((1 << bpp) - 1);
+  for (y = 0; y < height; y++) {
+    for (x = 0; x < width; x++) {
+      uint16_t r = in_r[x + y * in_r_stride];
+      uint16_t g = in_g[x + y * in_g_stride];
+      uint16_t b = in_b[x + y * in_b_stride];
+      out_p[y * out_p_stride + pixelsize * x + 0] = (uint8_t)(r >> 8);
+      out_p[y * out_p_stride + pixelsize * x + 1] = (uint8_t)(r & 0xFF);
+      out_p[y * out_p_stride + pixelsize * x + 2] = (uint8_t)(g >> 8);
+      out_p[y * out_p_stride + pixelsize * x + 3] = (uint8_t)(g & 0xFF);
+      out_p[y * out_p_stride + pixelsize * x + 4] = (uint8_t)(b >> 8);
+      out_p[y * out_p_stride + pixelsize * x + 5] = (uint8_t)(b & 0xFF);
+      if (output_has_alpha) {
+        uint16_t a = input_has_alpha ? in_a[x + y * in_a_stride] : alpha_max;
+        out_p[y * out_p_stride + pixelsize * x + 6] = (uint8_t)(a >> 8);
+        out_p[y * out_p_stride + pixelsize * x + 7] = (uint8_t)(a & 0xFF);
+      }
+    }
+  }
+
+  return outimg;
+}
+
+
+std::vector<ColorStateWithCost>
+Op_RGB_to_RRGGBBaa_BE::state_after_conversion(const ColorState& input_state,
+                                              const ColorState& target_state,
+                                              const heif_color_conversion_options& options,
+                                              const heif_color_conversion_options_ext& options_ext) const
+{
+  // Note: no input alpha channel required. It will be filled up with 0xFF.
+
+  if (input_state.colorspace != heif_colorspace_RGB ||
+      input_state.chroma != heif_chroma_444 ||
+      input_state.bits_per_pixel != 8) {
+    return {};
+  }
+
+  std::vector<ColorStateWithCost> states;
+
+  ColorState output_state;
+
+  // --- convert to RRGGBB_BE
+
+  if (input_state.has_alpha == false) {
+    output_state.colorspace = heif_colorspace_RGB;
+    output_state.chroma = heif_chroma_interleaved_RRGGBB_BE;
+    output_state.has_alpha = false;
+    output_state.bits_per_pixel = input_state.bits_per_pixel;
+
+    states.emplace_back(output_state, SpeedCosts_Unoptimized);
+  }
+
+
+  // --- convert to RRGGBBAA_BE
+
+  output_state.colorspace = heif_colorspace_RGB;
+  output_state.chroma = heif_chroma_interleaved_RRGGBBAA_BE;
+  output_state.has_alpha = true;
+  output_state.bits_per_pixel = input_state.bits_per_pixel;
+
+  states.emplace_back(output_state, SpeedCosts_Unoptimized);
+
+  return states;
+}
+
+
+Result<std::shared_ptr<HeifPixelImage>>
+Op_RGB_to_RRGGBBaa_BE::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                                          const ColorState& input_state,
+                                          const ColorState& target_state,
+                                          const heif_color_conversion_options& options,
+                                          const heif_color_conversion_options_ext& options_ext,
+                                          const heif_security_limits* limits) const
+{
+  if (input->get_bits_per_pixel(heif_channel_R) != 8 ||
+      input->get_bits_per_pixel(heif_channel_G) != 8 ||
+      input->get_bits_per_pixel(heif_channel_B) != 8) {
+    return Error::InternalError;
+  }
+
+  //int bpp = input->get_bits_per_pixel(heif_channel_R);
+
+  bool input_has_alpha = input->has_channel(heif_channel_Alpha);
+  bool output_has_alpha = input_has_alpha || target_state.has_alpha;
+
+  if (input_has_alpha && input->get_bits_per_pixel(heif_channel_Alpha) != 8) {
+    return Error::InternalError;
+  }
+
+  auto outimg = std::make_shared<HeifPixelImage>();
+
+  uint32_t width = input->get_width();
+  uint32_t height = input->get_height();
+
+  outimg->create(width, height, heif_colorspace_RGB,
+                 output_has_alpha ? heif_chroma_interleaved_RRGGBBAA_BE : heif_chroma_interleaved_RRGGBB_BE);
+
+  if (auto err = outimg->add_plane(heif_channel_interleaved, width, height, input->get_bits_per_pixel(heif_channel_R), limits)) {
+    return err;
+  }
+
+  const uint8_t* in_r, * in_g, * in_b, * in_a = nullptr;
+  size_t in_r_stride = 0, in_g_stride = 0, in_b_stride = 0, in_a_stride = 0;
+
+  uint8_t* out_p;
+  size_t out_p_stride = 0;
+
+  in_r = input->get_plane(heif_channel_R, &in_r_stride);
+  in_g = input->get_plane(heif_channel_G, &in_g_stride);
+  in_b = input->get_plane(heif_channel_B, &in_b_stride);
+  out_p = outimg->get_plane(heif_channel_interleaved, &out_p_stride);
+
+  if (input_has_alpha) {
+    in_a = input->get_plane(heif_channel_Alpha, &in_a_stride);
+  }
+
+  const int pixelsize = (output_has_alpha ? 8 : 6);
+
+  uint32_t x, y;
+  for (y = 0; y < height; y++) {
+
+    if (input_has_alpha) {
+      for (x = 0; x < width; x++) {
+        out_p[y * out_p_stride + 8 * x + 0] = 0;
+        out_p[y * out_p_stride + 8 * x + 1] = in_r[x + y * in_r_stride];
+        out_p[y * out_p_stride + 8 * x + 2] = 0;
+        out_p[y * out_p_stride + 8 * x + 3] = in_g[x + y * in_g_stride];
+        out_p[y * out_p_stride + 8 * x + 4] = 0;
+        out_p[y * out_p_stride + 8 * x + 5] = in_b[x + y * in_b_stride];
+        out_p[y * out_p_stride + 8 * x + 6] = 0;
+        out_p[y * out_p_stride + 8 * x + 7] = in_a[x + y * in_a_stride];
+      }
+    }
+    else {
+      for (x = 0; x < width; x++) {
+        out_p[y * out_p_stride + pixelsize * x + 0] = 0;
+        out_p[y * out_p_stride + pixelsize * x + 1] = in_r[x + y * in_r_stride];
+        out_p[y * out_p_stride + pixelsize * x + 2] = 0;
+        out_p[y * out_p_stride + pixelsize * x + 3] = in_g[x + y * in_g_stride];
+        out_p[y * out_p_stride + pixelsize * x + 4] = 0;
+        out_p[y * out_p_stride + pixelsize * x + 5] = in_b[x + y * in_b_stride];
+
+        if (output_has_alpha) {
+          out_p[y * out_p_stride + pixelsize * x + 6] = 0;
+          out_p[y * out_p_stride + pixelsize * x + 7] = 0xFF;
+        }
+      }
+    }
+  }
+
+  return outimg;
+}
+
+
+std::vector<ColorStateWithCost>
+Op_RRGGBBaa_BE_to_RGB_HDR::state_after_conversion(const ColorState& input_state,
+                                                  const ColorState& target_state,
+                                                  const heif_color_conversion_options& options,
+                                                  const heif_color_conversion_options_ext& options_ext) const
+{
+  // Note: no input alpha channel required. It will be filled up with 0xFF.
+
+  if (input_state.colorspace != heif_colorspace_RGB ||
+      (input_state.chroma != heif_chroma_interleaved_RRGGBB_BE &&
+       input_state.chroma != heif_chroma_interleaved_RRGGBBAA_BE) ||
+      input_state.bits_per_pixel <= 8) {
+    return {};
+  }
+
+  std::vector<ColorStateWithCost> states;
+
+  ColorState output_state;
+
+  // --- convert to RRGGBB_BE
+
+  output_state.colorspace = heif_colorspace_RGB;
+  output_state.chroma = heif_chroma_444;
+  output_state.has_alpha = target_state.has_alpha;
+  output_state.bits_per_pixel = input_state.bits_per_pixel;
+
+  states.emplace_back(output_state, SpeedCosts_Unoptimized);
+
+  return states;
+}
+
+
+Result<std::shared_ptr<HeifPixelImage>>
+Op_RRGGBBaa_BE_to_RGB_HDR::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                                              const ColorState& input_state,
+                                              const ColorState& target_state,
+                                              const heif_color_conversion_options& options,
+                                              const heif_color_conversion_options_ext& options_ext,
+                                              const heif_security_limits* limits) const
+{
+  bool has_alpha = (input->get_chroma_format() == heif_chroma_interleaved_RRGGBBAA_LE ||
+                    input->get_chroma_format() == heif_chroma_interleaved_RRGGBBAA_BE);
+  bool want_alpha = target_state.has_alpha;
+
+  auto outimg = std::make_shared<HeifPixelImage>();
+
+  uint32_t width = input->get_width();
+  uint32_t height = input->get_height();
+  int bpp = input->get_bits_per_pixel(heif_channel_interleaved);
+
+  outimg->create(width, height, heif_colorspace_RGB, heif_chroma_444);
+
+  if (auto err = outimg->add_plane(heif_channel_R, width, height, bpp, limits) ||
+                 outimg->add_plane(heif_channel_G, width, height, bpp, limits) ||
+                 outimg->add_plane(heif_channel_B, width, height, bpp, limits)) {
+    return err;
+  }
+
+  if (want_alpha) {
+    if (auto err = outimg->add_plane(heif_channel_Alpha, width, height, bpp, limits)) {
+      return err;
+    }
+  }
+
+  const uint8_t* in_p;
+  size_t in_p_stride = 0;
+  int in_pix_size = has_alpha ? 8 : 6;
+
+  uint16_t* out_r, * out_g, * out_b, * out_a = nullptr;
+  size_t out_r_stride = 0, out_g_stride = 0, out_b_stride = 0, out_a_stride = 0;
+
+  in_p = input->get_plane(heif_channel_interleaved, &in_p_stride);
+
+  out_r = (uint16_t*) outimg->get_plane(heif_channel_R, &out_r_stride);
+  out_g = (uint16_t*) outimg->get_plane(heif_channel_G, &out_g_stride);
+  out_b = (uint16_t*) outimg->get_plane(heif_channel_B, &out_b_stride);
+
+  if (want_alpha) {
+    out_a = (uint16_t*) outimg->get_plane(heif_channel_Alpha, &out_a_stride);
+  }
+
+  out_r_stride /= 2;
+  out_g_stride /= 2;
+  out_b_stride /= 2;
+  out_a_stride /= 2;
+
+  auto alpha_max = static_cast<uint16_t>((1 << bpp) - 1);
+  uint32_t x, y;
+  for (y = 0; y < height; y++) {
+
+    for (x = 0; x < width; x++) {
+      uint16_t r = (uint16_t) ((in_p[y * in_p_stride + in_pix_size * x + 0] << 8) |
+                               in_p[y * in_p_stride + in_pix_size * x + 1]);
+      uint16_t g = (uint16_t) ((in_p[y * in_p_stride + in_pix_size * x + 2] << 8) |
+                               in_p[y * in_p_stride + in_pix_size * x + 3]);
+      uint16_t b = (uint16_t) ((in_p[y * in_p_stride + in_pix_size * x + 4] << 8) |
+                               in_p[y * in_p_stride + in_pix_size * x + 5]);
+
+      out_r[x + y * out_r_stride] = r;
+      out_g[x + y * out_g_stride] = g;
+      out_b[x + y * out_b_stride] = b;
+
+      if (want_alpha) {
+        // in_pix_size is always 8 when we have alpha channel
+        uint16_t a = has_alpha ? (uint16_t) ((in_p[y * in_p_stride + 8 * x + 6] << 8) |
+                                 in_p[y * in_p_stride + 8 * x + 7]) : alpha_max;
+
+        out_a[x + y * out_a_stride] = a;
+      }
+    }
+  }
+
+  return outimg;
+}
+
+
+std::vector<ColorStateWithCost>
+Op_RGB24_32_to_RGB::state_after_conversion(const ColorState& input_state,
+                                           const ColorState& target_state,
+                                           const heif_color_conversion_options& options,
+                                           const heif_color_conversion_options_ext& options_ext) const
+{
+  // Note: no input alpha channel required. It will be filled up with 0xFF.
+
+  if (input_state.colorspace != heif_colorspace_RGB ||
+      (input_state.chroma != heif_chroma_interleaved_RGB &&
+       input_state.chroma != heif_chroma_interleaved_RGBA) ||
+      input_state.bits_per_pixel != 8) {
+    return {};
+  }
+
+  std::vector<ColorStateWithCost> states;
+
+  ColorState output_state;
+
+  // --- convert to planar RGB
+
+  output_state.colorspace = heif_colorspace_RGB;
+  output_state.chroma = heif_chroma_444;
+  output_state.has_alpha = target_state.has_alpha;
+  output_state.bits_per_pixel = input_state.bits_per_pixel;
+
+  states.emplace_back(output_state, SpeedCosts_Unoptimized);
+
+  return states;
+}
+
+
+Result<std::shared_ptr<HeifPixelImage>>
+Op_RGB24_32_to_RGB::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                                       const ColorState& input_state,
+                                       const ColorState& target_state,
+                                       const heif_color_conversion_options& options,
+                                       const heif_color_conversion_options_ext& options_ext,
+                                       const heif_security_limits* limits) const
+{
+  bool has_alpha = input->get_chroma_format() == heif_chroma_interleaved_RGBA;
+  bool want_alpha = target_state.has_alpha;
+
+  auto outimg = std::make_shared<HeifPixelImage>();
+
+  uint32_t width = input->get_width();
+  uint32_t height = input->get_height();
+
+  outimg->create(width, height, heif_colorspace_RGB, heif_chroma_444);
+
+  if (auto err = outimg->add_plane(heif_channel_R, width, height, 8, limits) ||
+                 outimg->add_plane(heif_channel_G, width, height, 8, limits) ||
+                 outimg->add_plane(heif_channel_B, width, height, 8, limits)) {
+    return err;
+  }
+
+  if (want_alpha) {
+    if (auto err = outimg->add_plane(heif_channel_Alpha, width, height, 8, limits)) {
+      return err;
+    }
+  }
+
+  const uint8_t* in_p;
+  size_t in_p_stride = 0;
+  int in_pix_size = has_alpha ? 4 : 3;
+
+  uint8_t* out_r, * out_g, * out_b, * out_a = nullptr;
+  size_t out_r_stride = 0, out_g_stride = 0, out_b_stride = 0, out_a_stride = 0;
+
+  in_p = input->get_plane(heif_channel_interleaved, &in_p_stride);
+
+  out_r = outimg->get_plane(heif_channel_R, &out_r_stride);
+  out_g = outimg->get_plane(heif_channel_G, &out_g_stride);
+  out_b = outimg->get_plane(heif_channel_B, &out_b_stride);
+
+  if (want_alpha) {
+    out_a = outimg->get_plane(heif_channel_Alpha, &out_a_stride);
+  }
+
+  uint32_t x, y;
+  for (y = 0; y < height; y++) {
+
+    for (x = 0; x < width; x++) {
+      out_r[x + y * out_r_stride] = in_p[y * in_p_stride + in_pix_size * x + 0];
+      out_g[x + y * out_g_stride] = in_p[y * in_p_stride + in_pix_size * x + 1];
+      out_b[x + y * out_b_stride] = in_p[y * in_p_stride + in_pix_size * x + 2];
+
+      if (want_alpha) {
+        uint8_t a = has_alpha ? in_p[y * in_p_stride + in_pix_size * x + 3] : 0xff;
+        out_a[x + y * out_a_stride] = a;
+      }
+    }
+  }
+
+  return outimg;
+}
+
+
+std::vector<ColorStateWithCost>
+Op_RRGGBBaa_swap_endianness::state_after_conversion(const ColorState& input_state,
+                                                    const ColorState& target_state,
+                                                    const heif_color_conversion_options& options,
+                                                    const heif_color_conversion_options_ext& options_ext) const
+{
+  // Note: no input alpha channel required. It will be filled up with 0xFF.
+
+  if (input_state.colorspace != heif_colorspace_RGB ||
+      (input_state.chroma != heif_chroma_interleaved_RRGGBB_LE &&
+       input_state.chroma != heif_chroma_interleaved_RRGGBB_BE &&
+       input_state.chroma != heif_chroma_interleaved_RRGGBBAA_LE &&
+       input_state.chroma != heif_chroma_interleaved_RRGGBBAA_BE)) {
+    return {};
+  }
+
+  std::vector<ColorStateWithCost> states;
+
+  ColorState output_state;
+
+  // --- swap RRGGBB
+
+  if (input_state.chroma == heif_chroma_interleaved_RRGGBB_LE ||
+      input_state.chroma == heif_chroma_interleaved_RRGGBB_BE) {
+    output_state.colorspace = heif_colorspace_RGB;
+
+    if (input_state.chroma == heif_chroma_interleaved_RRGGBB_LE) {
+      output_state.chroma = heif_chroma_interleaved_RRGGBB_BE;
+    }
+    else {
+      output_state.chroma = heif_chroma_interleaved_RRGGBB_LE;
+    }
+
+    output_state.has_alpha = false;
+    output_state.bits_per_pixel = input_state.bits_per_pixel;
+
+    states.emplace_back(output_state, SpeedCosts_Unoptimized);
+  }
+
+
+  // --- swap RRGGBBAA
+
+  if (input_state.chroma == heif_chroma_interleaved_RRGGBBAA_LE ||
+      input_state.chroma == heif_chroma_interleaved_RRGGBBAA_BE) {
+    output_state.colorspace = heif_colorspace_RGB;
+
+    if (input_state.chroma == heif_chroma_interleaved_RRGGBBAA_LE) {
+      output_state.chroma = heif_chroma_interleaved_RRGGBBAA_BE;
+    }
+    else {
+      output_state.chroma = heif_chroma_interleaved_RRGGBBAA_LE;
+    }
+
+    output_state.has_alpha = true;
+    output_state.bits_per_pixel = input_state.bits_per_pixel;
+
+    states.emplace_back(output_state, SpeedCosts_Unoptimized);
+  }
+
+  return states;
+}
+
+
+Result<std::shared_ptr<HeifPixelImage>>
+Op_RRGGBBaa_swap_endianness::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                                                const ColorState& input_state,
+                                                const ColorState& target_state,
+                                                const heif_color_conversion_options& options,
+                                                const heif_color_conversion_options_ext& options_ext,
+                                                const heif_security_limits* limits) const
+{
+  auto outimg = std::make_shared<HeifPixelImage>();
+
+  uint32_t width = input->get_width();
+  uint32_t height = input->get_height();
+
+  switch (input->get_chroma_format()) {
+    case heif_chroma_interleaved_RRGGBB_LE:
+      outimg->create(width, height, heif_colorspace_RGB, heif_chroma_interleaved_RRGGBB_BE);
+      break;
+    case heif_chroma_interleaved_RRGGBB_BE:
+      outimg->create(width, height, heif_colorspace_RGB, heif_chroma_interleaved_RRGGBB_LE);
+      break;
+    case heif_chroma_interleaved_RRGGBBAA_LE:
+      outimg->create(width, height, heif_colorspace_RGB, heif_chroma_interleaved_RRGGBBAA_BE);
+      break;
+    case heif_chroma_interleaved_RRGGBBAA_BE:
+      outimg->create(width, height, heif_colorspace_RGB, heif_chroma_interleaved_RRGGBBAA_LE);
+      break;
+    default:
+      return Error::InternalError;
+  }
+
+  if (auto err = outimg->add_plane(heif_channel_interleaved, width, height,
+                                   input->get_bits_per_pixel(heif_channel_interleaved), limits)) {
+    return err;
+  }
+
+  const uint8_t* in_p = nullptr;
+  size_t in_p_stride = 0;
+
+  uint8_t* out_p;
+  size_t out_p_stride = 0;
+
+  in_p = input->get_plane(heif_channel_interleaved, &in_p_stride);
+  out_p = outimg->get_plane(heif_channel_interleaved, &out_p_stride);
+
+  size_t n_bytes = std::min(in_p_stride, out_p_stride);
+
+  uint32_t x, y;
+  for (y = 0; y < height; y++) {
+    for (x = 0; x < n_bytes; x += 2) {
+      out_p[y * out_p_stride + x + 0] = in_p[y * in_p_stride + x + 1];
+      out_p[y * out_p_stride + x + 1] = in_p[y * in_p_stride + x + 0];
+    }
+  }
+
+  return outimg;
+}
diff --git a/libheif/color-conversion/rgb2rgb.h b/libheif/color-conversion/rgb2rgb.h
new file mode 100644
index 0000000000..4c82c65b16
--- /dev/null
+++ b/libheif/color-conversion/rgb2rgb.h
@@ -0,0 +1,143 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_RGB2RGB_H
+#define LIBHEIF_RGB2RGB_H
+
+#include "colorconversion.h"
+#include <vector>
+#include <memory>
+
+
+class Op_RGB_to_RGB24_32 : public ColorConversionOperation
+{
+public:
+  std::vector<ColorStateWithCost>
+  state_after_conversion(const ColorState& input_state,
+                         const ColorState& target_state,
+                         const heif_color_conversion_options& options,
+                         const heif_color_conversion_options_ext& options_ext) const override;
+
+  Result<std::shared_ptr<HeifPixelImage>>
+  convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                     const ColorState& input_state,
+                     const ColorState& target_state,
+                     const heif_color_conversion_options& options,
+                     const heif_color_conversion_options_ext& options_ext,
+                     const heif_security_limits* limits) const override;
+};
+
+
+class Op_RGB_HDR_to_RRGGBBaa_BE : public ColorConversionOperation
+{
+public:
+  std::vector<ColorStateWithCost>
+  state_after_conversion(const ColorState& input_state,
+                         const ColorState& target_state,
+                         const heif_color_conversion_options& options,
+                         const heif_color_conversion_options_ext& options_ext) const override;
+
+  Result<std::shared_ptr<HeifPixelImage>>
+  convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                     const ColorState& input_state,
+                     const ColorState& target_state,
+                     const heif_color_conversion_options& options,
+                     const heif_color_conversion_options_ext& options_ext,
+                     const heif_security_limits* limits) const override;
+};
+
+
+class Op_RGB_to_RRGGBBaa_BE : public ColorConversionOperation
+{
+public:
+  std::vector<ColorStateWithCost>
+  state_after_conversion(const ColorState& input_state,
+                         const ColorState& target_state,
+                         const heif_color_conversion_options& options,
+                         const heif_color_conversion_options_ext& options_ext) const override;
+
+  Result<std::shared_ptr<HeifPixelImage>>
+  convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                     const ColorState& input_state,
+                     const ColorState& target_state,
+                     const heif_color_conversion_options& options,
+                     const heif_color_conversion_options_ext& options_ext,
+                     const heif_security_limits* limits) const override;
+};
+
+
+class Op_RRGGBBaa_BE_to_RGB_HDR : public ColorConversionOperation
+{
+public:
+  std::vector<ColorStateWithCost>
+  state_after_conversion(const ColorState& input_state,
+                         const ColorState& target_state,
+                         const heif_color_conversion_options& options,
+                         const heif_color_conversion_options_ext& options_ext) const override;
+
+  Result<std::shared_ptr<HeifPixelImage>>
+  convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                     const ColorState& input_state,
+                     const ColorState& target_state,
+                     const heif_color_conversion_options& options,
+                     const heif_color_conversion_options_ext& options_ext,
+                     const heif_security_limits* limits) const override;
+};
+
+
+class Op_RGB24_32_to_RGB : public ColorConversionOperation
+{
+public:
+  std::vector<ColorStateWithCost>
+  state_after_conversion(const ColorState& input_state,
+                         const ColorState& target_state,
+                         const heif_color_conversion_options& options,
+                         const heif_color_conversion_options_ext& options_ext) const override;
+
+  Result<std::shared_ptr<HeifPixelImage>>
+  convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                     const ColorState& input_state,
+                     const ColorState& target_state,
+                     const heif_color_conversion_options& options,
+                     const heif_color_conversion_options_ext& options_ext,
+                     const heif_security_limits* limits) const override;
+};
+
+
+class Op_RRGGBBaa_swap_endianness : public ColorConversionOperation
+{
+public:
+  std::vector<ColorStateWithCost>
+  state_after_conversion(const ColorState& input_state,
+                         const ColorState& target_state,
+                         const heif_color_conversion_options& options,
+                         const heif_color_conversion_options_ext& options_ext) const override;
+
+  Result<std::shared_ptr<HeifPixelImage>>
+  convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                     const ColorState& input_state,
+                     const ColorState& target_state,
+                     const heif_color_conversion_options& options,
+                     const heif_color_conversion_options_ext& options_ext,
+                     const heif_security_limits* limits) const override;
+};
+
+
+#endif //LIBHEIF_RGB2RGB_H
diff --git a/libheif/color-conversion/rgb2yuv.cc b/libheif/color-conversion/rgb2yuv.cc
new file mode 100644
index 0000000000..b570fe6bd7
--- /dev/null
+++ b/libheif/color-conversion/rgb2yuv.cc
@@ -0,0 +1,912 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <cstring>
+#include <cassert>
+#include <memory>
+#include <vector>
+#include "rgb2yuv.h"
+#include "nclx.h"
+#include "common_utils.h"
+
+
+template<class Pixel>
+std::vector<ColorStateWithCost>
+Op_RGB_to_YCbCr<Pixel>::state_after_conversion(const ColorState& input_state,
+                                               const ColorState& target_state,
+                                               const heif_color_conversion_options& options,
+                                               const heif_color_conversion_options_ext& options_ext) const
+{
+  bool hdr = !std::is_same<Pixel, uint8_t>::value;
+
+  if ((input_state.bits_per_pixel > 8) != hdr) {
+    return {};
+  }
+
+  // TODO: add support for <8 bpp
+  if (input_state.bits_per_pixel < 8) {
+    return {};
+  }
+
+  if (input_state.colorspace != heif_colorspace_RGB ||
+      input_state.chroma != heif_chroma_444) {
+    return {};
+  }
+
+  int matrix = target_state.nclx.get_matrix_coefficients();
+  if (matrix == 11 || matrix == 14) {
+    return {};
+  }
+
+  std::vector<ColorStateWithCost> states;
+
+  ColorState output_state;
+
+  // --- convert to YCbCr
+
+  // This Op only implements the nearest-neighbor downsampling algorithm, but it can still convert to 4:4:4.
+
+  if (target_state.chroma != heif_chroma_444 &&
+      (options.preferred_chroma_downsampling_algorithm == heif_chroma_downsampling_nearest_neighbor ||
+       !options.only_use_preferred_chroma_algorithm)) {
+
+    output_state.colorspace = heif_colorspace_YCbCr;
+    output_state.chroma = target_state.chroma;
+    output_state.has_alpha = input_state.has_alpha;  // we simply keep the old alpha plane
+    output_state.bits_per_pixel = input_state.bits_per_pixel;
+    output_state.nclx = target_state.nclx;
+
+    states.emplace_back(output_state, SpeedCosts_Unoptimized);
+  }
+  else {
+    // --- convert to YCbCr 4:4:4
+
+    output_state.colorspace = heif_colorspace_YCbCr;
+    output_state.chroma = heif_chroma_444;
+    output_state.has_alpha = input_state.has_alpha;  // we simply keep the old alpha plane
+    output_state.bits_per_pixel = input_state.bits_per_pixel;
+    output_state.nclx = target_state.nclx;
+
+    states.emplace_back(output_state, SpeedCosts_Unoptimized);
+  }
+
+  return states;
+}
+
+template<class Pixel>
+Result<std::shared_ptr<HeifPixelImage>>
+Op_RGB_to_YCbCr<Pixel>::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                                           const ColorState& input_state,
+                                           const ColorState& target_state,
+                                           const heif_color_conversion_options& options,
+                                           const heif_color_conversion_options_ext& options_ext,
+                                           const heif_security_limits* limits) const
+{
+  bool hdr = !std::is_same<Pixel, uint8_t>::value;
+
+  uint32_t width = input->get_width();
+  uint32_t height = input->get_height();
+
+  heif_chroma chroma = target_state.chroma;
+  int subH = chroma_h_subsampling(chroma);
+  int subV = chroma_v_subsampling(chroma);
+
+  int bpp = input->get_bits_per_pixel(heif_channel_R);
+  if (bpp < 8 || (bpp > 8) != hdr) {
+    return Error::InternalError;
+  }
+
+  bool has_alpha = input->has_channel(heif_channel_Alpha);
+
+  if (has_alpha && input->get_bits_per_pixel(heif_channel_Alpha) != bpp) {
+    return Error::InternalError;
+  }
+
+  auto outimg = std::make_shared<HeifPixelImage>();
+
+  outimg->create(width, height, heif_colorspace_YCbCr, chroma);
+
+  uint32_t cwidth = (width + subH - 1) / subH;
+  uint32_t cheight = (height + subV - 1) / subV;
+
+  if (auto err = outimg->add_plane(heif_channel_Y, width, height, bpp, limits) ||
+                 outimg->add_plane(heif_channel_Cb, cwidth, cheight, bpp, limits) ||
+                 outimg->add_plane(heif_channel_Cr, cwidth, cheight, bpp, limits)) {
+    return err;
+  }
+
+  if (has_alpha) {
+    if (auto err = outimg->add_plane(heif_channel_Alpha, width, height, bpp, limits)) {
+      return err;
+    }
+  }
+
+  const Pixel* in_r, * in_g, * in_b;
+  size_t in_r_stride = 0, in_g_stride = 0, in_b_stride = 0, in_a_stride = 0;
+
+  Pixel* out_y, * out_cb, * out_cr;
+  size_t out_y_stride = 0, out_cb_stride = 0, out_cr_stride = 0, out_a_stride = 0;
+
+  in_r = (const Pixel*) input->get_plane(heif_channel_R, &in_r_stride);
+  in_g = (const Pixel*) input->get_plane(heif_channel_G, &in_g_stride);
+  in_b = (const Pixel*) input->get_plane(heif_channel_B, &in_b_stride);
+  out_y = (Pixel*) outimg->get_plane(heif_channel_Y, &out_y_stride);
+  out_cb = (Pixel*) outimg->get_plane(heif_channel_Cb, &out_cb_stride);
+  out_cr = (Pixel*) outimg->get_plane(heif_channel_Cr, &out_cr_stride);
+
+  const uint8_t* in_a;
+  uint8_t* out_a;
+
+  if (has_alpha) {
+    in_a = input->get_plane(heif_channel_Alpha, &in_a_stride);
+    out_a = outimg->get_plane(heif_channel_Alpha, &out_a_stride);
+  }
+  else {
+    in_a = nullptr;
+    out_a = nullptr;
+  }
+
+  if (hdr) {
+    in_r_stride /= 2;
+    in_g_stride /= 2;
+    in_b_stride /= 2;
+    out_y_stride /= 2;
+    out_cb_stride /= 2;
+    out_cr_stride /= 2;
+  }
+
+  uint16_t halfRange = (uint16_t) (1 << (bpp - 1));
+  int32_t fullRange = (1 << bpp) - 1;
+  float limited_range_offset = static_cast<float>(16 << (bpp - 8));
+
+  int matrix_coeffs = 2;
+  RGB_to_YCbCr_coefficients coeffs = RGB_to_YCbCr_coefficients::defaults();
+  bool full_range_flag = true;
+  full_range_flag = target_state.nclx.get_full_range_flag();
+  matrix_coeffs = target_state.nclx.get_matrix_coefficients();
+  coeffs = get_RGB_to_YCbCr_coefficients(target_state.nclx.get_matrix_coefficients(),
+                                         target_state.nclx.get_colour_primaries());
+
+  uint32_t x, y;
+
+  for (y = 0; y < height; y++) {
+    for (x = 0; x < width; x++) {
+      if (matrix_coeffs == 0) {
+        if (full_range_flag) {
+          out_y[y * out_y_stride + x] = in_g[y * in_g_stride + x];
+        }
+        else {
+          float v = (((in_g[y * in_g_stride + x] * 219.0f) / 256) + limited_range_offset);
+          out_y[y * out_y_stride + x] = (Pixel) clip_f_u16(v, fullRange);
+        }
+      }
+      else if (matrix_coeffs == 8) {
+        // Note: this is the YCgCo transform for equal Y/C bit depths, H.273(2024) Eq.51-57.
+        // To avoid a loss in accuracy, input bit-depth must be extended by two bits.
+        out_y[y * out_y_stride + x] = static_cast<Pixel>(in_g[y * in_g_stride + x] / 2 + (in_r[y * in_r_stride + x] + in_b[y * in_b_stride + x]) / 4);
+      }
+      else {
+        float r = in_r[y * in_r_stride + x];
+        float g = in_g[y * in_g_stride + x];
+        float b = in_b[y * in_b_stride + x];
+
+        float v = r * coeffs.c[0][0] + g * coeffs.c[0][1] + b * coeffs.c[0][2];
+        if (!full_range_flag) {
+          v = (((v * 219) / 256) + limited_range_offset);
+        }
+
+        Pixel pix = (Pixel) clip_f_u16(v, fullRange);
+
+        out_y[y * out_y_stride + x] = pix;
+      }
+    }
+  }
+
+  for (y = 0; y < height; y += subV) {
+    for (x = 0; x < width; x += subH) {
+      if (matrix_coeffs == 0) {
+        if (full_range_flag) {
+          out_cb[(y / subV) * out_cb_stride + (x / subH)] = in_b[y * in_b_stride + x];
+          out_cr[(y / subV) * out_cb_stride + (x / subH)] = in_r[y * in_b_stride + x];
+        }
+        else {
+          out_cb[(y / subV) * out_cb_stride + (x / subH)] = (Pixel) clip_f_u16(
+              ((in_b[y * in_b_stride + x] * 224.0f) / 256) + limited_range_offset, fullRange);
+          out_cr[(y / subV) * out_cb_stride + (x / subH)] = (Pixel) clip_f_u16(
+              ((in_r[y * in_b_stride + x] * 224.0f) / 256) + limited_range_offset, fullRange);
+        }
+      }
+      else if (matrix_coeffs == 8) {
+        // Note: this is the YCgCo transform for equal Y/C bit depths, H.273(2024) Eq.51-57.
+        // To avoid a loss in accuracy, input bit-depth must be extended by two bits.
+        out_cb[(y / subV) * out_cb_stride + (x / subH)] = static_cast<Pixel>(clip_int_u16(in_g[y * in_g_stride + x] / 2
+                                                                                          - (in_r[y * in_r_stride + x] + in_b[y * in_b_stride + x]) / 4
+                                                                                          + halfRange, (uint16_t) fullRange));
+        out_cr[(y / subV) * out_cr_stride + (x / subH)] = static_cast<Pixel>(clip_int_u16((in_r[y * in_r_stride + x] - in_b[y * in_b_stride + x]) / 2
+                                                                                          + halfRange, (uint16_t) fullRange));
+      }
+      else {
+        float r = in_r[y * in_r_stride + x];
+        float g = in_g[y * in_g_stride + x];
+        float b = in_b[y * in_b_stride + x];
+
+        if (subH > 1 || subV > 1) {
+          uint32_t x2 = (x + 1 < width && subH == 2 && subV == 2) ? x + 1 : x;  // subV==2 -> Do not center for 4:2:2 (see comment in Op_RGB24_32_to_YCbCr, github issue #521)
+          uint32_t y2 = (y + 1 < height && subV == 2) ? y + 1 : y;
+
+          r += in_r[y * in_r_stride + x2];
+          g += in_g[y * in_g_stride + x2];
+          b += in_b[y * in_b_stride + x2];
+
+          r += in_r[y2 * in_r_stride + x];
+          g += in_g[y2 * in_g_stride + x];
+          b += in_b[y2 * in_b_stride + x];
+
+          r += in_r[y2 * in_r_stride + x2];
+          g += in_g[y2 * in_g_stride + x2];
+          b += in_b[y2 * in_b_stride + x2];
+
+          r *= 0.25f;
+          g *= 0.25f;
+          b *= 0.25f;
+        }
+
+        float cb, cr;
+
+        cb = r * coeffs.c[1][0] + g * coeffs.c[1][1] + b * coeffs.c[1][2];
+        cr = r * coeffs.c[2][0] + g * coeffs.c[2][1] + b * coeffs.c[2][2];
+
+        if (!full_range_flag) {
+          cb = (cb * 224) / 256;
+          cr = (cr * 224) / 256;
+        }
+
+        out_cb[(y / subV) * out_cb_stride + (x / subH)] = (Pixel) clip_f_u16(cb + halfRange, fullRange);
+        out_cr[(y / subV) * out_cr_stride + (x / subH)] = (Pixel) clip_f_u16(cr + halfRange, fullRange);
+      }
+    }
+  }
+
+
+  if (has_alpha) {
+    int bpp_a = input->get_bits_per_pixel(heif_channel_Alpha);
+    int alphaCopyWidth = (bpp_a > 8 ? width * 2 : width);
+
+    for (y = 0; y < height; y++) {
+      memcpy(&out_a[y * out_a_stride], &in_a[y * in_a_stride], alphaCopyWidth);
+    }
+  }
+
+  return outimg;
+}
+
+template class Op_RGB_to_YCbCr<uint8_t>;
+template class Op_RGB_to_YCbCr<uint16_t>;
+
+
+std::vector<ColorStateWithCost>
+Op_RRGGBBxx_HDR_to_YCbCr420::state_after_conversion(const ColorState& input_state,
+                                                    const ColorState& target_state,
+                                                    const heif_color_conversion_options& options,
+                                                    const heif_color_conversion_options_ext& options_ext) const
+{
+  // this Op only implements the nearest-neighbor algorithm
+
+  if (target_state.chroma != heif_chroma_444) {
+    if (options.preferred_chroma_downsampling_algorithm != heif_chroma_downsampling_nearest_neighbor &&
+        options.only_use_preferred_chroma_algorithm) {
+      return {};
+    }
+  }
+
+  if (input_state.colorspace != heif_colorspace_RGB ||
+      !(input_state.chroma == heif_chroma_interleaved_RRGGBB_BE ||
+        input_state.chroma == heif_chroma_interleaved_RRGGBB_LE ||
+        input_state.chroma == heif_chroma_interleaved_RRGGBBAA_BE ||
+        input_state.chroma == heif_chroma_interleaved_RRGGBBAA_LE) ||
+      input_state.bits_per_pixel <= 8) {
+    return {};
+  }
+
+  int matrix = target_state.nclx.get_matrix_coefficients();
+  if (matrix == 0 || matrix == 8 || matrix == 11 || matrix == 14) {
+    return {};
+  }
+  if (!target_state.nclx.get_full_range_flag()) {
+    return {};
+  }
+
+  if (target_state.chroma != heif_chroma_420) {
+    return {};
+  }
+
+
+  std::vector<ColorStateWithCost> states;
+
+  ColorState output_state;
+
+  // --- convert to YCbCr
+
+  output_state.colorspace = heif_colorspace_YCbCr;
+  output_state.chroma = heif_chroma_420;
+  output_state.has_alpha = input_state.has_alpha;  // we generate an alpha plane if the source contains data
+  output_state.bits_per_pixel = input_state.bits_per_pixel;
+  output_state.nclx = target_state.nclx;
+
+  states.emplace_back(output_state, SpeedCosts_Unoptimized);
+
+  return states;
+}
+
+
+Result<std::shared_ptr<HeifPixelImage>>
+Op_RRGGBBxx_HDR_to_YCbCr420::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                                                const ColorState& input_state,
+                                                const ColorState& target_state,
+                                                const heif_color_conversion_options& options,
+                                                const heif_color_conversion_options_ext& options_ext,
+                                                const heif_security_limits* limits) const
+{
+  uint32_t width = input->get_width();
+  uint32_t height = input->get_height();
+
+  int bpp = input->get_bits_per_pixel(heif_channel_interleaved);
+
+  bool has_alpha = (input->get_chroma_format() == heif_chroma_interleaved_RRGGBBAA_BE ||
+                    input->get_chroma_format() == heif_chroma_interleaved_RRGGBBAA_LE);
+
+  auto outimg = std::make_shared<HeifPixelImage>();
+
+  outimg->create(width, height, heif_colorspace_YCbCr, heif_chroma_420);
+
+  int bytesPerPixel = has_alpha ? 8 : 6;
+
+  uint32_t cwidth = (width + 1) / 2;
+  uint32_t cheight = (height + 1) / 2;
+
+  if (auto err = outimg->add_plane(heif_channel_Y, width, height, bpp, limits) ||
+                 outimg->add_plane(heif_channel_Cb, cwidth, cheight, bpp, limits) ||
+                 outimg->add_plane(heif_channel_Cr, cwidth, cheight, bpp, limits)) {
+    return err;
+  }
+
+  if (has_alpha) {
+    if (auto err = outimg->add_plane(heif_channel_Alpha, width, height, bpp, limits)) {
+      return err;
+    }
+  }
+
+  const uint8_t* in_p;
+  size_t in_p_stride = 0;
+
+  uint16_t* out_y, * out_cb, * out_cr, * out_a = nullptr;
+  size_t out_y_stride = 0, out_cb_stride = 0, out_cr_stride = 0, out_a_stride = 0;
+
+  in_p = input->get_plane(heif_channel_interleaved, &in_p_stride);
+  out_y = (uint16_t*) outimg->get_plane(heif_channel_Y, &out_y_stride);
+  out_cb = (uint16_t*) outimg->get_plane(heif_channel_Cb, &out_cb_stride);
+  out_cr = (uint16_t*) outimg->get_plane(heif_channel_Cr, &out_cr_stride);
+
+  if (has_alpha) {
+    out_a = (uint16_t*) outimg->get_plane(heif_channel_Alpha, &out_a_stride);
+  }
+
+
+  // adapt stride as we are pointing to 16bit integers
+  out_y_stride /= 2;
+  out_cb_stride /= 2;
+  out_cr_stride /= 2;
+  out_a_stride /= 2;
+
+  uint16_t halfRange = (uint16_t) (1 << (bpp - 1));
+  int32_t fullRange = (1 << bpp) - 1;
+  float limited_range_offset = static_cast<float>(16 << (bpp - 8));
+
+  // le=1 for little endian, le=0 for big endian
+  int le = (input->get_chroma_format() == heif_chroma_interleaved_RRGGBBAA_LE ||
+            input->get_chroma_format() == heif_chroma_interleaved_RRGGBB_LE) ? 1 : 0;
+
+  bool full_range_flag = target_state.nclx.get_full_range_flag();
+  RGB_to_YCbCr_coefficients coeffs = get_RGB_to_YCbCr_coefficients(
+      target_state.nclx.get_matrix_coefficients(),
+      target_state.nclx.get_colour_primaries());
+
+  for (uint32_t y = 0; y < height; y++) {
+    for (uint32_t x = 0; x < width; x++) {
+
+      const uint8_t* in = &in_p[y * in_p_stride + bytesPerPixel * x];
+
+      float r = static_cast<float>((in[0 + le] << 8) | in[1 - le]);
+      float g = static_cast<float>((in[2 + le] << 8) | in[3 - le]);
+      float b = static_cast<float>((in[4 + le] << 8) | in[5 - le]);
+
+      float v = r * coeffs.c[0][0] + g * coeffs.c[0][1] + b * coeffs.c[0][2];
+
+      if (!full_range_flag) {
+        v = v * 0.85547f + limited_range_offset;  // 0.85547 = 219/256
+      }
+
+      out_y[y * out_y_stride + x] = clip_f_u16(v, fullRange);
+
+      if (has_alpha) {
+        uint16_t a = (uint16_t) ((in[6 + le] << 8) | in[7 - le]);
+        out_a[y * out_a_stride + x] = a;
+      }
+    }
+  }
+
+  for (uint32_t y = 0; y < height; y += 2) {
+    for (uint32_t x = 0; x < width; x += 2) {
+      const uint8_t* in = &in_p[y * in_p_stride + bytesPerPixel * x];
+
+      float r = static_cast<float>((in[0 + le] << 8) | in[1 - le]);
+      float g = static_cast<float>((in[2 + le] << 8) | in[3 - le]);
+      float b = static_cast<float>((in[4 + le] << 8) | in[5 - le]);
+
+      int dx = (x + 1 < width) ? bytesPerPixel : 0;
+      int dy = (y + 1 < height) ? (int)in_p_stride : 0;
+
+      r += static_cast<float>((in[0 + le + dx] << 8) | in[1 - le + dx]);
+      g += static_cast<float>((in[2 + le + dx] << 8) | in[3 - le + dx]);
+      b += static_cast<float>((in[4 + le + dx] << 8) | in[5 - le + dx]);
+
+      r += static_cast<float>((in[0 + le + dy] << 8) | in[1 - le + dy]);
+      g += static_cast<float>((in[2 + le + dy] << 8) | in[3 - le + dy]);
+      b += static_cast<float>((in[4 + le + dy] << 8) | in[5 - le + dy]);
+
+      r += static_cast<float>((in[0 + le + dx + dy] << 8) | in[1 - le + dx + dy]);
+      g += static_cast<float>((in[2 + le + dx + dy] << 8) | in[3 - le + dx + dy]);
+      b += static_cast<float>((in[4 + le + dx + dy] << 8) | in[5 - le + dx + dy]);
+
+      r *= 0.25f;
+      g *= 0.25f;
+      b *= 0.25f;
+
+      float cb = r * coeffs.c[1][0] + g * coeffs.c[1][1] + b * coeffs.c[1][2];
+      float cr = r * coeffs.c[2][0] + g * coeffs.c[2][1] + b * coeffs.c[2][2];
+
+      if (!full_range_flag) {
+        cb = cb * 0.8750f;  // 0.8750 = 224/256
+        cr = cr * 0.8750f;  // 0.8750 = 224/256
+      }
+
+      out_cb[(y / 2) * out_cb_stride + (x / 2)] = clip_f_u16(halfRange + cb, fullRange);
+      out_cr[(y / 2) * out_cr_stride + (x / 2)] = clip_f_u16(halfRange + cr, fullRange);
+    }
+  }
+
+  return outimg;
+}
+
+
+std::vector<ColorStateWithCost>
+Op_RGB24_32_to_YCbCr::state_after_conversion(const ColorState& input_state,
+                                             const ColorState& target_state,
+                                             const heif_color_conversion_options& options,
+                                             const heif_color_conversion_options_ext& options_ext) const
+{
+  // this Op only implements the nearest-neighbor algorithm
+
+  if (target_state.chroma != heif_chroma_444) {
+    if (options.preferred_chroma_downsampling_algorithm != heif_chroma_downsampling_nearest_neighbor &&
+        options.only_use_preferred_chroma_algorithm) {
+      return {};
+    }
+  }
+
+  // Note: no input alpha channel required. It will be filled up with 0xFF.
+
+  if (input_state.colorspace != heif_colorspace_RGB ||
+      (input_state.chroma != heif_chroma_interleaved_RGB &&
+       input_state.chroma != heif_chroma_interleaved_RGBA)) {
+    return {};
+  }
+
+  if (target_state.chroma != heif_chroma_420 &&
+      target_state.chroma != heif_chroma_422 &&
+      target_state.chroma != heif_chroma_444) {
+    return {};
+  }
+
+  int matrix = target_state.nclx.get_matrix_coefficients();
+  if (matrix == 0 || matrix == 8 || matrix == 11 || matrix == 14) {
+    return {};
+  }
+
+  std::vector<ColorStateWithCost> states;
+
+  ColorState output_state;
+
+  output_state.colorspace = heif_colorspace_YCbCr;
+  output_state.chroma = target_state.chroma;
+  output_state.has_alpha = target_state.has_alpha;
+  output_state.bits_per_pixel = 8;
+  output_state.nclx = target_state.nclx;
+
+  states.emplace_back(output_state, SpeedCosts_Unoptimized);
+
+  return states;
+}
+
+
+inline void set_chroma_pixels(uint8_t* out_cb, uint8_t* out_cr,
+                              uint8_t r, uint8_t g, uint8_t b,
+                              const RGB_to_YCbCr_coefficients& coeffs,
+                              bool full_range_flag)
+{
+  float cb = r * coeffs.c[1][0] + g * coeffs.c[1][1] + b * coeffs.c[1][2];
+  float cr = r * coeffs.c[2][0] + g * coeffs.c[2][1] + b * coeffs.c[2][2];
+
+  if (full_range_flag) {
+    *out_cb = clip_f_u8(cb + 128);
+    *out_cr = clip_f_u8(cr + 128);
+  }
+  else {
+    *out_cb = (uint8_t) clip_f_u8(cb * 0.875f + 128.0f);
+    *out_cr = (uint8_t) clip_f_u8(cr * 0.875f + 128.0f);
+  }
+}
+
+
+Result<std::shared_ptr<HeifPixelImage>>
+Op_RGB24_32_to_YCbCr::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                                         const ColorState& input_state,
+                                         const ColorState& target_state,
+                                         const heif_color_conversion_options& options,
+                                         const heif_color_conversion_options_ext& options_ext,
+                                         const heif_security_limits* limits) const
+{
+  uint32_t width = input->get_width();
+  uint32_t height = input->get_height();
+
+  auto outimg = std::make_shared<HeifPixelImage>();
+
+  auto chroma = target_state.chroma;
+  uint8_t chromaSubH = chroma_h_subsampling(chroma);
+  uint8_t chromaSubV = chroma_v_subsampling(chroma);
+
+  outimg->create(width, height, heif_colorspace_YCbCr, chroma);
+
+  int chroma_width = (width + chromaSubH - 1) / chromaSubH;
+  int chroma_height = (height + chromaSubV - 1) / chromaSubV;
+
+  const bool has_alpha = (input->get_chroma_format() == heif_chroma_interleaved_32bit);
+  const bool want_alpha = target_state.has_alpha;
+
+  if (auto err = outimg->add_plane(heif_channel_Y, width, height, 8, limits) ||
+                 outimg->add_plane(heif_channel_Cb, chroma_width, chroma_height, 8, limits) ||
+                 outimg->add_plane(heif_channel_Cr, chroma_width, chroma_height, 8, limits)) {
+    return err;
+  }
+
+  if (want_alpha) {
+    if (auto err = outimg->add_plane(heif_channel_Alpha, width, height, 8, limits)) {
+      return err;
+    }
+  }
+
+  uint8_t* out_cb, * out_cr, * out_y, * out_a;
+  size_t out_cb_stride = 0, out_cr_stride = 0, out_y_stride = 0, out_a_stride = 0;
+
+  const uint8_t* in_p;
+  size_t in_stride = 0;
+
+  in_p = input->get_plane(heif_channel_interleaved, &in_stride);
+
+  out_y = outimg->get_plane(heif_channel_Y, &out_y_stride);
+  out_cb = outimg->get_plane(heif_channel_Cb, &out_cb_stride);
+  out_cr = outimg->get_plane(heif_channel_Cr, &out_cr_stride);
+
+  if (want_alpha) {
+    out_a = outimg->get_plane(heif_channel_Alpha, &out_a_stride);
+  }
+  else {
+    out_a = nullptr;
+  }
+
+
+  RGB_to_YCbCr_coefficients coeffs = RGB_to_YCbCr_coefficients::defaults();
+  bool full_range_flag = true;
+  full_range_flag = target_state.nclx.get_full_range_flag();
+  coeffs = get_RGB_to_YCbCr_coefficients(target_state.nclx.get_matrix_coefficients(),
+                                         target_state.nclx.get_colour_primaries());
+
+
+  int bytes_per_pixel = (has_alpha ? 4 : 3);
+
+  for (uint32_t y = 0; y < height; y++) {
+    const uint8_t* p = &in_p[y * in_stride];
+
+    for (uint32_t x = 0; x < width; x++) {
+      uint8_t r = p[0];
+      uint8_t g = p[1];
+      uint8_t b = p[2];
+      p += bytes_per_pixel;
+
+      float yv = r * coeffs.c[0][0] + g * coeffs.c[0][1] + b * coeffs.c[0][2];
+
+      if (full_range_flag) {
+        out_y[y * out_y_stride + x] = clip_f_u8(yv);
+      }
+      else {
+        out_y[y * out_y_stride + x] = (uint8_t) (clip_f_u16(yv * 0.85547f, 219) + 16);
+      }
+    }
+  }
+
+  if (chromaSubH == 1 && chromaSubV == 1) {
+    // chroma 4:4:4
+
+    for (uint32_t y = 0; y < height; y++) {
+      const uint8_t* p = &in_p[y * in_stride];
+
+      for (uint32_t x = 0; x < width; x++) {
+        uint8_t r = p[0];
+        uint8_t g = p[1];
+        uint8_t b = p[2];
+        p += bytes_per_pixel;
+
+        set_chroma_pixels(out_cb + y * out_cb_stride + x,
+                          out_cr + y * out_cr_stride + x,
+                          r, g, b,
+                          coeffs, full_range_flag);
+      }
+    }
+  }
+  else if (chromaSubH == 2 && chromaSubV == 2) {
+    // chroma 4:2:0
+
+    for (uint32_t y = 0; y < (height & ~1U); y += 2) {
+      const uint8_t* p = &in_p[y * in_stride];
+
+      for (uint32_t x = 0; x < (width & ~1U); x += 2) {
+        uint8_t r = uint8_t((p[0] + p[bytes_per_pixel + 0] + p[in_stride + 0] + p[bytes_per_pixel + in_stride + 0]) / 4);
+        uint8_t g = uint8_t((p[1] + p[bytes_per_pixel + 1] + p[in_stride + 1] + p[bytes_per_pixel + in_stride + 1]) / 4);
+        uint8_t b = uint8_t((p[2] + p[bytes_per_pixel + 2] + p[in_stride + 2] + p[bytes_per_pixel + in_stride + 2]) / 4);
+
+        p += bytes_per_pixel * 2;
+
+        set_chroma_pixels(out_cb + (y / 2) * out_cb_stride + (x / 2),
+                          out_cr + (y / 2) * out_cr_stride + (x / 2),
+                          r, g, b,
+                          coeffs, full_range_flag);
+      }
+    }
+
+    // 4:2:0 right column (if odd width)
+    if (width & 1) {
+      uint32_t x = width - 1;
+      const uint8_t* p = &in_p[x * bytes_per_pixel];
+
+      for (uint32_t y = 0; y < height; y += 2) {
+        uint8_t r, g, b;
+        if (y + 1 < height) {
+          r = uint8_t((p[0] + p[in_stride + 0]) / 2);
+          g = uint8_t((p[1] + p[in_stride + 1]) / 2);
+          b = uint8_t((p[2] + p[in_stride + 2]) / 2);
+        }
+        else {
+          r = p[0];
+          g = p[1];
+          b = p[2];
+        }
+
+        set_chroma_pixels(out_cb + (y / 2) * out_cb_stride + (x / 2),
+                          out_cr + (y / 2) * out_cr_stride + (x / 2),
+                          r, g, b,
+                          coeffs, full_range_flag);
+
+        p += in_stride * 2;
+      }
+    }
+
+    // 4:2:0 bottom row (if odd height)
+    if (height & 1) {
+      uint32_t y = height - 1;
+      const uint8_t* p = &in_p[y * in_stride];
+
+      for (uint32_t x = 0; x < width; x += 2) {
+        uint8_t r, g, b;
+        if (x + 1 < width) {
+          r = uint8_t((p[0] + p[bytes_per_pixel + 0]) / 2);
+          g = uint8_t((p[1] + p[bytes_per_pixel + 1]) / 2);
+          b = uint8_t((p[2] + p[bytes_per_pixel + 2]) / 2);
+        }
+        else {
+          r = p[0];
+          g = p[1];
+          b = p[2];
+        }
+
+        set_chroma_pixels(out_cb + (y / 2) * out_cb_stride + (x / 2),
+                          out_cr + (y / 2) * out_cr_stride + (x / 2),
+                          r, g, b,
+                          coeffs, full_range_flag);
+
+        p += bytes_per_pixel * 2;
+      }
+    }
+  }
+  else if (chromaSubH == 2 && chromaSubV == 1) {
+    // chroma 4:2:2
+
+    for (uint32_t y = 0; y < height; y++) {
+      const uint8_t* p = &in_p[y * in_stride];
+
+      for (uint32_t x = 0; x < width; x += 2) {
+        uint8_t r, g, b;
+
+        // TODO: it still is an open question where the 'correct' chroma sample positions are for 4:2:2
+        // Since 4:2:2 is primarily used for video content and as there is no way to signal center position for h.265,
+        // we currently use left-aligned sampling. See the discussion here: https://github.com/strukturag/libheif/issues/521
+#if USE_CENTER_CHROMA_422
+        if (x + 1 < width) {
+          r = uint8_t((p[0] + p[bytes_per_pixel + 0]) / 2);
+          g = uint8_t((p[1] + p[bytes_per_pixel + 1]) / 2);
+          b = uint8_t((p[2] + p[bytes_per_pixel + 2]) / 2);
+        }
+        else {
+          r = p[0];
+          g = p[1];
+          b = p[2];
+        }
+#else
+        r = p[0];
+        g = p[1];
+        b = p[2];
+#endif
+
+        p += bytes_per_pixel * 2;
+
+        set_chroma_pixels(out_cb + y * out_cb_stride + (x / 2),
+                          out_cr + y * out_cr_stride + (x / 2),
+                          r, g, b,
+                          coeffs, full_range_flag);
+      }
+    }
+  }
+
+  if (want_alpha) {
+    if (has_alpha) {
+      assert(bytes_per_pixel == 4);
+    }
+
+    for (uint32_t y = 0; y < height; y++) {
+      for (uint32_t x = 0; x < width; x++) {
+        uint8_t a = has_alpha ? in_p[y * in_stride + x * 4 + 3] : 0xff;
+
+        // alpha
+        out_a[y * out_a_stride + x] = a;
+      }
+    }
+  }
+
+  return outimg;
+}
+
+
+std::vector<ColorStateWithCost>
+Op_RGB24_32_to_YCbCr444_GBR::state_after_conversion(const ColorState& input_state,
+                                                    const ColorState& target_state,
+                                                    const heif_color_conversion_options& options,
+                                                    const heif_color_conversion_options_ext& options_ext) const
+{
+  // Note: no input alpha channel required. It will be filled up with 0xFF.
+
+  if (input_state.colorspace != heif_colorspace_RGB ||
+      (input_state.chroma != heif_chroma_interleaved_RGB &&
+       input_state.chroma != heif_chroma_interleaved_RGBA)) {
+    return {};
+  }
+
+  if (target_state.nclx.get_matrix_coefficients() != 0) {
+    return {};
+  }
+
+  if (!target_state.nclx.get_full_range_flag()) {
+    return {};
+  }
+
+  std::vector<ColorStateWithCost> states;
+
+  ColorState output_state;
+
+  output_state.colorspace = heif_colorspace_YCbCr;
+  output_state.chroma = heif_chroma_444;
+  output_state.has_alpha = target_state.has_alpha;
+  output_state.bits_per_pixel = 8;
+  output_state.nclx = target_state.nclx;
+
+  states.emplace_back(output_state, SpeedCosts_Unoptimized);
+
+  return states;
+}
+
+
+Result<std::shared_ptr<HeifPixelImage>>
+Op_RGB24_32_to_YCbCr444_GBR::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                                                const ColorState& input_state,
+                                                const ColorState& target_state,
+                                                const heif_color_conversion_options& options,
+                                                const heif_color_conversion_options_ext& options_ext,
+                                                const heif_security_limits* limits) const
+{
+  uint32_t width = input->get_width();
+  uint32_t height = input->get_height();
+
+  auto outimg = std::make_shared<HeifPixelImage>();
+
+  outimg->create(width, height, heif_colorspace_YCbCr, heif_chroma_444);
+
+  const bool has_alpha = (input->get_chroma_format() == heif_chroma_interleaved_32bit);
+  const bool want_alpha = target_state.has_alpha;
+
+  if (auto err = outimg->add_plane(heif_channel_Y, width, height, 8, limits) ||
+                 outimg->add_plane(heif_channel_Cb, width, height, 8, limits) ||
+                 outimg->add_plane(heif_channel_Cr, width, height, 8, limits)) {
+    return err;
+  }
+
+  if (want_alpha) {
+    if (auto err = outimg->add_plane(heif_channel_Alpha, width, height, 8, limits)) {
+      return err;
+    }
+  }
+
+  uint8_t* out_cb, * out_cr, * out_y, * out_a = nullptr;
+  size_t out_cb_stride = 0, out_cr_stride = 0, out_y_stride = 0, out_a_stride = 0;
+
+  const uint8_t* in_p;
+  size_t in_stride = 0;
+
+  in_p = input->get_plane(heif_channel_interleaved, &in_stride);
+
+  out_y = outimg->get_plane(heif_channel_Y, &out_y_stride);
+  out_cb = outimg->get_plane(heif_channel_Cb, &out_cb_stride);
+  out_cr = outimg->get_plane(heif_channel_Cr, &out_cr_stride);
+
+  if (want_alpha) {
+    out_a = outimg->get_plane(heif_channel_Alpha, &out_a_stride);
+  }
+
+
+  assert(target_state.nclx.get_matrix_coefficients() == 0);
+  int bytes_per_pixel = (has_alpha ? 4 : 3);
+
+  for (uint32_t y = 0; y < height; y++) {
+    for (uint32_t x = 0; x < width; x++) {
+      uint8_t r = in_p[y * in_stride + x * bytes_per_pixel + 0];
+      uint8_t g = in_p[y * in_stride + x * bytes_per_pixel + 1];
+      uint8_t b = in_p[y * in_stride + x * bytes_per_pixel + 2];
+
+      out_y[y * out_y_stride + x] = g;
+      out_cb[y * out_cb_stride + x] = b;
+      out_cr[y * out_cr_stride + x] = r;
+
+      if (want_alpha) {
+        uint8_t a =
+            has_alpha ? in_p[y * in_stride + x * bytes_per_pixel + 3] : 0xff;
+        out_a[y * out_a_stride + x] = a;
+      }
+    }
+  }
+
+  return outimg;
+}
diff --git a/libheif/color-conversion/rgb2yuv.h b/libheif/color-conversion/rgb2yuv.h
new file mode 100644
index 0000000000..7f2cc58689
--- /dev/null
+++ b/libheif/color-conversion/rgb2yuv.h
@@ -0,0 +1,106 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_COLORCONVERSION_RGB2YUV_H
+#define LIBHEIF_COLORCONVERSION_RGB2YUV_H
+
+#include "color-conversion/colorconversion.h"
+#include <vector>
+#include <memory>
+
+
+template<class Pixel>
+class Op_RGB_to_YCbCr : public ColorConversionOperation
+{
+public:
+  std::vector<ColorStateWithCost>
+  state_after_conversion(const ColorState& input_state,
+                         const ColorState& target_state,
+                         const heif_color_conversion_options& options,
+                         const heif_color_conversion_options_ext& options_ext) const override;
+
+  Result<std::shared_ptr<HeifPixelImage>>
+  convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                     const ColorState& input_state,
+                     const ColorState& target_state,
+                     const heif_color_conversion_options& options,
+                     const heif_color_conversion_options_ext& options_ext,
+                     const heif_security_limits* limits) const override;
+};
+
+
+
+class Op_RRGGBBxx_HDR_to_YCbCr420 : public ColorConversionOperation
+{
+public:
+  std::vector<ColorStateWithCost>
+  state_after_conversion(const ColorState& input_state,
+                         const ColorState& target_state,
+                         const heif_color_conversion_options& options,
+                         const heif_color_conversion_options_ext& options_ext) const override;
+
+  Result<std::shared_ptr<HeifPixelImage>>
+  convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                     const ColorState& input_state,
+                     const ColorState& target_state,
+                     const heif_color_conversion_options& options,
+                     const heif_color_conversion_options_ext& options_ext,
+                     const heif_security_limits* limits) const override;
+};
+
+
+class Op_RGB24_32_to_YCbCr : public ColorConversionOperation
+{
+public:
+  std::vector<ColorStateWithCost>
+  state_after_conversion(const ColorState& input_state,
+                         const ColorState& target_state,
+                         const heif_color_conversion_options& options,
+                         const heif_color_conversion_options_ext& options_ext) const override;
+
+  Result<std::shared_ptr<HeifPixelImage>>
+  convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                     const ColorState& input_state,
+                     const ColorState& target_state,
+                     const heif_color_conversion_options& options,
+                     const heif_color_conversion_options_ext& options_ext,
+                     const heif_security_limits* limits) const override;
+};
+
+
+class Op_RGB24_32_to_YCbCr444_GBR : public ColorConversionOperation
+{
+public:
+  std::vector<ColorStateWithCost>
+  state_after_conversion(const ColorState& input_state,
+                         const ColorState& target_state,
+                         const heif_color_conversion_options& options,
+                         const heif_color_conversion_options_ext& options_ext) const override;
+
+  Result<std::shared_ptr<HeifPixelImage>>
+  convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                     const ColorState& input_state,
+                     const ColorState& target_state,
+                     const heif_color_conversion_options& options,
+                     const heif_color_conversion_options_ext& options_ext,
+                     const heif_security_limits* limits) const override;
+};
+
+#endif //LIBHEIF_COLORCONVERSION_RGB2YUV_H
diff --git a/libheif/color-conversion/rgb2yuv_sharp.cc b/libheif/color-conversion/rgb2yuv_sharp.cc
new file mode 100644
index 0000000000..d24b660813
--- /dev/null
+++ b/libheif/color-conversion/rgb2yuv_sharp.cc
@@ -0,0 +1,281 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <cassert>
+#include <memory>
+#include <vector>
+#include "rgb2yuv_sharp.h"
+
+#ifdef HAVE_LIBSHARPYUV
+
+#include <sharpyuv/sharpyuv.h>
+#include <sharpyuv/sharpyuv_csp.h>
+#include "nclx.h"
+#include "common_utils.h"
+
+static inline bool PlatformIsBigEndian()
+{
+  int i = 1;
+  return !*((char*) &i);
+}
+
+static uint16_t Shift(uint16_t v, int input_bits, int output_bits)
+{
+  if (input_bits == output_bits) return v;
+  if (output_bits > input_bits) {
+    int shift1 = output_bits - input_bits;
+    int shift2 = 8 - shift1;
+    return (uint16_t) ((v << shift1) | (v >> shift2));
+  }
+  else {
+    int shift = input_bits - output_bits;
+    return (uint16_t) (v >> shift);
+  }
+}
+
+#endif
+
+std::vector<ColorStateWithCost>
+Op_Any_RGB_to_YCbCr_420_Sharp::state_after_conversion(
+    const ColorState& input_state, const ColorState& target_state,
+    const heif_color_conversion_options& options,
+    const heif_color_conversion_options_ext& options_ext) const
+{
+#ifdef HAVE_LIBSHARPYUV
+  // this Op only implements the sharp_yuv algorithm
+
+  // Note: no input alpha channel required. It will be filled up with 0xFF.
+
+  if (options.preferred_chroma_downsampling_algorithm != heif_chroma_downsampling_sharp_yuv &&
+      options.only_use_preferred_chroma_algorithm) {
+    return {};
+  }
+
+  // Only endianness matching the platform's is supported.
+  const bool big_endian = PlatformIsBigEndian();
+  const heif_chroma hdr_chroma = big_endian ? heif_chroma_interleaved_RRGGBB_BE
+                                            : heif_chroma_interleaved_RRGGBB_LE;
+  const heif_chroma hdr_with_alpha_chroma =
+      big_endian ? heif_chroma_interleaved_RRGGBBAA_BE
+                 : heif_chroma_interleaved_RRGGBBAA_LE;
+
+  if (input_state.colorspace != heif_colorspace_RGB ||
+      (
+          input_state.chroma != heif_chroma_444 &&  // Planar input.
+          input_state.chroma != heif_chroma_interleaved_RGB &&
+          input_state.chroma != heif_chroma_interleaved_RGBA &&
+          input_state.chroma != hdr_chroma &&
+          input_state.chroma != hdr_with_alpha_chroma)) {
+    return {};
+  }
+
+  if (input_state.bits_per_pixel != 8 && input_state.bits_per_pixel != 10 &&
+      input_state.bits_per_pixel != 12 && input_state.bits_per_pixel != 16) {
+    return {};
+  }
+
+  if (target_state.bits_per_pixel != 8 && target_state.bits_per_pixel != 10 &&
+      target_state.bits_per_pixel != 12) {
+    return {};
+  }
+
+  if (target_state.chroma != heif_chroma_420) {
+    return {};
+  }
+
+  int matrix = target_state.nclx.get_matrix_coefficients();
+  if (matrix == 0 || matrix == 8 || matrix == 11 || matrix == 14) {
+    return {};
+  }
+
+  std::vector<ColorStateWithCost> states;
+
+  ColorState output_state;
+
+  output_state.colorspace = heif_colorspace_YCbCr;
+  output_state.chroma = heif_chroma_420;
+  output_state.has_alpha = target_state.has_alpha;
+  output_state.bits_per_pixel = target_state.bits_per_pixel;
+  output_state.nclx = target_state.nclx;
+  states.emplace_back(output_state, SpeedCosts_Slow);
+
+  return states;
+#else
+  return {};
+#endif
+}
+
+Result<std::shared_ptr<HeifPixelImage>>
+Op_Any_RGB_to_YCbCr_420_Sharp::convert_colorspace(
+    const std::shared_ptr<const HeifPixelImage>& input,
+    const ColorState& input_state,
+    const ColorState& target_state,
+    const heif_color_conversion_options& options,
+    const heif_color_conversion_options_ext& options_ext,
+    const heif_security_limits* limits) const
+{
+#ifdef HAVE_LIBSHARPYUV
+  uint32_t width = input->get_width();
+  uint32_t height = input->get_height();
+
+  auto outimg = std::make_shared<HeifPixelImage>();
+
+  heif_chroma input_chroma = input->get_chroma_format();
+  heif_chroma output_chroma = target_state.chroma;
+  assert(output_chroma == heif_chroma_420);  // Only 420 is supported by libsharpyuv.
+  uint8_t chromaSubH = chroma_h_subsampling(output_chroma);
+  uint8_t chromaSubV = chroma_v_subsampling(output_chroma);
+
+  outimg->create(width, height, heif_colorspace_YCbCr, output_chroma);
+
+  uint32_t chroma_width = (width + chromaSubH - 1) / chromaSubH;
+  uint32_t chroma_height = (height + chromaSubV - 1) / chromaSubV;
+
+  bool has_alpha =
+      input->get_chroma_format() == heif_chroma_interleaved_RGBA ||
+      input->get_chroma_format() == heif_chroma_interleaved_RRGGBBAA_LE ||
+      input->get_chroma_format() == heif_chroma_interleaved_RRGGBBAA_BE ||
+      (input->get_chroma_format() == heif_chroma_444 &&
+       input->has_channel(heif_channel_Alpha));
+  bool want_alpha = target_state.has_alpha;
+
+  int output_bits = target_state.bits_per_pixel;
+  if (auto err = outimg->add_plane(heif_channel_Y, width, height, output_bits, limits) ||
+                 outimg->add_plane(heif_channel_Cb, chroma_width, chroma_height, output_bits, limits) ||
+                 outimg->add_plane(heif_channel_Cr, chroma_width, chroma_height, output_bits, limits)) {
+    return err;
+  }
+
+  if (want_alpha) {
+    if (auto err = outimg->add_plane(heif_channel_Alpha, width, height, output_bits, limits)) {
+      return err;
+    }
+  }
+
+  int input_bytes_per_sample =
+      (input_chroma == heif_chroma_interleaved_RGB ||
+       input_chroma == heif_chroma_interleaved_RGBA ||
+       (input_chroma == heif_chroma_444 &&
+        input->get_bits_per_pixel(heif_channel_R) <= 8))
+      ? 1
+      : 2;
+
+  const uint8_t* in_r, * in_g, * in_b, * in_a = nullptr;
+  size_t in_stride = 0;
+  size_t in_a_stride = 0;
+  bool planar_input = input_chroma == heif_chroma_444;
+  int input_bits = 0;
+  if (planar_input) {
+    size_t in_r_stride = 0, in_g_stride = 0, in_b_stride = 0;
+    in_r = input->get_plane(heif_channel_R, &in_r_stride);
+    in_g = input->get_plane(heif_channel_G, &in_g_stride);
+    in_b = input->get_plane(heif_channel_B, &in_b_stride);
+    // The stride must be the same for all channels.
+    if (in_r_stride != in_g_stride || in_r_stride != in_b_stride) {
+      return Error::InternalError;
+    }
+    in_stride = in_r_stride;
+    // Bpp must also be the same.
+    input_bits = input->get_bits_per_pixel(heif_channel_R);
+    if (input_bits != input->get_bits_per_pixel(heif_channel_G) ||
+        input_bits != input->get_bits_per_pixel(heif_channel_B)) {
+      return Error::InternalError;
+    }
+    if (has_alpha) {
+      in_a = input->get_plane(heif_channel_Alpha, &in_a_stride);
+    }
+  }
+  else {
+    const uint8_t* in_p = input->get_plane(heif_channel_interleaved, &in_stride);
+    input_bits = input->get_bits_per_pixel(heif_channel_interleaved);
+    in_r = &in_p[input_bytes_per_sample * 0];
+    in_g = &in_p[input_bytes_per_sample * 1];
+    in_b = &in_p[input_bytes_per_sample * 2];
+    if (has_alpha) {
+      in_a = &in_p[input_bytes_per_sample * 3];
+      in_a_stride = in_stride;
+    }
+  }
+
+  size_t out_cb_stride = 0, out_cr_stride = 0, out_y_stride = 0;
+  uint8_t* out_y = outimg->get_plane(heif_channel_Y, &out_y_stride);
+  uint8_t* out_cb = outimg->get_plane(heif_channel_Cb, &out_cb_stride);
+  uint8_t* out_cr = outimg->get_plane(heif_channel_Cr, &out_cr_stride);
+
+  bool full_range_flag = true;
+  Kr_Kb kr_kb = Kr_Kb::defaults();
+  full_range_flag = target_state.nclx.get_full_range_flag();
+  kr_kb =
+      get_Kr_Kb(target_state.nclx.get_matrix_coefficients(),
+                target_state.nclx.get_colour_primaries());
+
+  SharpYuvColorSpace color_space = {
+      kr_kb.Kr, kr_kb.Kb, output_bits,
+      full_range_flag ? kSharpYuvRangeFull : kSharpYuvRangeLimited};
+  SharpYuvConversionMatrix yuv_matrix;
+  SharpYuvComputeConversionMatrix(&color_space, &yuv_matrix);
+  int input_bytes_per_pixel = (has_alpha ? 4 : 3) * input_bytes_per_sample;
+  int rgb_step = planar_input ? input_bytes_per_sample : input_bytes_per_pixel;
+
+  int sharpyuv_ok =
+      SharpYuvConvert(in_r, in_g, in_b, rgb_step, (int)in_stride,
+                      input_bits, out_y, (int)out_y_stride, out_cb, (int)out_cb_stride,
+                      out_cr, (int)out_cr_stride, output_bits,
+                      input->get_width(), input->get_height(), &yuv_matrix);
+  if (!sharpyuv_ok) {
+    return Error{heif_error_Unsupported_feature,
+                 heif_suberror_Unsupported_color_conversion,
+                 "SharpYuv color conversion failed"};
+  }
+
+  if (want_alpha) {
+    int le = (input_chroma == heif_chroma_interleaved_RRGGBBAA_LE ||
+              input_chroma == heif_chroma_interleaved_RRGGBB_LE ||
+              (planar_input && !PlatformIsBigEndian()))
+             ? 1
+             : 0;
+    size_t out_a_stride;
+
+    uint8_t* out_a = outimg->get_plane(heif_channel_Alpha, &out_a_stride);
+    uint16_t alpha_max = static_cast<uint16_t>((1 << input_bits) - 1);
+    for (uint32_t y = 0; y < height; y++) {
+      for (uint32_t x = 0; x < width; x++) {
+        const uint8_t* in = has_alpha ? &in_a[y * in_a_stride + x * rgb_step] : nullptr;
+        uint16_t a = has_alpha
+                     ? ((input_bits == 8)
+                        ? in[0]
+                        : (uint16_t) ((in[0 + le] << 8) | in[1 - le]))
+                     : alpha_max;
+        if (output_bits == 8) {
+          out_a[y * out_a_stride + x] = (uint8_t) Shift(a, input_bits, output_bits);
+        }
+        else {
+          uint16_t* out_a16 = reinterpret_cast<uint16_t*>(out_a);
+          out_a16[y * out_a_stride / 2 + x] = Shift(a, input_bits, output_bits);
+        }
+      }
+    }
+  }
+
+  return outimg;
+#else
+  return Error::InternalError;
+#endif
+}
diff --git a/libheif/color-conversion/rgb2yuv_sharp.h b/libheif/color-conversion/rgb2yuv_sharp.h
new file mode 100644
index 0000000000..f438c659a7
--- /dev/null
+++ b/libheif/color-conversion/rgb2yuv_sharp.h
@@ -0,0 +1,48 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_RGB2YUV_SHARP_H
+#define LIBHEIF_RGB2YUV_SHARP_H
+
+#include "colorconversion.h"
+#include <vector>
+#include <memory>
+
+
+class Op_Any_RGB_to_YCbCr_420_Sharp : public ColorConversionOperation
+{
+public:
+  std::vector<ColorStateWithCost>
+  state_after_conversion(const ColorState& input_state,
+                         const ColorState& target_state,
+                         const heif_color_conversion_options& options,
+                         const heif_color_conversion_options_ext& options_ext) const override;
+
+  Result<std::shared_ptr<HeifPixelImage>>
+  convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                     const ColorState& input_state,
+                     const ColorState& target_state,
+                     const heif_color_conversion_options& options,
+                     const heif_color_conversion_options_ext& options_ext,
+                     const heif_security_limits* limits) const override;
+};
+
+
+#endif //LIBHEIF_RGB2YUV_SHARP_H
diff --git a/libheif/color-conversion/yuv2rgb.cc b/libheif/color-conversion/yuv2rgb.cc
new file mode 100644
index 0000000000..c98893bea6
--- /dev/null
+++ b/libheif/color-conversion/yuv2rgb.cc
@@ -0,0 +1,724 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <cmath>
+#include <cstring>
+#include "yuv2rgb.h"
+#include "nclx.h"
+#include "common_utils.h"
+
+
+template<class Pixel>
+std::vector<ColorStateWithCost>
+Op_YCbCr_to_RGB<Pixel>::state_after_conversion(const ColorState& input_state,
+                                               const ColorState& target_state,
+                                               const heif_color_conversion_options& options,
+                                               const heif_color_conversion_options_ext& options_ext) const
+{
+  // this Op only implements the nearest-neighbor algorithm
+
+  if (input_state.chroma != heif_chroma_444) {
+    if (options.preferred_chroma_upsampling_algorithm != heif_chroma_upsampling_nearest_neighbor &&
+        options.only_use_preferred_chroma_algorithm) {
+      return {};
+    }
+  }
+
+  if (input_state.colorspace != heif_colorspace_YCbCr ||
+      (input_state.chroma != heif_chroma_444 &&
+       input_state.chroma != heif_chroma_422 &&
+       input_state.chroma != heif_chroma_420)) {
+    return {};
+  }
+
+  int matrix = input_state.nclx.get_matrix_coefficients();
+  if (matrix == 11 || matrix == 14) {
+    return {};
+  }
+
+
+  bool hdr = !std::is_same<Pixel, uint8_t>::value;
+
+  if ((input_state.bits_per_pixel > 8) != hdr) {
+    return {};
+  }
+
+  // TODO: add support for <8 bpp
+  if (input_state.bits_per_pixel < 8) {
+    return {};
+  }
+
+  if (input_state.bits_per_pixel > 14) {
+    return {};
+  }
+
+  std::vector<ColorStateWithCost> states;
+
+  ColorState output_state;
+
+  // --- convert to RGB
+
+  output_state.colorspace = heif_colorspace_RGB;
+  output_state.chroma = heif_chroma_444;
+  output_state.has_alpha = input_state.has_alpha;  // we simply keep the old alpha plane
+  output_state.bits_per_pixel = input_state.bits_per_pixel;
+
+  states.emplace_back(output_state, SpeedCosts_Unoptimized);
+
+  return states;
+}
+
+
+template<class Pixel>
+Result<std::shared_ptr<HeifPixelImage>>
+Op_YCbCr_to_RGB<Pixel>::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                                           const ColorState& input_state,
+                                           const ColorState& target_state,
+                                           const heif_color_conversion_options& options,
+                                           const heif_color_conversion_options_ext& options_ext,
+                                           const heif_security_limits* limits) const
+{
+  bool hdr = !std::is_same<Pixel, uint8_t>::value;
+
+  heif_chroma chroma = input->get_chroma_format();
+
+  int bpp_y = input->get_bits_per_pixel(heif_channel_Y);
+  int bpp_cb = input->get_bits_per_pixel(heif_channel_Cb);
+  int bpp_cr = input->get_bits_per_pixel(heif_channel_Cr);
+  int bpp_a = 0;
+
+  bool has_alpha = input->has_channel(heif_channel_Alpha);
+
+  if (has_alpha) {
+    bpp_a = input->get_bits_per_pixel(heif_channel_Alpha);
+  }
+
+  if (!hdr) {
+    if (bpp_y != 8 ||
+        bpp_cb != 8 ||
+        bpp_cr != 8) {
+      return Error::InternalError;
+    }
+  }
+  else {
+    if (bpp_y == 8 ||
+        bpp_cb == 8 ||
+        bpp_cr == 8) {
+      return Error::InternalError;
+    }
+  }
+
+
+  if (bpp_y != bpp_cb ||
+      bpp_y != bpp_cr) {
+    // TODO: test with varying bit depths when we have a test image
+    return Error::InternalError;
+  }
+
+
+  uint32_t width = input->get_width();
+  uint32_t height = input->get_height();
+
+  auto outimg = std::make_shared<HeifPixelImage>();
+
+  outimg->create(width, height, heif_colorspace_RGB, heif_chroma_444);
+
+  if (auto err = outimg->add_plane(heif_channel_R, width, height, bpp_y, limits) ||
+                 outimg->add_plane(heif_channel_G, width, height, bpp_y, limits) ||
+                 outimg->add_plane(heif_channel_B, width, height, bpp_y, limits)) {
+    return err;
+  }
+
+  if (has_alpha) {
+    if (auto err = outimg->add_plane(heif_channel_Alpha, width, height, bpp_a, limits)) {
+      return err;
+    }
+  }
+
+  const Pixel* in_y, * in_cb, * in_cr;
+  size_t in_y_stride = 0, in_cb_stride = 0, in_cr_stride = 0, in_a_stride = 0;
+
+  Pixel* out_r, * out_g, * out_b;
+  size_t out_r_stride = 0, out_g_stride = 0, out_b_stride = 0, out_a_stride = 0;
+
+  in_y = (const Pixel*) input->get_plane(heif_channel_Y, &in_y_stride);
+  in_cb = (const Pixel*) input->get_plane(heif_channel_Cb, &in_cb_stride);
+  in_cr = (const Pixel*) input->get_plane(heif_channel_Cr, &in_cr_stride);
+  out_r = (Pixel*) outimg->get_plane(heif_channel_R, &out_r_stride);
+  out_g = (Pixel*) outimg->get_plane(heif_channel_G, &out_g_stride);
+  out_b = (Pixel*) outimg->get_plane(heif_channel_B, &out_b_stride);
+
+
+  // We only copy the alpha, do not access it as 16 bit
+  const uint8_t* in_a;
+  uint8_t* out_a;
+
+  if (has_alpha) {
+    in_a = input->get_plane(heif_channel_Alpha, &in_a_stride);
+    out_a = outimg->get_plane(heif_channel_Alpha, &out_a_stride);
+  }
+  else {
+    in_a = nullptr;
+    out_a = nullptr;
+  }
+
+
+  uint16_t halfRange = static_cast<uint16_t>(1 << (bpp_y - 1));
+  int16_t halfRange_chroma = static_cast<int16_t>(1 << (bpp_cb - 1));
+
+  int32_t fullRange = (1 << bpp_y) - 1;
+  int limited_range_offset_int = 16 << (bpp_y - 8);
+  float limited_range_offset = static_cast<float>(limited_range_offset_int);
+
+  int shiftH = chroma_h_subsampling(chroma) - 1;
+  int shiftV = chroma_v_subsampling(chroma) - 1;
+
+  if (hdr) {
+    in_y_stride /= 2;
+    in_cb_stride /= 2;
+    in_cr_stride /= 2;
+    out_r_stride /= 2;
+    out_g_stride /= 2;
+    out_b_stride /= 2;
+  }
+
+  int matrix_coeffs = 2;
+  bool full_range_flag = true;
+  YCbCr_to_RGB_coefficients coeffs = YCbCr_to_RGB_coefficients::defaults();
+  if (input->has_nclx_color_profile()) {
+    nclx_profile colorProfile = input->get_color_profile_nclx();
+
+    matrix_coeffs = colorProfile.get_matrix_coefficients();
+    full_range_flag = colorProfile.get_full_range_flag();
+    coeffs = get_YCbCr_to_RGB_coefficients(colorProfile.get_matrix_coefficients(),
+                                           colorProfile.get_colour_primaries());
+  }
+
+
+  uint32_t x, y;
+  for (y = 0; y < height; y++) {
+    for (x = 0; x < width; x++) {
+      int cx = (x >> shiftH);
+      int cy = (y >> shiftV);
+
+      if (matrix_coeffs == 0) {
+        if (full_range_flag) {
+          out_r[y * out_r_stride + x] = in_cr[cy * in_cr_stride + cx];
+          out_g[y * out_g_stride + x] = in_y[y * in_y_stride + x];
+          out_b[y * out_b_stride + x] = in_cb[cy * in_cb_stride + cx];
+        }
+        else {
+          // Convert from limited range to full range.
+          out_r[y * out_r_stride + x] = (Pixel) clip_f_u16((in_cr[cy * in_cr_stride + cx] - limited_range_offset) * 1.1429f, fullRange);
+          out_g[y * out_g_stride + x] = (Pixel) clip_f_u16((in_y[y * in_y_stride + x] - limited_range_offset) * 1.1689f, fullRange);
+          out_b[y * out_b_stride + x] = (Pixel) clip_f_u16((in_cb[cy * in_cb_stride + cx] - limited_range_offset) * 1.1429f, fullRange);
+        }
+      }
+      else if (matrix_coeffs == 8) {
+        // TODO: check this. I have no input image yet which is known to be correct.
+        // TODO: is there a coeff=8 with full_range=false ?
+
+        int yv = in_y[y * in_y_stride + x];
+        int cb = in_cb[cy * in_cb_stride + cx] - halfRange;
+        int cr = in_cr[cy * in_cr_stride + cx] - halfRange;
+
+        out_r[y * out_r_stride + x] = (Pixel) (clip_int_u8(yv - cb + cr));
+        out_g[y * out_g_stride + x] = (Pixel) (clip_int_u8(yv + cb));
+        out_b[y * out_b_stride + x] = (Pixel) (clip_int_u8(yv - cb - cr));
+      }
+      else if (matrix_coeffs == 16) {
+        int16_t yy = in_y[y * in_y_stride + x];
+        int16_t cb = static_cast<int16_t>(in_cb[cy * in_cb_stride + cx]) - halfRange_chroma;
+        int16_t cr = static_cast<int16_t>(in_cr[cy * in_cr_stride + cx]) - halfRange_chroma;
+
+        int16_t t = yy - (cb >> 1);
+        int16_t g = t + cb;
+        int16_t b = t - (cr>>1);
+        int16_t r = b + cr;
+
+        // TODO: we are extending the output RGB bpp by 2 bits because this function cannot do bit-depth
+        //       conversion yet. This should be ultimately replaced by a new function with implicit bit-depth reduction.
+
+        uint16_t max_rgb = static_cast<uint16_t>((1<<bpp_y)-1);
+        out_r[y * out_r_stride + x] = static_cast<Pixel>(clip_int_u16(r * 4, max_rgb));
+        out_g[y * out_g_stride + x] = static_cast<Pixel>(clip_int_u16(g * 4, max_rgb));
+        out_b[y * out_b_stride + x] = static_cast<Pixel>(clip_int_u16(b * 4, max_rgb));
+      }
+      else { // TODO: matrix_coefficients = 11,14
+        float yv, cb, cr;
+        yv = static_cast<float>(in_y[y * in_y_stride + x] );
+        cb = static_cast<float>(in_cb[cy * in_cb_stride + cx] - halfRange);
+        cr = static_cast<float>(in_cr[cy * in_cr_stride + cx] - halfRange);
+
+        if (!full_range_flag) {
+          yv = (yv - limited_range_offset) * 1.1689f;
+          cb = cb * 1.1429f;
+          cr = cr * 1.1429f;
+        }
+
+        out_r[y * out_r_stride + x] = (Pixel) (clip_f_u16(yv + coeffs.r_cr * cr, fullRange));
+        out_g[y * out_g_stride + x] = (Pixel) (clip_f_u16(yv + coeffs.g_cb * cb + coeffs.g_cr * cr, fullRange));
+        out_b[y * out_b_stride + x] = (Pixel) (clip_f_u16(yv + coeffs.b_cb * cb, fullRange));
+      }
+    }
+
+    if (has_alpha) {
+      int alphaCopyWidth = (bpp_a>8 ? width * 2 : width);
+      memcpy(&out_a[y * out_a_stride], &in_a[y * in_a_stride], alphaCopyWidth);
+    }
+  }
+
+  return outimg;
+}
+
+template class Op_YCbCr_to_RGB<uint8_t>;
+template class Op_YCbCr_to_RGB<uint16_t>;
+
+
+std::vector<ColorStateWithCost>
+Op_YCbCr420_to_RGB24::state_after_conversion(const ColorState& input_state,
+                                             const ColorState& target_state,
+                                             const heif_color_conversion_options& options,
+                                             const heif_color_conversion_options_ext& options_ext) const
+{
+  // this Op only implements the nearest-neighbor algorithm
+
+  if (input_state.chroma != heif_chroma_444) {
+    if (options.preferred_chroma_upsampling_algorithm != heif_chroma_upsampling_nearest_neighbor &&
+        options.only_use_preferred_chroma_algorithm) {
+      return {};
+    }
+  }
+
+  if (input_state.colorspace != heif_colorspace_YCbCr ||
+      input_state.chroma != heif_chroma_420 ||
+      input_state.bits_per_pixel != 8 ||
+      input_state.has_alpha == true) {
+    return {};
+  }
+
+  int matrix = input_state.nclx.get_matrix_coefficients();
+  if (matrix == 0 || matrix == 8 || matrix == 11 || matrix == 14) {
+    return {};
+  }
+  if (!input_state.nclx.get_full_range_flag()) {
+    return {};
+  }
+
+  std::vector<ColorStateWithCost> states;
+
+  ColorState output_state;
+
+  // --- convert to RGB
+
+  output_state.colorspace = heif_colorspace_RGB;
+  output_state.chroma = heif_chroma_interleaved_RGB;
+  output_state.has_alpha = false;
+  output_state.bits_per_pixel = 8;
+
+  states.emplace_back(output_state, SpeedCosts_Unoptimized);
+
+  return states;
+}
+
+
+Result<std::shared_ptr<HeifPixelImage>>
+Op_YCbCr420_to_RGB24::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                                         const ColorState& input_state,
+                                         const ColorState& target_state,
+                                         const heif_color_conversion_options& options,
+                                         const heif_color_conversion_options_ext& options_ext,
+                                         const heif_security_limits* limits) const
+{
+  if (input->get_bits_per_pixel(heif_channel_Y) != 8 ||
+      input->get_bits_per_pixel(heif_channel_Cb) != 8 ||
+      input->get_bits_per_pixel(heif_channel_Cr) != 8) {
+    return Error::InternalError;
+  }
+
+  auto outimg = std::make_shared<HeifPixelImage>();
+
+  uint32_t width = input->get_width();
+  uint32_t height = input->get_height();
+
+  outimg->create(width, height, heif_colorspace_RGB, heif_chroma_interleaved_24bit);
+
+  if (auto err = outimg->add_plane(heif_channel_interleaved, width, height, 8, limits)) {
+    return err;
+  }
+
+  YCbCr_to_RGB_coefficients coeffs = YCbCr_to_RGB_coefficients::defaults();
+  if (input->has_nclx_color_profile()) {
+    auto colorProfile = input->get_color_profile_nclx();
+    coeffs = get_YCbCr_to_RGB_coefficients(colorProfile.get_matrix_coefficients(),
+                                           colorProfile.get_colour_primaries());
+  }
+
+  int r_cr = static_cast<int>(std::lround(256 * coeffs.r_cr));
+  int g_cr = static_cast<int>(std::lround(256 * coeffs.g_cr));
+  int g_cb = static_cast<int>(std::lround(256 * coeffs.g_cb));
+  int b_cb = static_cast<int>(std::lround(256 * coeffs.b_cb));
+
+  const uint8_t* in_y, * in_cb, * in_cr;
+  size_t in_y_stride = 0, in_cb_stride = 0, in_cr_stride = 0;
+
+  uint8_t* out_p;
+  size_t out_p_stride = 0;
+
+  in_y = input->get_plane(heif_channel_Y, &in_y_stride);
+  in_cb = input->get_plane(heif_channel_Cb, &in_cb_stride);
+  in_cr = input->get_plane(heif_channel_Cr, &in_cr_stride);
+  out_p = outimg->get_plane(heif_channel_interleaved, &out_p_stride);
+
+  uint32_t x, y;
+  for (y = 0; y < height; y++) {
+    // Row pointers for input and output
+    const uint8_t* y_row = &in_y[y * in_y_stride];
+    const uint8_t* cb_row = &in_cb[(y / 2) * in_cb_stride];
+    const uint8_t* cr_row = &in_cr[(y / 2) * in_cr_stride];
+    uint8_t* out_row = &out_p[y * out_p_stride];
+
+    int cb = 0;
+    int cr = 0;
+    int r_offset = 0;
+    int g_offset = 0;
+    int b_offset = 0;
+
+    for (x = 0; x < width; x++) {
+      // Update color offsets every other pixel
+      if ((x & 1) == 0) {
+        cb = cb_row[x / 2] - 128;
+        cr = cr_row[x / 2] - 128;
+        r_offset = ((r_cr * cr + 128) >> 8);
+        g_offset = ((g_cb * cb + g_cr * cr + 128) >> 8);
+        b_offset = ((b_cb * cb + 128) >> 8);
+      }
+
+      int yv = y_row[x];
+      uint8_t* rgb = &out_row[3 * x];
+      rgb[0] = clip_int_u8(yv + r_offset);
+      rgb[1] = clip_int_u8(yv + g_offset);
+      rgb[2] = clip_int_u8(yv + b_offset);
+    }
+  }
+
+  return outimg;
+}
+
+
+std::vector<ColorStateWithCost>
+Op_YCbCr420_to_RGB32::state_after_conversion(const ColorState& input_state,
+                                             const ColorState& target_state,
+                                             const heif_color_conversion_options& options,
+                                             const heif_color_conversion_options_ext& options_ext) const
+{
+  // this Op only implements the nearest-neighbor algorithm
+
+  if (input_state.chroma != heif_chroma_444) {
+    if (options.preferred_chroma_upsampling_algorithm != heif_chroma_upsampling_nearest_neighbor &&
+        options.only_use_preferred_chroma_algorithm) {
+      return {};
+    }
+  }
+
+  // Note: no input alpha channel required. It will be filled up with 0xFF.
+
+  if (input_state.colorspace != heif_colorspace_YCbCr ||
+      input_state.chroma != heif_chroma_420 ||
+      input_state.bits_per_pixel != 8) {
+    return {};
+  }
+
+  int matrix = input_state.nclx.get_matrix_coefficients();
+  if (matrix == 0 || matrix == 8 || matrix == 11 || matrix == 14) {
+    return {};
+  }
+  if (!input_state.nclx.get_full_range_flag()) {
+    return {};
+  }
+
+  std::vector<ColorStateWithCost> states;
+
+  ColorState output_state;
+
+  // --- convert to RGB
+
+  output_state.colorspace = heif_colorspace_RGB;
+  output_state.chroma = heif_chroma_interleaved_RGBA;
+  output_state.has_alpha = true;
+  output_state.bits_per_pixel = 8;
+
+  states.emplace_back(output_state, SpeedCosts_Unoptimized);
+
+  return states;
+}
+
+
+Result<std::shared_ptr<HeifPixelImage>>
+Op_YCbCr420_to_RGB32::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                                         const ColorState& input_state,
+                                         const ColorState& target_state,
+                                         const heif_color_conversion_options& options,
+                                         const heif_color_conversion_options_ext& options_ext,
+                                         const heif_security_limits* limits) const
+{
+  if (input->get_bits_per_pixel(heif_channel_Y) != 8 ||
+      input->get_bits_per_pixel(heif_channel_Cb) != 8 ||
+      input->get_bits_per_pixel(heif_channel_Cr) != 8) {
+    return Error::InternalError;
+  }
+
+  auto outimg = std::make_shared<HeifPixelImage>();
+
+  uint32_t width = input->get_width();
+  uint32_t height = input->get_height();
+
+  outimg->create(width, height, heif_colorspace_RGB, heif_chroma_interleaved_32bit);
+
+  if (auto err = outimg->add_plane(heif_channel_interleaved, width, height, 8, limits)) {
+    return err;
+  }
+
+
+  // --- get conversion coefficients
+
+  YCbCr_to_RGB_coefficients coeffs = YCbCr_to_RGB_coefficients::defaults();
+  if (input->has_nclx_color_profile()) {
+    nclx_profile colorProfile = input->get_color_profile_nclx();
+    coeffs = get_YCbCr_to_RGB_coefficients(colorProfile.get_matrix_coefficients(),
+                                           colorProfile.get_colour_primaries());
+  }
+
+  int r_cr = static_cast<int>(std::lround(256 * coeffs.r_cr));
+  int g_cr = static_cast<int>(std::lround(256 * coeffs.g_cr));
+  int g_cb = static_cast<int>(std::lround(256 * coeffs.g_cb));
+  int b_cb = static_cast<int>(std::lround(256 * coeffs.b_cb));
+
+
+  const bool with_alpha = input->has_channel(heif_channel_Alpha);
+
+  const uint8_t* in_y, * in_cb, * in_cr, * in_a = nullptr;
+  size_t in_y_stride = 0, in_cb_stride = 0, in_cr_stride = 0, in_a_stride = 0;
+
+  uint8_t* out_p;
+  size_t out_p_stride = 0;
+
+  in_y = input->get_plane(heif_channel_Y, &in_y_stride);
+  in_cb = input->get_plane(heif_channel_Cb, &in_cb_stride);
+  in_cr = input->get_plane(heif_channel_Cr, &in_cr_stride);
+  if (with_alpha) {
+    in_a = input->get_plane(heif_channel_Alpha, &in_a_stride);
+  }
+
+  out_p = outimg->get_plane(heif_channel_interleaved, &out_p_stride);
+
+  uint32_t x, y;
+  for (y = 0; y < height; y++) {
+    for (x = 0; x < width; x++) {
+
+      int yv = (in_y[y * in_y_stride + x]);
+      int cb = (in_cb[y / 2 * in_cb_stride + x / 2] - 128);
+      int cr = (in_cr[y / 2 * in_cr_stride + x / 2] - 128);
+
+      out_p[y * out_p_stride + 4 * x + 0] = clip_int_u8(yv + ((r_cr * cr + 128) >> 8));
+      out_p[y * out_p_stride + 4 * x + 1] = clip_int_u8(yv + ((g_cb * cb + g_cr * cr + 128) >> 8));
+      out_p[y * out_p_stride + 4 * x + 2] = clip_int_u8(yv + ((b_cb * cb + 128) >> 8));
+
+
+      if (with_alpha) {
+        out_p[y * out_p_stride + 4 * x + 3] = in_a[y * in_a_stride + x];
+      }
+      else {
+        out_p[y * out_p_stride + 4 * x + 3] = 0xFF;
+      }
+    }
+  }
+
+  return outimg;
+}
+
+
+std::vector<ColorStateWithCost>
+Op_YCbCr420_to_RRGGBBaa::state_after_conversion(const ColorState& input_state,
+                                                const ColorState& target_state,
+                                                const heif_color_conversion_options& options,
+                                                const heif_color_conversion_options_ext& options_ext) const
+{
+  // this Op only implements the nearest-neighbor algorithm
+
+  if (input_state.chroma != heif_chroma_444) {
+    if (options.preferred_chroma_upsampling_algorithm != heif_chroma_upsampling_nearest_neighbor &&
+        options.only_use_preferred_chroma_algorithm) {
+      return {};
+    }
+  }
+
+  if (input_state.colorspace != heif_colorspace_YCbCr ||
+      input_state.chroma != heif_chroma_420 ||
+      input_state.bits_per_pixel <= 8) {
+    return {};
+  }
+
+  int matrix = input_state.nclx.get_matrix_coefficients();
+  if (matrix == 0 || matrix == 8 || matrix == 11 || matrix == 14) {
+    return {};
+  }
+
+  std::vector<ColorStateWithCost> states;
+
+  ColorState output_state;
+
+  // --- convert to YCbCr
+
+  output_state.colorspace = heif_colorspace_RGB;
+  output_state.chroma = (input_state.has_alpha ?
+                         heif_chroma_interleaved_RRGGBBAA_LE : heif_chroma_interleaved_RRGGBB_LE);
+  output_state.has_alpha = input_state.has_alpha;
+  output_state.bits_per_pixel = input_state.bits_per_pixel;
+
+  states.emplace_back(output_state, SpeedCosts_Unoptimized);
+
+
+  output_state.colorspace = heif_colorspace_RGB;
+  output_state.chroma = (input_state.has_alpha ?
+                         heif_chroma_interleaved_RRGGBBAA_BE : heif_chroma_interleaved_RRGGBB_BE);
+  output_state.has_alpha = input_state.has_alpha;
+  output_state.bits_per_pixel = input_state.bits_per_pixel;
+
+  states.emplace_back(output_state, SpeedCosts_Unoptimized);
+
+  return states;
+}
+
+
+Result<std::shared_ptr<HeifPixelImage>>
+Op_YCbCr420_to_RRGGBBaa::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                                            const ColorState& input_state,
+                                            const ColorState& target_state,
+                                            const heif_color_conversion_options& options,
+                                            const heif_color_conversion_options_ext& options_ext,
+                                            const heif_security_limits* limits) const
+{
+  uint32_t width = input->get_width();
+  uint32_t height = input->get_height();
+
+  int bpp = input->get_bits_per_pixel(heif_channel_Y);
+  bool has_alpha = input->has_channel(heif_channel_Alpha);
+
+  int le = (target_state.chroma == heif_chroma_interleaved_RRGGBB_LE ||
+            target_state.chroma == heif_chroma_interleaved_RRGGBBAA_LE) ? 1 : 0;
+
+  auto outimg = std::make_shared<HeifPixelImage>();
+  outimg->create(width, height, heif_colorspace_RGB, target_state.chroma);
+
+  int bytesPerPixel = has_alpha ? 8 : 6;
+
+  if (auto err = outimg->add_plane(heif_channel_interleaved, width, height, bpp, limits)) {
+    return err;
+  }
+
+  if (has_alpha) {
+    if (input->get_width(heif_channel_Alpha) != width ||
+        input->get_height(heif_channel_Alpha) != height) {
+      return Error{
+        heif_error_Unsupported_feature,
+        heif_suberror_Unspecified,
+        "Color conversion cannot handle alpha images with sizes differing from the main image size."
+      };
+    }
+
+    if (input->get_bits_per_pixel(heif_channel_Alpha) != bpp) {
+      return Error{
+        heif_error_Unsupported_feature,
+        heif_suberror_Unspecified,
+        "Color conversion cannot handle alpha images with bits-per-pixel differing from the main image."
+      };
+    }
+
+    if (auto err = outimg->add_plane(heif_channel_Alpha, width, height, bpp, limits)) {
+      return err;
+    }
+  }
+
+  uint8_t* out_p;
+  size_t out_p_stride = 0;
+
+  const uint16_t* in_y, * in_cb, * in_cr, * in_a = nullptr;
+  size_t in_y_stride = 0, in_cb_stride = 0, in_cr_stride = 0, in_a_stride = 0;
+
+  out_p = outimg->get_plane(heif_channel_interleaved, &out_p_stride);
+  in_y = (uint16_t*) input->get_plane(heif_channel_Y, &in_y_stride);
+  in_cb = (uint16_t*) input->get_plane(heif_channel_Cb, &in_cb_stride);
+  in_cr = (uint16_t*) input->get_plane(heif_channel_Cr, &in_cr_stride);
+
+  if (has_alpha) {
+    in_a = (uint16_t*) input->get_plane(heif_channel_Alpha, &in_a_stride);
+  }
+
+  int maxval = (1 << bpp) - 1;
+
+  bool full_range_flag = true;
+  YCbCr_to_RGB_coefficients coeffs = YCbCr_to_RGB_coefficients::defaults();
+
+  if (input->has_nclx_color_profile()) {
+    nclx_profile colorProfile = input->get_color_profile_nclx();
+    full_range_flag = colorProfile.get_full_range_flag();
+    coeffs = get_YCbCr_to_RGB_coefficients(colorProfile.get_matrix_coefficients(),
+                                           colorProfile.get_colour_primaries());
+  }
+
+  float limited_range_offset = static_cast<float>(16 << (bpp - 8));
+
+  for (uint32_t y = 0; y < height; y++) {
+    for (uint32_t x = 0; x < width; x++) {
+
+      float y_ = in_y[y * in_y_stride / 2 + x];
+      float cb = static_cast<float>(in_cb[y / 2 * in_cb_stride / 2 + x / 2] - (1 << (bpp - 1)));
+      float cr = static_cast<float>(in_cr[y / 2 * in_cr_stride / 2 + x / 2] - (1 << (bpp - 1)));
+
+      if (!full_range_flag) {
+        y_ = (y_ - limited_range_offset) * 1.1689f;
+        cb = cb * 1.1429f;
+        cr = cr * 1.1429f;
+      }
+
+      int r = clip_f_u16(y_ + coeffs.r_cr * cr, maxval);
+      int g = clip_f_u16(y_ + coeffs.g_cb * cb + coeffs.g_cr * cr, maxval);
+      int b = clip_f_u16(y_ + coeffs.b_cb * cb, maxval);
+
+      out_p[y * out_p_stride + bytesPerPixel * x + 0 + le] = (uint8_t) (r >> 8);
+      out_p[y * out_p_stride + bytesPerPixel * x + 2 + le] = (uint8_t) (g >> 8);
+      out_p[y * out_p_stride + bytesPerPixel * x + 4 + le] = (uint8_t) (b >> 8);
+
+      out_p[y * out_p_stride + bytesPerPixel * x + 1 - le] = (uint8_t) (r & 0xff);
+      out_p[y * out_p_stride + bytesPerPixel * x + 3 - le] = (uint8_t) (g & 0xff);
+      out_p[y * out_p_stride + bytesPerPixel * x + 5 - le] = (uint8_t) (b & 0xff);
+
+      if (has_alpha) {
+        out_p[y * out_p_stride + 8 * x + 6 + le] = (uint8_t) (in_a[y * in_a_stride / 2 + x] >> 8);
+        out_p[y * out_p_stride + 8 * x + 7 - le] = (uint8_t) (in_a[y * in_a_stride / 2 + x] & 0xff);
+      }
+    }
+  }
+
+
+  return outimg;
+}
+
diff --git a/libheif/color-conversion/yuv2rgb.h b/libheif/color-conversion/yuv2rgb.h
new file mode 100644
index 0000000000..658a37418d
--- /dev/null
+++ b/libheif/color-conversion/yuv2rgb.h
@@ -0,0 +1,106 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef LIBHEIF_COLORCONVERSION_YUV2RGB_H
+#define LIBHEIF_COLORCONVERSION_YUV2RGB_H
+
+#include <vector>
+#include <memory>
+#include "colorconversion.h"
+
+
+template<class Pixel>
+class Op_YCbCr_to_RGB : public ColorConversionOperation
+{
+public:
+  std::vector<ColorStateWithCost>
+  state_after_conversion(const ColorState& input_state,
+                         const ColorState& target_state,
+                         const heif_color_conversion_options& options,
+                         const heif_color_conversion_options_ext& options_ext) const override;
+
+  Result<std::shared_ptr<HeifPixelImage>>
+  convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                     const ColorState& input_state,
+                     const ColorState& target_state,
+                     const heif_color_conversion_options& options,
+                     const heif_color_conversion_options_ext& options_ext,
+                     const heif_security_limits* limits) const override;
+};
+
+
+class Op_YCbCr420_to_RGB24 : public ColorConversionOperation
+{
+public:
+  std::vector<ColorStateWithCost>
+  state_after_conversion(const ColorState& input_state,
+                         const ColorState& target_state,
+                         const heif_color_conversion_options& options,
+                         const heif_color_conversion_options_ext& options_ext) const override;
+
+  Result<std::shared_ptr<HeifPixelImage>>
+  convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                     const ColorState& input_state,
+                     const ColorState& target_state,
+                     const heif_color_conversion_options& options,
+                     const heif_color_conversion_options_ext& options_ext,
+                     const heif_security_limits* limits) const override;
+};
+
+
+class Op_YCbCr420_to_RGB32 : public ColorConversionOperation
+{
+public:
+  std::vector<ColorStateWithCost>
+  state_after_conversion(const ColorState& input_state,
+                         const ColorState& target_state,
+                         const heif_color_conversion_options& options,
+                         const heif_color_conversion_options_ext& options_ext) const override;
+
+  Result<std::shared_ptr<HeifPixelImage>>
+  convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                     const ColorState& input_state,
+                     const ColorState& target_state,
+                     const heif_color_conversion_options& options,
+                     const heif_color_conversion_options_ext& options_ext,
+                     const heif_security_limits* limits) const override;
+};
+
+
+class Op_YCbCr420_to_RRGGBBaa : public ColorConversionOperation
+{
+public:
+  std::vector<ColorStateWithCost>
+  state_after_conversion(const ColorState& input_state,
+                         const ColorState& target_state,
+                         const heif_color_conversion_options& options,
+                         const heif_color_conversion_options_ext& options_ext) const override;
+
+  Result<std::shared_ptr<HeifPixelImage>>
+  convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
+                     const ColorState& input_state,
+                     const ColorState& target_state,
+                     const heif_color_conversion_options& options,
+                     const heif_color_conversion_options_ext& options_ext,
+                     const heif_security_limits* limits) const override;
+};
+
+#endif //LIBHEIF_COLORCONVERSION_YUV2RGB_H
diff --git a/libheif/common_utils.cc b/libheif/common_utils.cc
new file mode 100644
index 0000000000..3c195220d4
--- /dev/null
+++ b/libheif/common_utils.cc
@@ -0,0 +1,184 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "common_utils.h"
+#include <cassert>
+
+
+uint8_t chroma_h_subsampling(heif_chroma c)
+{
+  switch (c) {
+    case heif_chroma_monochrome:
+    case heif_chroma_444:
+      return 1;
+
+    case heif_chroma_420:
+    case heif_chroma_422:
+      return 2;
+
+    case heif_chroma_interleaved_RGB:
+    case heif_chroma_interleaved_RGBA:
+    default:
+      assert(false);
+      return 0;
+  }
+}
+
+
+uint8_t chroma_v_subsampling(heif_chroma c)
+{
+  switch (c) {
+    case heif_chroma_monochrome:
+    case heif_chroma_444:
+    case heif_chroma_422:
+      return 1;
+
+    case heif_chroma_420:
+      return 2;
+
+    case heif_chroma_interleaved_RGB:
+    case heif_chroma_interleaved_RGBA:
+    default:
+      assert(false);
+      return 0;
+  }
+}
+
+
+uint32_t get_subsampled_size_h(uint32_t width,
+                               heif_channel channel,
+                               heif_chroma chroma,
+                               scaling_mode mode)
+{
+  if (channel == heif_channel_Cb ||
+      channel == heif_channel_Cr) {
+    uint8_t chromaSubH = chroma_h_subsampling(chroma);
+
+    switch (mode) {
+      case scaling_mode::round_up:
+        // NOLINTNEXTLINE(clang-analyzer-core.DivideZero)
+        return (width + chromaSubH - 1) / chromaSubH;
+      case scaling_mode::round_down:
+        // NOLINTNEXTLINE(clang-analyzer-core.DivideZero)
+        return width / chromaSubH;
+      case scaling_mode::is_divisible:
+        assert(width % chromaSubH == 0);
+        return width / chromaSubH;
+      default:
+        assert(false);
+        return 0;
+    }
+  } else {
+    return width;
+  }
+}
+
+
+uint32_t get_subsampled_size_v(uint32_t height,
+                               heif_channel channel,
+                               heif_chroma chroma,
+                               scaling_mode mode)
+{
+  if (channel == heif_channel_Cb ||
+      channel == heif_channel_Cr) {
+    uint8_t chromaSubV = chroma_v_subsampling(chroma);
+
+    switch (mode) {
+      case scaling_mode::round_up:
+        // NOLINTNEXTLINE(clang-analyzer-core.DivideZero)
+        return (height + chromaSubV - 1) / chromaSubV;
+      case scaling_mode::round_down:
+        // NOLINTNEXTLINE(clang-analyzer-core.DivideZero)
+        return height / chromaSubV;
+      case scaling_mode::is_divisible:
+        assert(height % chromaSubV == 0);
+        return height / chromaSubV;
+      default:
+        assert(false);
+        return 0;
+    }
+  } else {
+    return height;
+  }
+}
+
+
+void get_subsampled_size(uint32_t width, uint32_t height,
+                         heif_channel channel,
+                         heif_chroma chroma,
+                         uint32_t* subsampled_width, uint32_t* subsampled_height)
+{
+  *subsampled_width = get_subsampled_size_h(width, channel, chroma, scaling_mode::round_up);
+  *subsampled_height = get_subsampled_size_v(height, channel, chroma, scaling_mode::round_up);
+}
+
+
+
+uint8_t compute_avif_profile(int bits_per_pixel, heif_chroma chroma)
+{
+  if (bits_per_pixel <= 10 &&
+      (chroma == heif_chroma_420 ||
+       chroma == heif_chroma_monochrome)) {
+    return 0;
+  }
+  else if (bits_per_pixel <= 10 &&
+           chroma == heif_chroma_444) {
+    return 1;
+  }
+  else {
+    return 2;
+  }
+}
+
+
+std::string fourcc_to_string(uint32_t code)
+{
+  std::string str("    ");
+  str[0] = static_cast<char>((code >> 24) & 0xFF);
+  str[1] = static_cast<char>((code >> 16) & 0xFF);
+  str[2] = static_cast<char>((code >> 8) & 0xFF);
+  str[3] = static_cast<char>((code >> 0) & 0xFF);
+
+  return str;
+}
+
+
+Result<std::string> vector_to_string(const std::vector<uint8_t>& vec)
+{
+  if (vec.empty()) {
+    return std::string{}; // return empty string
+  }
+
+  if (vec.back() != 0) {
+    return Error{heif_error_Invalid_input,
+                 heif_suberror_Unspecified,
+                 "utf8string not null-terminated"};
+  }
+
+  for (size_t i=0;i<vec.size()-1;i++) {
+    if (vec[i] == 0) {
+      return Error{heif_error_Invalid_input,
+                   heif_suberror_Unspecified,
+                   "utf8string with null character"};
+    }
+  }
+
+  return std::string(vec.begin(), vec.end()-1);
+}
diff --git a/libheif/common_utils.h b/libheif/common_utils.h
new file mode 100644
index 0000000000..0a63a24067
--- /dev/null
+++ b/libheif/common_utils.h
@@ -0,0 +1,126 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_COMMON_UTILS_H
+#define LIBHEIF_COMMON_UTILS_H
+
+#include <cinttypes>
+#include <string>
+#include <vector>
+
+#include "libheif/heif.h"
+#include "error.h"
+
+#ifdef _MSC_VER
+#define MAYBE_UNUSED
+#else
+#define MAYBE_UNUSED __attribute__((unused))
+#endif
+
+
+constexpr uint32_t four_bytes_to_uint32(uint8_t msb, uint8_t b, uint8_t c, uint8_t lsb)
+{
+  return (static_cast<uint32_t>(msb << 24) |
+          static_cast<uint32_t>(b << 16) |
+          static_cast<uint32_t>(c << 8) |
+          static_cast<uint32_t>(lsb));
+}
+
+constexpr uint16_t two_bytes_to_uint16(uint8_t msb, uint8_t lsb)
+{
+  return (static_cast<uint16_t>(msb << 8) |
+          static_cast<uint16_t>(lsb));
+}
+
+constexpr uint32_t fourcc(const char* id)
+{
+  return four_bytes_to_uint32(static_cast<uint8_t>(id[0]),
+                              static_cast<uint8_t>(id[1]),
+                              static_cast<uint8_t>(id[2]),
+                              static_cast<uint8_t>(id[3]));
+}
+
+std::string fourcc_to_string(uint32_t code);
+
+
+// Functions for common use in libheif and the plugins.
+
+uint8_t chroma_h_subsampling(heif_chroma c);
+
+uint8_t chroma_v_subsampling(heif_chroma c);
+
+enum class scaling_mode : uint8_t {
+  round_down,
+  round_up,
+  is_divisible
+};
+
+uint32_t get_subsampled_size_h(uint32_t width,
+                               heif_channel channel,
+                               heif_chroma chroma,
+                               scaling_mode mode);
+
+uint32_t get_subsampled_size_v(uint32_t height,
+                               heif_channel channel,
+                               heif_chroma chroma,
+                               scaling_mode mode);
+
+void get_subsampled_size(uint32_t width, uint32_t height,
+                         heif_channel channel,
+                         heif_chroma chroma,
+                         uint32_t* subsampled_width, uint32_t* subsampled_height);
+
+uint8_t compute_avif_profile(int bits_per_pixel, heif_chroma chroma);
+
+
+inline uint8_t clip_int_u8(int x)
+{
+  if (x < 0) return 0;
+  if (x > 255) return 255;
+  return static_cast<uint8_t>(x);
+}
+
+inline uint16_t clip_int_u16(int32_t x, uint16_t maxi)
+{
+  if (x < 0) return 0;
+  if (x > maxi) return maxi;
+  return static_cast<uint16_t>(x);
+}
+
+
+inline uint16_t clip_f_u16(float fx, int32_t maxi)
+{
+  int32_t x = (int32_t) (fx + 0.5f);
+  if (x < 0) return 0;
+  if (x > maxi) return (uint16_t) maxi;
+  return static_cast<uint16_t>(x);
+}
+
+inline uint8_t clip_f_u8(float fx)
+{
+  int32_t x = (int32_t) (fx + 0.5f);
+  if (x < 0) return 0;
+  if (x > 255) return 255;
+  return static_cast<uint8_t>(x);
+}
+
+Result<std::string> vector_to_string(const std::vector<uint8_t>& vec);
+
+#endif //LIBHEIF_COMMON_UTILS_H
diff --git a/libheif/compression.cc b/libheif/compression.cc
new file mode 100644
index 0000000000..037cf9269c
--- /dev/null
+++ b/libheif/compression.cc
@@ -0,0 +1,61 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2026 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "compression.h"
+#include "common_utils.h"
+
+
+uint32_t unci_compression_to_fourcc(heif_unci_compression method)
+{
+  switch (method) {
+    case heif_unci_compression_off:
+      return 0;
+    case heif_unci_compression_deflate:
+      return fourcc("defl");
+    case heif_unci_compression_zlib:
+      return fourcc("zlib");
+    case heif_unci_compression_brotli:
+      return fourcc("brot");
+    default:
+      return 0;
+  }
+}
+
+
+Result<std::vector<uint8_t>> compress_unci_fourcc(uint32_t fourcc_code,
+                                                   const uint8_t* data, size_t size)
+{
+  switch (fourcc_code) {
+#if HAVE_ZLIB
+    case fourcc("defl"):
+      return {compress_deflate(data, size)};
+    case fourcc("zlib"):
+      return {compress_zlib(data, size)};
+#endif
+#if HAVE_BROTLI
+    case fourcc("brot"):
+      return {compress_brotli(data, size)};
+#endif
+    default:
+      return Error{heif_error_Unsupported_feature,
+                   heif_suberror_Unsupported_generic_compression_method,
+                   "Unsupported unci compression method."};
+  }
+}
diff --git a/libheif/compression.h b/libheif/compression.h
new file mode 100644
index 0000000000..95e4522175
--- /dev/null
+++ b/libheif/compression.h
@@ -0,0 +1,117 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2022 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef LIBHEIF_COMPRESSION_H
+#define LIBHEIF_COMPRESSION_H
+
+#include <vector>
+#include <cinttypes>
+#include <cstddef>
+
+#include <error.h>
+#include <libheif/heif_uncompressed_types.h>
+
+/**
+ * Convert heif_unci_compression enum to a fourcc code.
+ *
+ * @param method the compression method
+ * @return the corresponding fourcc code, or 0 for heif_unci_compression_off
+ */
+uint32_t unci_compression_to_fourcc(heif_unci_compression method);
+
+/**
+ * Compress data using the compression method identified by a fourcc code.
+ *
+ * @param fourcc_code the fourcc code for the compression method (e.g. "defl", "zlib", "brot")
+ * @param data pointer to the data to be compressed
+ * @param size the length of the input array in bytes
+ * @return the corresponding compressed data, or an error
+ */
+Result<std::vector<uint8_t>> compress_unci_fourcc(uint32_t fourcc_code,
+                                                   const uint8_t* data, size_t size);
+
+#if HAVE_ZLIB
+/**
+ * Compress data using zlib method.
+ * 
+ * This is the RFC 1950 format.
+ * 
+ * @param input pointer to the data to be compressed
+ * @param size the length of the input array in bytes
+ * @return the corresponding compressed data
+ */
+std::vector<uint8_t> compress_zlib(const uint8_t* input, size_t size);
+
+/**
+ * Compress data using deflate method.
+ * 
+ * This is the RFC 1951 format.
+ * 
+ * @param input pointer to the data to be compressed
+ * @param size the length of the input array in bytes
+ * @return the corresponding compressed data
+ */
+std::vector<uint8_t> compress_deflate(const uint8_t* input, size_t size);
+
+/**
+ * Decompress zlib compressed data.
+ *
+ * This is assumed to be in RFC 1950 format, which is the normal zlib format.
+ *
+ * @param compressed_input the compressed data to be decompressed
+ * @param output pointer to the resulting vector of decompressed data
+ * @return success (Ok) or an error on failure (usually corrupt data)
+ * 
+ * @sa decompress_deflate
+ * @sa compress_zlib
+ */
+Result<std::vector<uint8_t>> decompress_zlib(const std::vector<uint8_t>& compressed_input);
+
+/**
+ * Decompress "deflate" compressed data.
+ *
+ * This is assumed to be in RFC 1951 format, which is the deflate format.
+ *
+ * @param compressed_input the compressed data to be decompressed
+ * @param output pointer to the resulting vector of decompressed data
+ * @return success (Ok) or an error on failure (usually corrupt data)
+ * 
+ * @sa decompress_zlib
+ * @sa compress_deflate
+ */
+Result<std::vector<uint8_t>> decompress_deflate(const std::vector<uint8_t>& compressed_input);
+
+#endif
+
+#if HAVE_BROTLI
+/**
+ * Decompress Brotli compressed data.
+ *
+ * Brotli is described at https://brotli.org/
+ *
+ * @param compressed_input the compressed data to be decompressed
+ * @param output pointer to the resulting vector of decompressed data
+ * @return success (Ok) or an error on failure (usually corrupt data)
+ */
+Result<std::vector<uint8_t>> decompress_brotli(const std::vector<uint8_t>& compressed_input);
+
+std::vector<uint8_t> compress_brotli(const uint8_t* input, size_t size);
+#endif
+
+#endif //LIBHEIF_COMPRESSION_H
diff --git a/libheif/compression_brotli.cc b/libheif/compression_brotli.cc
new file mode 100644
index 0000000000..b6abc1fb3f
--- /dev/null
+++ b/libheif/compression_brotli.cc
@@ -0,0 +1,129 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Brad Hards <bradh@frogmouth.net>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "compression.h"
+
+#if HAVE_BROTLI
+
+const size_t BUF_SIZE = (1 << 18);
+#include <brotli/decode.h>
+#include <brotli/encode.h>
+#include <cstring>
+#include <cstdio>
+#include <string>
+#include <vector>
+
+#include "error.h"
+
+
+Result<std::vector<uint8_t>> decompress_brotli(const std::vector<uint8_t> &compressed_input)
+{
+    BrotliDecoderResult result = BROTLI_DECODER_RESULT_ERROR;
+    std::vector<uint8_t> buffer(BUF_SIZE, 0);
+    size_t available_in = compressed_input.size();
+    const std::uint8_t *next_in = reinterpret_cast<const std::uint8_t *>(compressed_input.data());
+    size_t available_out = buffer.size();
+    std::uint8_t *next_output = buffer.data();
+
+    std::unique_ptr<BrotliDecoderState, void(*)(BrotliDecoderState*)> state(BrotliDecoderCreateInstance(0, 0, 0), BrotliDecoderDestroyInstance);
+
+    std::vector<uint8_t> output;
+
+    while (true)
+    {
+        result = BrotliDecoderDecompressStream(state.get(), &available_in, &next_in, &available_out, &next_output, 0);
+
+        if (result == BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT)
+        {
+            output.insert(output.end(), buffer.data(), buffer.data() + std::distance(buffer.data(), next_output));
+            available_out = buffer.size();
+            next_output = buffer.data();
+        }
+        else if (result == BROTLI_DECODER_RESULT_SUCCESS)
+        {
+            output.insert(output.end(), buffer.data(), buffer.data() + std::distance(buffer.data(), next_output));
+            break;
+        }
+        else if (result == BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT)
+        {
+            std::stringstream sstr;
+            sstr << "Error performing brotli inflate - insufficient data.\n";
+            return Error(heif_error_Invalid_input, heif_suberror_Decompression_invalid_data, sstr.str());
+        }
+        else if (result == BROTLI_DECODER_RESULT_ERROR)
+        {
+            const char* errorMessage = BrotliDecoderErrorString(BrotliDecoderGetErrorCode(state.get()));
+            std::stringstream sstr;
+            sstr << "Error performing brotli inflate - " << errorMessage << "\n";
+            return Error(heif_error_Invalid_input, heif_suberror_Decompression_invalid_data, sstr.str());
+        }
+        else
+        {
+            const char* errorMessage = BrotliDecoderErrorString(BrotliDecoderGetErrorCode(state.get()));
+            std::stringstream sstr;
+            sstr << "Unknown error performing brotli inflate - " << errorMessage << "\n";
+            return Error(heif_error_Invalid_input, heif_suberror_Decompression_invalid_data, sstr.str());
+        }
+    }
+
+    return output;
+}
+
+
+std::vector<uint8_t> compress_brotli(const uint8_t* input, size_t size)
+{
+  std::unique_ptr<BrotliEncoderState, void(*)(BrotliEncoderState*)> state(BrotliEncoderCreateInstance(nullptr, nullptr, nullptr), BrotliEncoderDestroyInstance);
+
+  size_t available_in = size;
+  const uint8_t* next_in = input;
+
+  std::vector<uint8_t> tmp(BUF_SIZE);
+  size_t available_out = BUF_SIZE;
+  uint8_t* next_out = tmp.data();
+
+  std::vector<uint8_t> result;
+
+  for (;;) {
+    BROTLI_BOOL success = BrotliEncoderCompressStream(state.get(),
+                                                      BROTLI_OPERATION_FINISH,
+                                                      &available_in,
+                                                      &next_in,
+                                                      &available_out,
+                                                      &next_out,
+                                                      nullptr);
+    if (!success) {
+      return {};
+    }
+
+    if (next_out != tmp.data()) {
+      result.insert(result.end(), tmp.data(), tmp.data() + std::distance(tmp.data(), next_out));
+      available_out = BUF_SIZE;
+      next_out = tmp.data();
+    }
+
+    if (BrotliEncoderIsFinished(state.get())) {
+      break;
+    }
+  }
+
+  return result;
+}
+
+#endif
diff --git a/libheif/compression_zlib.cc b/libheif/compression_zlib.cc
new file mode 100644
index 0000000000..e3543d89ff
--- /dev/null
+++ b/libheif/compression_zlib.cc
@@ -0,0 +1,181 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2022 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "compression.h"
+
+
+#if HAVE_ZLIB
+
+#include <zlib.h>
+#include <cstring>
+#include <iostream>
+
+std::vector<uint8_t> compress(const uint8_t* input, size_t size, int windowSize)
+{
+  std::vector<uint8_t> output;
+
+  // initialize compressor
+
+  const int outBufferSize = 8192;
+  uint8_t dst[outBufferSize];
+
+  z_stream strm;
+  memset(&strm, 0, sizeof(z_stream));
+
+  strm.avail_in = (uInt)size;
+  strm.next_in = (Bytef*)input;
+
+  strm.avail_out = outBufferSize;
+  strm.next_out = (Bytef*) dst;
+
+  strm.zalloc = Z_NULL;
+  strm.zfree = Z_NULL;
+  strm.opaque = Z_NULL;
+
+  int err = deflateInit2(&strm, Z_DEFAULT_COMPRESSION, Z_DEFLATED, windowSize, 8, Z_DEFAULT_STRATEGY);
+  if (err != Z_OK) {
+    return {}; // TODO: return error
+  }
+
+  do {
+    strm.next_out = dst;
+    strm.avail_out = outBufferSize;
+
+    err = deflate(&strm, Z_FINISH);
+    if (err == Z_BUF_ERROR || err == Z_OK) {
+      // this is the usual case when we run out of buffer space
+      // -> do nothing
+    }
+    else if (err == Z_STREAM_ERROR) {
+      return {}; // TODO: return error
+    }
+
+
+    // append decoded data to output
+
+    output.insert(output.end(), dst, dst + outBufferSize - strm.avail_out);
+  } while (err != Z_STREAM_END);
+
+  deflateEnd(&strm);
+
+  return output;
+}
+
+
+Result<std::vector<uint8_t>> do_inflate(const std::vector<uint8_t>& compressed_input, int windowSize)
+{
+  if (compressed_input.empty()) {
+    return Error(heif_error_Invalid_input, heif_suberror_Decompression_invalid_data,
+                 "Empty zlib compressed data.");
+  }
+
+  std::vector<uint8_t> output;
+
+  // decompress data with zlib
+
+  std::vector<uint8_t> dst;
+  dst.resize(8192);
+
+  z_stream strm;
+  memset(&strm, 0, sizeof(z_stream));
+
+  strm.avail_in = (int)compressed_input.size();
+  strm.next_in = (Bytef*) compressed_input.data();
+
+  strm.avail_out = (uInt)dst.size();
+  strm.next_out = (Bytef*) dst.data();
+
+  strm.zalloc = Z_NULL;
+  strm.zfree = Z_NULL;
+  strm.opaque = Z_NULL;
+
+  int err = -1;
+
+  err = inflateInit2(&strm, windowSize);
+  if (err != Z_OK) {
+    std::stringstream sstr;
+    sstr << "Error initialising zlib inflate: " << (strm.msg ? strm.msg : "NULL") << " (" << err << ")\n";
+    return Error(heif_error_Memory_allocation_error, heif_suberror_Compression_initialisation_error, sstr.str());
+  }
+
+  do {
+    strm.avail_out = (uInt)dst.size();
+    strm.next_out = (Bytef*) dst.data();
+
+    err = inflate(&strm, Z_NO_FLUSH);
+
+    if (err == Z_BUF_ERROR) {
+      if (strm.avail_in == 0) {
+        // All input consumed; decompression is complete even without Z_STREAM_END
+        break;
+      }
+
+      if (dst.size() >= 256 * 1024 * 1024) { // TODO: make this a security limit
+        inflateEnd(&strm);
+        std::stringstream sstr;
+        sstr << "Error performing zlib inflate: maximum output buffer size exceeded\n";
+        return Error(heif_error_Memory_allocation_error, heif_suberror_Compression_initialisation_error, sstr.str());
+      }
+
+      dst.resize(dst.size() * 2);
+      strm.next_out = dst.data();
+      strm.avail_out = (uInt)dst.size();
+      continue;
+    }
+
+    if (err == Z_NEED_DICT || err == Z_DATA_ERROR || err == Z_STREAM_ERROR) {
+      inflateEnd(&strm);
+      std::stringstream sstr;
+      sstr << "Error performing zlib inflate: " << (strm.msg ? strm.msg : "NULL") << " (" << err << ")\n";
+      return Error(heif_error_Invalid_input, heif_suberror_Decompression_invalid_data, sstr.str());
+    }
+
+    // append decoded data to output
+    output.insert(output.end(), dst.begin(), dst.end() - strm.avail_out);
+  } while (err != Z_STREAM_END);
+
+
+  inflateEnd(&strm);
+
+  return output;
+}
+
+std::vector<uint8_t> compress_zlib(const uint8_t* input, size_t size)
+{
+  return compress(input, size, 15);
+}
+
+std::vector<uint8_t> compress_deflate(const uint8_t* input, size_t size)
+{
+  return compress(input, size, -15);
+}
+
+
+Result<std::vector<uint8_t>> decompress_zlib(const std::vector<uint8_t>& compressed_input)
+{
+  return do_inflate(compressed_input, 15);
+}
+
+Result<std::vector<uint8_t>> decompress_deflate(const std::vector<uint8_t>& compressed_input)
+{
+  return do_inflate(compressed_input, -15);
+}
+#endif
diff --git a/libheif/context.cc b/libheif/context.cc
new file mode 100644
index 0000000000..8b7841c305
--- /dev/null
+++ b/libheif/context.cc
@@ -0,0 +1,2126 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "box.h"
+#include "error.h"
+#include "libheif/heif.h"
+#include "region.h"
+#include "brands.h"
+#include <cstdint>
+#include <cassert>
+#include <cstring>
+#include <algorithm>
+#include <iostream>
+#include <limits>
+#include <cmath>
+#include <deque>
+#include "image-items/image_item.h"
+#include <codecs/hevc_boxes.h>
+#include "sequences/track.h"
+#include "sequences/track_visual.h"
+#include "sequences/track_metadata.h"
+#include "libheif/heif_sequences.h"
+
+#if ENABLE_PARALLEL_TILE_DECODING
+#include <future>
+#endif
+
+#include "context.h"
+#include "file.h"
+#include "pixelimage.h"
+#include "api_structs.h"
+#include "security_limits.h"
+#include "compression.h"
+#include "color-conversion/colorconversion.h"
+#include "plugin_registry.h"
+#include "image-items/hevc.h"
+#include "image-items/vvc.h"
+#include "image-items/avif.h"
+#include "image-items/jpeg.h"
+#include "image-items/mask_image.h"
+#include "image-items/jpeg2000.h"
+#include "image-items/grid.h"
+#include "image-items/overlay.h"
+#include "image-items/tiled.h"
+
+#if WITH_UNCOMPRESSED_CODEC
+#include "image-items/unc_image.h"
+#endif
+#include "text.h"
+
+
+heif_encoder::heif_encoder(const heif_encoder_plugin* _plugin)
+    : plugin(_plugin)
+{
+
+}
+
+heif_encoder::~heif_encoder()
+{
+  release();
+}
+
+void heif_encoder::release()
+{
+  if (encoder) {
+    plugin->free_encoder(encoder);
+    encoder = nullptr;
+  }
+}
+
+
+heif_error heif_encoder::alloc()
+{
+  if (encoder == nullptr) {
+    heif_error error = plugin->new_encoder(&encoder);
+    // TODO: error handling
+    return error;
+  }
+
+  return {heif_error_Ok, heif_suberror_Unspecified, Error::kSuccess};
+}
+
+
+HeifContext::HeifContext()
+    : m_memory_tracker(&m_limits)
+{
+  const char* security_limits_variable = getenv("LIBHEIF_SECURITY_LIMITS");
+
+  if (security_limits_variable && (strcmp(security_limits_variable, "off") == 0 ||
+                                   strcmp(security_limits_variable, "OFF") == 0)) {
+    m_limits = disabled_security_limits;
+  }
+  else {
+    m_limits = global_security_limits;
+  }
+
+  reset_to_empty_heif();
+}
+
+
+HeifContext::~HeifContext()
+{
+  // Break circular references between Images (when a faulty input image has circular image references)
+  for (auto& it : m_all_images) {
+    std::shared_ptr<ImageItem> image = it.second;
+    image->clear();
+  }
+}
+
+
+static void copy_security_limits(heif_security_limits* dst, const heif_security_limits* src)
+{
+  dst->max_image_size_pixels = src->max_image_size_pixels;
+  dst->max_number_of_tiles = src->max_number_of_tiles;
+  dst->max_bayer_pattern_pixels = src->max_bayer_pattern_pixels;
+  dst->max_items = src->max_items;
+
+  dst->max_color_profile_size = src->max_color_profile_size;
+  dst->max_memory_block_size = src->max_memory_block_size;
+
+  dst->max_components = src->max_components;
+
+  dst->max_iloc_extents_per_item = src->max_iloc_extents_per_item;
+  dst->max_size_entity_group = src->max_size_entity_group;
+
+  dst->max_children_per_box = src->max_children_per_box;
+
+  if (src->version >= 2) {
+    dst->max_total_memory = src->max_total_memory;
+    dst->max_sample_description_box_entries = src->max_sample_description_box_entries;
+    dst->max_sample_group_description_box_entries = src->max_sample_group_description_box_entries;
+  }
+
+  if (src->version >= 3) {
+    dst->max_sequence_frames = src->max_sequence_frames;
+    dst->max_number_of_file_brands = src->max_number_of_file_brands;
+  }
+
+  if (src->version >= 4) {
+    dst->max_bad_pixels = src->max_bad_pixels;
+  }
+}
+
+
+void HeifContext::set_security_limits(const heif_security_limits* limits)
+{
+  // copy default limits
+  if (limits->version < global_security_limits.version) {
+    copy_security_limits(&m_limits, &global_security_limits);
+  }
+
+  // overwrite with input limits
+  copy_security_limits(&m_limits, limits);
+}
+
+
+void HeifContext::set_unif(bool flag)
+{
+  m_heif_file->get_id_creator().set_unif(flag);
+}
+
+
+bool HeifContext::get_unif() const
+{
+  return m_heif_file->get_id_creator().get_unif();
+}
+
+
+IDCreator& HeifContext::get_id_creator()
+{
+  return m_heif_file->get_id_creator();
+}
+
+
+Error HeifContext::read(const std::shared_ptr<StreamReader>& reader)
+{
+  m_heif_file = std::make_shared<HeifFile>();
+  m_heif_file->set_security_limits(&m_limits);
+  Error err = m_heif_file->read(reader);
+  if (err) {
+    return err;
+  }
+
+  return interpret_heif_file();
+}
+
+Error HeifContext::read_from_file(const char* input_filename)
+{
+  m_heif_file = std::make_shared<HeifFile>();
+  m_heif_file->set_security_limits(&m_limits);
+  Error err = m_heif_file->read_from_file(input_filename);
+  if (err) {
+    return err;
+  }
+
+  return interpret_heif_file();
+}
+
+Error HeifContext::read_from_memory(const void* data, size_t size, bool copy)
+{
+  m_heif_file = std::make_shared<HeifFile>();
+  m_heif_file->set_security_limits(&m_limits);
+  Error err = m_heif_file->read_from_memory(data, size, copy);
+  if (err) {
+    return err;
+  }
+
+  return interpret_heif_file();
+}
+
+void HeifContext::reset_to_empty_heif()
+{
+  m_heif_file = std::make_shared<HeifFile>();
+  m_heif_file->set_security_limits(&m_limits);
+  m_heif_file->new_empty_file();
+
+  m_all_images.clear();
+  m_top_level_images.clear();
+  m_primary_image.reset();
+}
+
+
+std::vector<std::shared_ptr<ImageItem>> HeifContext::get_top_level_images(bool return_error_images)
+{
+  if (return_error_images) {
+    return m_top_level_images;
+  }
+  else {
+    std::vector<std::shared_ptr<ImageItem>> filtered;
+    for (auto& item : m_top_level_images) {
+      if (!item->get_item_error()) {
+        filtered.push_back(item);
+      }
+    }
+
+    return filtered;
+  }
+}
+
+
+std::shared_ptr<ImageItem> HeifContext::get_image(heif_item_id id, bool return_error_images)
+{
+  auto iter = m_all_images.find(id);
+  if (iter == m_all_images.end()) {
+    return nullptr;
+  }
+  else {
+    if (iter->second->get_item_error() && !return_error_images) {
+      return nullptr;
+    }
+    else {
+      return iter->second;
+    }
+  }
+}
+
+
+std::shared_ptr<ImageItem> HeifContext::get_primary_image(bool return_error_image)
+{
+  if (m_primary_image == nullptr)
+    return nullptr;
+  else if (!return_error_image && m_primary_image->get_item_error())
+    return nullptr;
+  else
+    return m_primary_image;
+}
+
+
+std::shared_ptr<const ImageItem> HeifContext::get_primary_image(bool return_error_image) const
+{
+  return const_cast<HeifContext*>(this)->get_primary_image(return_error_image);
+}
+
+
+bool HeifContext::is_image(heif_item_id ID) const
+{
+  return m_all_images.contains(ID);
+}
+
+
+Result<std::shared_ptr<RegionItem>> HeifContext::add_region_item(uint32_t reference_width, uint32_t reference_height)
+{
+  auto boxResult = m_heif_file->add_new_infe_box(fourcc("rgan"));
+  if (!boxResult) {
+    return boxResult.error();
+  }
+  auto box = *boxResult;
+  box->set_hidden_item(true);
+
+  auto regionItem = std::make_shared<RegionItem>(box->get_item_ID(), reference_width, reference_height);
+  add_region_item(regionItem);
+
+  return regionItem;
+}
+
+void HeifContext::add_region_referenced_mask_ref(heif_item_id region_item_id, heif_item_id mask_item_id)
+{
+  m_heif_file->add_iref_reference(region_item_id, fourcc("mask"), {mask_item_id});
+}
+
+
+static uint64_t rescale(uint64_t duration, uint32_t old_base, uint32_t new_base)
+{
+  // prevent division by zero
+  // TODO: we might emit an error in this case
+  if (old_base == 0) {
+    return 0;
+  }
+
+  return duration * new_base / old_base;
+}
+
+
+Error HeifContext::write(StreamWriter& writer)
+{
+  // --- finalize some parameters
+
+  uint64_t max_sequence_duration = 0;
+  if (auto mvhd = m_heif_file->get_mvhd_box()) {
+    for (const auto& track : m_tracks) {
+      track.second->finalize_track();
+
+      // rescale track duration to movie timescale units
+
+      uint64_t track_duration_in_media_units = track.second->get_duration_in_media_units();
+      uint32_t media_timescale = track.second->get_timescale();
+
+      uint32_t mvhd_timescale = m_heif_file->get_mvhd_box()->get_time_scale();
+      if (mvhd_timescale == 0) {
+        mvhd_timescale = track.second->get_timescale();
+        m_heif_file->get_mvhd_box()->set_time_scale(mvhd_timescale);
+      }
+
+      uint64_t movie_duration = rescale(track_duration_in_media_units, media_timescale, mvhd_timescale);
+      uint64_t unrepeated_movie_duration = movie_duration;
+
+      // sequence repetitions
+
+      if (m_sequence_repetitions == heif_sequence_maximum_number_of_repetitions) {
+        movie_duration = std::numeric_limits<uint64_t>::max();
+      }
+      else {
+        if (std::numeric_limits<uint64_t>::max() / m_sequence_repetitions < movie_duration) {
+          movie_duration = std::numeric_limits<uint64_t>::max();
+        }
+        else {
+          movie_duration *= m_sequence_repetitions;
+        }
+      }
+
+      if (m_sequence_repetitions != 1) {
+        track.second->enable_edit_list_repeat_mode(true);
+      }
+
+      track.second->set_track_duration_in_movie_units(movie_duration, unrepeated_movie_duration);
+
+      max_sequence_duration = std::max(max_sequence_duration, movie_duration);
+    }
+
+    mvhd->set_duration(max_sequence_duration);
+  }
+
+  // --- serialize regions
+
+  for (auto& image : m_all_images) {
+    for (auto region : image.second->get_region_item_ids()) {
+      m_heif_file->add_iref_reference(region,
+                                      fourcc("cdsc"), {image.first});
+    }
+  }
+
+  for (auto& region : m_region_items) {
+    std::vector<uint8_t> data_array;
+    Error err = region->encode(data_array);
+    if (err) {
+      return err;
+    }
+
+    m_heif_file->append_iloc_data(region->item_id, data_array, 0);
+  }
+
+  // --- serialise text items
+
+  for (auto& image : m_all_images) {
+    for (auto text_item_id : image.second->get_text_item_ids()) {
+      m_heif_file->add_iref_reference(text_item_id, fourcc("text"), {image.first});
+    }
+  }
+
+  for (auto& text_item : m_text_items) {
+    auto encodeResult = text_item->encode();
+    if (encodeResult) {
+      m_heif_file->append_iloc_data(text_item->get_item_id(), *encodeResult, 1);
+    }
+  }
+
+  // --- post-process images
+
+  for (auto& img : m_all_images) {
+    Error err = img.second->process_before_write();
+    if (err) {
+      return err;
+    }
+  }
+
+  // --- sort item properties
+
+  if (auto ipma = m_heif_file->get_ipma_box()) {
+    ipma->sort_properties(m_heif_file->get_ipco_box());
+  }
+
+  // --- derive box versions
+
+  m_heif_file->derive_box_versions();
+
+  // --- determine brands
+
+  heif_brand2 main_brand;
+  std::vector<heif_brand2> compatible_brands;
+  compatible_brands = compute_compatible_brands(this, &main_brand);
+
+  // Note: major brand should be repeated in the compatible brands, according to this:
+  //   ISOBMFF (ISO/IEC 14496-12:2020) § K.4:
+  //   NOTE This document requires that the major brand be repeated in the compatible-brands,
+  //   but this requirement is relaxed in the 'profiles' parameter for compactness.
+  // See https://github.com/strukturag/libheif/issues/478
+
+  auto ftyp = m_heif_file->get_ftyp_box();
+
+  // set major brand if not set manually yet
+  if (ftyp->get_major_brand() == 0) {
+    ftyp->set_major_brand(main_brand);
+  }
+
+  ftyp->set_minor_version(0);
+  for (auto brand : compatible_brands) {
+    ftyp->add_compatible_brand(brand);
+  }
+
+  // --- write to file
+
+  m_heif_file->write(writer);
+
+  return {};
+}
+
+std::string HeifContext::debug_dump_boxes() const
+{
+  return m_heif_file->debug_dump_boxes();
+}
+
+
+static bool item_type_is_image(uint32_t item_type, const std::string& content_type)
+{
+  return (item_type == fourcc("hvc1") ||
+          item_type == fourcc("av01") ||
+          item_type == fourcc("grid") ||
+          item_type == fourcc("tili") ||
+          item_type == fourcc("iden") ||
+          item_type == fourcc("iovl") ||
+          item_type == fourcc("avc1") ||
+          item_type == fourcc("unci") ||
+          item_type == fourcc("vvc1") ||
+          item_type == fourcc("jpeg") ||
+          (item_type == fourcc("mime") && content_type == "image/jpeg") ||
+          item_type == fourcc("j2k1") ||
+          item_type == fourcc("mski"));
+}
+
+
+void HeifContext::remove_top_level_image(const std::shared_ptr<ImageItem>& image)
+{
+  std::vector<std::shared_ptr<ImageItem>> new_list;
+
+  for (const auto& img : m_top_level_images) {
+    if (img != image) {
+      new_list.push_back(img);
+    }
+  }
+
+  m_top_level_images = std::move(new_list);
+}
+
+
+Error HeifContext::interpret_heif_file()
+{
+  if (m_heif_file->has_images()) {
+    Error err = interpret_heif_file_images();
+    if (err) {
+      return err;
+    }
+  }
+
+  if (m_heif_file->has_sequences()) {
+    Error err = interpret_heif_file_sequences();
+    if (err) {
+      return err;
+    }
+  }
+
+  return Error::Ok;
+}
+
+
+Error HeifContext::interpret_heif_file_images()
+{
+  m_all_images.clear();
+  m_top_level_images.clear();
+  m_primary_image.reset();
+
+
+  // --- reference all non-hidden images
+
+  std::vector<heif_item_id> image_IDs = m_heif_file->get_item_IDs();
+
+  for (heif_item_id id : image_IDs) {
+    auto infe_box = m_heif_file->get_infe_box(id);
+    if (!infe_box) {
+      // TODO(farindk): Should we return an error instead of skipping the invalid id?
+      continue;
+    }
+
+    auto imageItem = ImageItem::alloc_for_infe_box(this, infe_box);
+    if (!imageItem) {
+      // It is no imageItem item, skip it.
+      continue;
+    }
+
+    std::vector<std::shared_ptr<Box>> properties;
+    Error err = m_heif_file->get_properties(id, properties);
+    if (err) {
+      imageItem = std::make_shared<ImageItem_Error>(imageItem->get_infe_type(), id, err);
+    }
+
+    imageItem->set_properties(properties);
+
+    err = imageItem->initialize_decoder();
+    if (err) {
+      imageItem = std::make_shared<ImageItem_Error>(imageItem->get_infe_type(), id, err);
+      imageItem->set_properties(properties);
+    }
+
+    m_all_images.insert(std::make_pair(id, imageItem));
+
+    if (!infe_box->is_hidden_item()) {
+      if (id == m_heif_file->get_primary_image_ID()) {
+        imageItem->set_primary(true);
+        m_primary_image = imageItem;
+      }
+
+      m_top_level_images.push_back(imageItem);
+    }
+
+    imageItem->set_decoder_input_data();
+  }
+
+  if (!m_primary_image) {
+    return Error(heif_error_Invalid_input,
+                 heif_suberror_Nonexisting_item_referenced,
+                 "'pitm' box references an unsupported or non-existing image");
+  }
+
+
+  // --- process image properties
+
+  for (auto& pair : m_all_images) {
+    auto& image = pair.second;
+
+    if (image->get_item_error()) {
+      continue;
+    }
+
+    std::vector<std::shared_ptr<Box>> properties;
+
+    Error err = m_heif_file->get_properties(pair.first, properties);
+    if (err) {
+      return err;
+    }
+
+
+    // --- are there any 'essential' properties that we did not parse?
+
+    for (const auto& prop : properties) {
+      if (std::dynamic_pointer_cast<Box_other>(prop) &&
+          get_heif_file()->get_ipco_box()->is_property_essential_for_item(pair.first, prop, get_heif_file()->get_ipma_box())) {
+
+        std::stringstream sstr;
+        sstr << "could not parse item property '" << prop->get_type_string() << "'";
+        return {heif_error_Unsupported_feature, heif_suberror_Unsupported_essential_property, sstr.str()};
+      }
+    }
+
+
+    // --- Are there any parse errors in optional properties? Attach the errors as warnings to the images.
+
+    bool ignore_nonfatal_parse_errors = false; // TODO: this should be a user option. Where should we put this (heif_decoding_options, or while creating the context) ?
+
+    for (const auto& prop : properties) {
+      if (auto errorbox = std::dynamic_pointer_cast<Box_Error>(prop)) {
+        parse_error_fatality fatality = errorbox->get_parse_error_fatality();
+
+        if (fatality == parse_error_fatality::optional ||
+            (fatality == parse_error_fatality::ignorable && ignore_nonfatal_parse_errors)) {
+          image->add_decoding_warning(errorbox->get_error());
+        }
+        else {
+          return errorbox->get_error();
+        }
+      }
+    }
+
+
+    // --- extract image resolution
+
+    bool ispe_read = false;
+    for (const auto& prop : properties) {
+      auto ispe = std::dynamic_pointer_cast<Box_ispe>(prop);
+      if (ispe) {
+        uint32_t width = ispe->get_width();
+        uint32_t height = ispe->get_height();
+
+        if (width == 0 || height == 0) {
+          return {heif_error_Invalid_input,
+                  heif_suberror_Invalid_image_size,
+                  "Zero image width or height"};
+        }
+
+        image->set_resolution(width, height);
+        ispe_read = true;
+      }
+    }
+
+    // Note: usually, we would like to check here if an `ispe` property exists as this is mandatory.
+    // We want to do this if decoding_options.strict_decoding is set, but we cannot because we have no decoding_options
+    // when parsing the file structure.
+
+    if (!ispe_read) {
+      image->add_decoding_warning({heif_error_Invalid_input, heif_suberror_No_ispe_property});
+    }
+
+
+    for (const auto& prop : properties) {
+      auto colr = std::dynamic_pointer_cast<Box_colr>(prop);
+      if (colr) {
+        auto profile = colr->get_color_profile();
+        image->set_color_profile(profile);
+        continue;
+      }
+
+      auto cmin = std::dynamic_pointer_cast<Box_cmin>(prop);
+      if (cmin) {
+        if (!ispe_read) {
+          return {heif_error_Invalid_input, heif_suberror_No_ispe_property};
+        }
+
+        image->set_intrinsic_matrix(cmin->get_intrinsic_matrix());
+      }
+
+      auto cmex = std::dynamic_pointer_cast<Box_cmex>(prop);
+      if (cmex) {
+        image->set_extrinsic_matrix(cmex->get_extrinsic_matrix());
+      }
+    }
+
+
+    for (const auto& prop : properties) {
+      auto clap = std::dynamic_pointer_cast<Box_clap>(prop);
+      if (clap) {
+        image->set_resolution(clap->get_width_rounded(),
+                              clap->get_height_rounded());
+
+        if (image->has_intrinsic_matrix()) {
+          image->get_intrinsic_matrix().apply_clap(clap.get(), image->get_width(), image->get_height());
+        }
+      }
+
+      auto imir = std::dynamic_pointer_cast<Box_imir>(prop);
+      if (imir) {
+        if (!ispe_read) {
+          return {heif_error_Invalid_input, heif_suberror_No_ispe_property};
+        }
+
+        image->get_intrinsic_matrix().apply_imir(imir.get(), image->get_width(), image->get_height());
+      }
+
+      auto irot = std::dynamic_pointer_cast<Box_irot>(prop);
+      if (irot) {
+        if (irot->get_rotation_ccw() == 90 ||
+            irot->get_rotation_ccw() == 270) {
+          if (!ispe_read) {
+            return {heif_error_Invalid_input, heif_suberror_No_ispe_property};
+          }
+
+          // swap width and height
+          image->set_resolution(image->get_height(),
+                                image->get_width());
+        }
+
+        // TODO: apply irot to camera extrinsic matrix
+      }
+    }
+
+
+    // --- assign GIMI content-ID to image
+
+    if (auto box_gimi_content_id = image->get_property<Box_gimi_content_id>()) {
+      image->set_gimi_sample_content_id(box_gimi_content_id->get_content_id());
+    }
+
+#if HEIF_WITH_OMAF
+    // add image projection information
+    if (auto prfr = image->get_property<Box_prfr>()) {
+      image->ImageExtraData::set_omaf_image_projection(prfr->get_omaf_image_projection());
+    }
+#endif
+  }
+
+
+  // --- remove auxiliary from top-level images and assign to their respective image
+
+  auto iref_box = m_heif_file->get_iref_box();
+  if (iref_box) {
+    // m_top_level_images.clear();
+
+    for (auto& pair : m_all_images) {
+      auto& image = pair.second;
+
+      std::vector<Box_iref::Reference> references = iref_box->get_references_from(image->get_id());
+
+      for (const Box_iref::Reference& ref : references) {
+        uint32_t type = ref.header.get_short_type();
+
+        if (type == fourcc("thmb")) {
+          // --- this is a thumbnail image, attach to the main image
+
+          std::vector<heif_item_id> refs = ref.to_item_ID;
+          for (heif_item_id ref: refs) {
+            image->set_is_thumbnail();
+
+            auto master_iter = m_all_images.find(ref);
+            if (master_iter == m_all_images.end()) {
+              return Error(heif_error_Invalid_input,
+                          heif_suberror_Nonexisting_item_referenced,
+                          "Thumbnail references a non-existing image");
+            }
+
+            if (master_iter->second->is_thumbnail()) {
+              return Error(heif_error_Invalid_input,
+                          heif_suberror_Nonexisting_item_referenced,
+                          "Thumbnail references another thumbnail");
+            }
+
+            if (image.get() == master_iter->second.get()) {
+              return Error(heif_error_Invalid_input,
+                          heif_suberror_Nonexisting_item_referenced,
+                          "Recursive thumbnail image detected");
+            }
+            master_iter->second->add_thumbnail(image);
+          }
+          remove_top_level_image(image);
+        }
+        else if (type == fourcc("auxl")) {
+
+          // --- this is an auxiliary image
+          //     check whether it is an alpha channel and attach to the main image if yes
+
+          std::shared_ptr<Box_auxC> auxC_property = image->get_property<Box_auxC>();
+          if (!auxC_property) {
+            std::stringstream sstr;
+            sstr << "No auxC property for image " << image->get_id();
+            return Error(heif_error_Invalid_input,
+                         heif_suberror_Auxiliary_image_type_unspecified,
+                         sstr.str());
+          }
+
+          std::vector<heif_item_id> refs = ref.to_item_ID;
+
+          // alpha channel
+
+          if (auxC_property->get_aux_type() == "urn:mpeg:avc:2015:auxid:1" ||   // HEIF (avc)
+              auxC_property->get_aux_type() == "urn:mpeg:hevc:2015:auxid:1" ||  // HEIF (h265)
+              auxC_property->get_aux_type() == "urn:mpeg:mpegB:cicp:systems:auxiliary:alpha") { // MIAF
+
+            for (heif_item_id ref: refs) {
+              auto master_iter = m_all_images.find(ref);
+              if (master_iter == m_all_images.end()) {
+
+                if (!m_heif_file->has_item_with_id(ref)) {
+                  return Error(heif_error_Invalid_input,
+                               heif_suberror_Nonexisting_item_referenced,
+                               "Non-existing alpha image referenced");
+                }
+
+                continue;
+              }
+
+              auto master_img = master_iter->second;
+
+              if (image.get() == master_img.get()) {
+                return Error(heif_error_Invalid_input,
+                            heif_suberror_Nonexisting_item_referenced,
+                            "Recursive alpha image detected");
+              }
+
+              image->set_is_alpha_channel();
+              master_img->set_alpha_channel(image);
+            }
+          }
+
+
+          // depth channel
+
+          if (auxC_property->get_aux_type() == "urn:mpeg:hevc:2015:auxid:2" || // HEIF
+              auxC_property->get_aux_type() == "urn:mpeg:mpegB:cicp:systems:auxiliary:depth") { // AVIF
+            image->set_is_depth_channel();
+
+            for (heif_item_id ref: refs) {
+              auto master_iter = m_all_images.find(ref);
+              if (master_iter == m_all_images.end()) {
+
+                if (!m_heif_file->has_item_with_id(ref)) {
+                  return Error(heif_error_Invalid_input,
+                               heif_suberror_Nonexisting_item_referenced,
+                               "Non-existing depth image referenced");
+                }
+
+                continue;
+              }
+              if (image.get() == master_iter->second.get()) {
+                return Error(heif_error_Invalid_input,
+                            heif_suberror_Nonexisting_item_referenced,
+                            "Recursive depth image detected");
+              }
+              master_iter->second->set_depth_channel(image);
+
+              const auto& subtypes = auxC_property->get_subtypes();
+
+              if (!subtypes.empty()) {
+                std::vector<std::shared_ptr<SEIMessage>> sei_messages;
+                Error err = decode_hevc_aux_sei_messages(subtypes, sei_messages);
+                if (err) {
+                  return err;
+                }
+
+                for (auto& msg : sei_messages) {
+                  auto depth_msg = std::dynamic_pointer_cast<SEIMessage_depth_representation_info>(msg);
+                  if (depth_msg) {
+                    image->set_depth_representation_info(*depth_msg);
+                  }
+                }
+              }
+            }
+          }
+
+
+          // --- generic aux image
+
+          image->set_is_aux_image(auxC_property->get_aux_type());
+
+          for (heif_item_id ref: refs) {
+            auto master_iter = m_all_images.find(ref);
+            if (master_iter == m_all_images.end()) {
+
+              if (!m_heif_file->has_item_with_id(ref)) {
+                return Error(heif_error_Invalid_input,
+                             heif_suberror_Nonexisting_item_referenced,
+                             "Non-existing aux image referenced");
+              }
+
+              continue;
+            }
+            if (image.get() == master_iter->second.get()) {
+              return Error(heif_error_Invalid_input,
+                          heif_suberror_Nonexisting_item_referenced,
+                          "Recursive aux image detected");
+            }
+
+            master_iter->second->add_aux_image(image);
+
+            remove_top_level_image(image);
+          }
+        }
+        else {
+          // 'image' is a normal image, keep it as a top-level image
+        }
+      }
+    }
+  }
+
+
+  // --- check that HEVC images have an hvcC property
+
+  for (auto& pair : m_all_images) {
+    auto& image = pair.second;
+
+    if (image->get_item_error()) {
+      continue;
+    }
+
+    std::shared_ptr<Box_infe> infe = m_heif_file->get_infe_box(image->get_id());
+    if (infe->get_item_type_4cc() == fourcc("hvc1")) {
+
+      auto ipma = m_heif_file->get_ipma_box();
+      auto ipco = m_heif_file->get_ipco_box();
+
+      if (!ipco->get_property_for_item_ID(image->get_id(), ipma, fourcc("hvcC"))) {
+        return Error(heif_error_Invalid_input,
+                     heif_suberror_No_hvcC_box,
+                     "No hvcC property in hvc1 type image");
+      }
+    }
+    if (infe->get_item_type_4cc() == fourcc("vvc1")) {
+
+      auto ipma = m_heif_file->get_ipma_box();
+      auto ipco = m_heif_file->get_ipco_box();
+
+      if (!ipco->get_property_for_item_ID(image->get_id(), ipma, fourcc("vvcC"))) {
+        return Error(heif_error_Invalid_input,
+                     heif_suberror_No_vvcC_box,
+                     "No vvcC property in vvc1 type image");
+      }
+    }
+    // TODO: check for AV1, AVC, JPEG, J2K
+  }
+
+
+  // --- assign color profile from grid tiles to main image when main image has no profile assigned
+
+  for (auto& pair : m_all_images) {
+    auto& image = pair.second;
+    auto id = pair.first;
+
+    if (image->get_item_error()) {
+      continue;
+    }
+
+    auto infe_box = m_heif_file->get_infe_box(id);
+    if (!infe_box) {
+      continue;
+    }
+
+    if (!iref_box) {
+      break;
+    }
+
+    if (infe_box->get_item_type_4cc() == fourcc("grid")) {
+      std::vector<heif_item_id> image_references = iref_box->get_references(id, fourcc("dimg"));
+
+      if (image_references.empty()) {
+        continue; // TODO: can this every happen?
+      }
+
+      auto tileId = image_references.front();
+
+      auto iter = m_all_images.find(tileId);
+      if (iter == m_all_images.end()) {
+        continue; // invalid grid entry
+      }
+
+      auto tile_img = iter->second;
+      if (image->get_color_profile_icc() == nullptr && tile_img->get_color_profile_icc()) {
+        image->set_color_profile(tile_img->get_color_profile_icc());
+      }
+
+      if (!image->has_nclx_color_profile() && tile_img->has_nclx_color_profile()) {
+        image->set_color_profile_nclx(tile_img->get_color_profile_nclx());
+      }
+    }
+  }
+
+
+  // --- read metadata and assign to image
+
+  for (heif_item_id id : image_IDs) {
+    uint32_t item_type = m_heif_file->get_item_type_4cc(id);
+    std::string content_type = m_heif_file->get_content_type(id);
+
+    // 'rgan': skip region annotations, handled next
+    // 'iden': iden images are no metadata
+    if (item_type_is_image(item_type, content_type) || item_type == fourcc("rgan")) {
+      continue;
+    }
+
+    std::string item_uri_type = m_heif_file->get_item_uri_type(id);
+
+    // we now assign all kinds of metadata to the image, not only 'Exif' and 'XMP'
+
+    std::shared_ptr<ImageMetadata> metadata = std::make_shared<ImageMetadata>();
+    metadata->item_id = id;
+    metadata->item_type = fourcc_to_string(item_type);
+    metadata->content_type = content_type;
+    metadata->item_uri_type = std::move(item_uri_type);
+
+    auto metadataResult = m_heif_file->get_uncompressed_item_data(id);
+    if (!metadataResult) {
+      if (item_type == fourcc("Exif") || item_type == fourcc("mime")) {
+        // these item types should have data
+        return metadataResult.error();
+      }
+      else {
+        // anything else is probably something that we don't understand yet
+        continue;
+      }
+    }
+    else {
+      metadata->m_data = *metadataResult;
+    }
+
+    // --- assign metadata to the image
+
+    if (iref_box) {
+      std::vector<heif_item_id> references = iref_box->get_references(id, fourcc("cdsc"));
+      for (heif_item_id exif_image_id : references) {
+        auto img_iter = m_all_images.find(exif_image_id);
+        if (img_iter == m_all_images.end()) {
+          if (!m_heif_file->has_item_with_id(exif_image_id)) {
+            return Error(heif_error_Invalid_input,
+                         heif_suberror_Nonexisting_item_referenced,
+                         "Metadata assigned to non-existing image");
+          }
+
+          continue;
+        }
+        img_iter->second->add_metadata(metadata);
+      }
+    }
+  }
+
+  // --- set premultiplied alpha flag
+
+  for (heif_item_id id : image_IDs) {
+    if (iref_box) {
+      std::vector<heif_item_id> references = iref_box->get_references(id, fourcc("prem"));
+      for (heif_item_id ref : references) {
+        (void)ref;
+
+        heif_item_id color_image_id = id;
+        auto img_iter = m_all_images.find(color_image_id);
+        if (img_iter == m_all_images.end()) {
+          return Error(heif_error_Invalid_input,
+                       heif_suberror_Nonexisting_item_referenced,
+                       "`prem` link assigned to non-existing image");
+        }
+
+        img_iter->second->set_is_premultiplied_alpha(true);
+      }
+    }
+  }
+
+  // --- read region item and assign to image(s)
+
+  for (heif_item_id id : image_IDs) {
+    uint32_t item_type = m_heif_file->get_item_type_4cc(id);
+    if (item_type != fourcc("rgan")) {
+      continue;
+    }
+
+    std::shared_ptr<RegionItem> region_item = std::make_shared<RegionItem>();
+    region_item->item_id = id;
+
+    Result regionDataResult = m_heif_file->get_uncompressed_item_data(id);
+    if (!regionDataResult) {
+      return regionDataResult.error();
+    }
+    region_item->parse(*regionDataResult, get_security_limits());
+
+    if (iref_box) {
+      std::vector<Box_iref::Reference> references = iref_box->get_references_from(id);
+      for (const auto& ref : references) {
+        if (ref.header.get_short_type() == fourcc("cdsc")) {
+          std::vector<uint32_t> refs = ref.to_item_ID;
+          for (uint32_t ref : refs) {
+            uint32_t image_id = ref;
+            auto img_iter = m_all_images.find(image_id);
+            if (img_iter == m_all_images.end()) {
+              return Error(heif_error_Invalid_input,
+                           heif_suberror_Nonexisting_item_referenced,
+                           "Region item assigned to non-existing image");
+            }
+            img_iter->second->add_region_item_id(id);
+            m_region_items.push_back(region_item);
+          }
+        }
+
+        /* When the geometry 'mask' of a region is represented by a mask stored in
+        * another image item the image item containing the mask shall be identified
+        * by an item reference of type 'mask' from the region item to the image item
+        * containing the mask. */
+        if (ref.header.get_short_type() == fourcc("mask")) {
+          std::vector<uint32_t> refs = ref.to_item_ID;
+          size_t mask_index = 0;
+          for (int j = 0; j < region_item->get_number_of_regions(); j++) {
+            if (region_item->get_regions()[j]->getRegionType() == heif_region_type_referenced_mask) {
+              std::shared_ptr<RegionGeometry_ReferencedMask> mask_geometry = std::dynamic_pointer_cast<RegionGeometry_ReferencedMask>(region_item->get_regions()[j]);
+
+              if (mask_index >= refs.size()) {
+                return Error(heif_error_Invalid_input,
+                             heif_suberror_Unspecified,
+                             "Region mask reference with non-existing mask image reference");
+              }
+
+              uint32_t mask_image_id = refs[mask_index];
+              if (!is_image(mask_image_id)) {
+                return Error(heif_error_Invalid_input,
+                             heif_suberror_Unspecified,
+                             "Region mask referenced item is not an image");
+              }
+
+              auto mask_image = get_image(mask_image_id, true);
+              if (auto error = mask_image->get_item_error()) {
+                return error;
+              }
+
+              mask_geometry->referenced_item = mask_image_id;
+              if (mask_geometry->width == 0) {
+                mask_geometry->width = mask_image->get_ispe_width();
+              }
+              if (mask_geometry->height == 0) {
+                mask_geometry->height = mask_image->get_ispe_height();
+              }
+              mask_index += 1;
+              remove_top_level_image(mask_image);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // --- read text item and assign to image(s)
+  for (heif_item_id id : image_IDs) {
+    uint32_t item_type = m_heif_file->get_item_type_4cc(id);
+    if (item_type != fourcc("mime")) { // TODO: && content_type  starts with "text/" ?
+      continue;
+    }
+    std::shared_ptr<TextItem> text_item = std::make_shared<TextItem>();
+    text_item->set_item_id(id);
+
+    auto textDataResult = m_heif_file->get_uncompressed_item_data(id);
+    if (!textDataResult) {
+      return textDataResult.error();
+    }
+
+    text_item->parse(*textDataResult);
+    if (iref_box) {
+      std::vector<Box_iref::Reference> references = iref_box->get_references_from(id);
+      for (const auto& ref : references) {
+        if (ref.header.get_short_type() == fourcc("text")) {
+          std::vector<uint32_t> refs = ref.to_item_ID;
+          for (uint32_t ref : refs) {
+            uint32_t image_id = ref;
+            auto img_iter = m_all_images.find(image_id);
+            if (img_iter == m_all_images.end()) {
+              return Error(heif_error_Invalid_input,
+                           heif_suberror_Nonexisting_item_referenced,
+                           "Text item assigned to non-existing image");
+            }
+            img_iter->second->add_text_item_id(id);
+            m_text_items.push_back(text_item);
+          }
+        }
+      }
+    }
+  }
+
+  return Error::Ok;
+}
+
+
+bool HeifContext::has_alpha(heif_item_id ID) const
+{
+  auto imgIter = m_all_images.find(ID);
+  if (imgIter == m_all_images.end()) {
+    return false;
+  }
+
+  auto img = imgIter->second;
+
+  // --- has the image an auxiliary alpha image?
+
+  if (img->get_alpha_channel() != nullptr) {
+    return true;
+  }
+
+  if (img->has_coded_alpha_channel()) {
+    return true;
+  }
+
+  heif_colorspace colorspace;
+  heif_chroma chroma;
+  Error err = img->get_coded_image_colorspace(&colorspace, &chroma);
+  if (err) {
+    return false;
+  }
+
+  if (chroma == heif_chroma_interleaved_RGBA ||
+      chroma == heif_chroma_interleaved_RRGGBBAA_BE ||
+      chroma == heif_chroma_interleaved_RRGGBBAA_LE) {
+    return true;
+  }
+
+  // --- if the image is a 'grid', check if there is alpha in any of the tiles
+
+  // TODO: move this into ImageItem
+
+  uint32_t image_type = m_heif_file->get_item_type_4cc(ID);
+  if (image_type == fourcc("grid")) {
+
+    Result gridDataResult = m_heif_file->get_uncompressed_item_data(ID);
+    if (!gridDataResult) {
+      return false;
+    }
+
+    ImageGrid grid;
+    err = grid.parse(*gridDataResult);
+    if (err) {
+      return false;
+    }
+
+
+    auto iref_box = m_heif_file->get_iref_box();
+
+    if (!iref_box) {
+      return false;
+    }
+
+    std::vector<heif_item_id> image_references = iref_box->get_references(ID, fourcc("dimg"));
+
+    if ((int) image_references.size() != grid.get_rows() * grid.get_columns()) {
+      return false;
+    }
+
+
+    // --- check that all image IDs are valid images
+
+    for (heif_item_id tile_id : image_references) {
+      if (!is_image(tile_id)) {
+        return false;
+      }
+    }
+
+    // --- check whether at least one tile has an alpha channel
+
+    bool has_alpha = false;
+
+    for (heif_item_id tile_id : image_references) {
+      auto iter = m_all_images.find(tile_id);
+      if (iter == m_all_images.end()) {
+        return false;
+      }
+
+      const std::shared_ptr<ImageItem> tileImg = iter->second;
+
+      has_alpha |= tileImg->get_alpha_channel() != nullptr;
+    }
+
+    return has_alpha;
+  }
+  else {
+    // TODO: what about overlays ?
+    return false;
+  }
+}
+
+
+Error HeifContext::get_id_of_non_virtual_child_image(heif_item_id id, heif_item_id& out) const
+{
+  uint32_t image_type = m_heif_file->get_item_type_4cc(id);
+  if (image_type == fourcc("grid") ||
+      image_type == fourcc("iden") ||
+      image_type == fourcc("iovl")) {
+    auto iref_box = m_heif_file->get_iref_box();
+    if (!iref_box) {
+      return Error(heif_error_Invalid_input,
+                   heif_suberror_No_item_data,
+                   "Derived image does not reference any other image items");
+    }
+
+    std::vector<heif_item_id> image_references = iref_box->get_references(id, fourcc("dimg"));
+
+    // TODO: check whether this really can be recursive (e.g. overlay of grid images)
+
+    if (image_references.empty() || image_references[0] == id) {
+      return Error(heif_error_Invalid_input,
+                   heif_suberror_No_item_data,
+                   "Derived image does not reference any other image items");
+    }
+    else {
+      return get_id_of_non_virtual_child_image(image_references[0], out);
+    }
+  }
+  else {
+    if (!m_all_images.contains(id)) {
+      std::stringstream sstr;
+      sstr << "Image item " << id << " referenced, but it does not exist\n";
+
+      return Error(heif_error_Invalid_input,
+        heif_suberror_Nonexisting_item_referenced,
+        sstr.str());
+    }
+    else if (dynamic_cast<ImageItem_Error*>(m_all_images.find(id)->second.get())) {
+      // Should er return an error here or leave it to the follow-up code to detect that?
+    }
+
+    out = id;
+    return Error::Ok;
+  }
+}
+
+
+Result<std::shared_ptr<HeifPixelImage>> HeifContext::decode_image(heif_item_id ID,
+                                                                  heif_colorspace out_colorspace,
+                                                                  heif_chroma out_chroma,
+                                                                  const heif_decoding_options& options,
+                                                                  bool decode_only_tile, uint32_t tx, uint32_t ty,
+                                                                  std::set<heif_item_id> processed_ids) const
+{
+  std::shared_ptr<ImageItem> imgitem;
+  if (m_all_images.contains(ID)) {
+    imgitem = m_all_images.find(ID)->second;
+  }
+
+  // Note: this may happen, for example when an 'iden' image references a non-existing image item.
+  if (imgitem == nullptr) {
+    return Error(heif_error_Invalid_input, heif_suberror_Nonexisting_item_referenced);
+  }
+
+
+  auto decodingResult = imgitem->decode_image(options, decode_only_tile, tx, ty, processed_ids);
+  if (!decodingResult) {
+    return decodingResult.error();
+  }
+
+  std::shared_ptr<HeifPixelImage> img = *decodingResult;
+
+
+  // --- check that the decoded image has the claimed size (only check if transformations are applied)
+
+  if (!options.ignore_transformations && !decode_only_tile) {
+    uint32_t primary_component = img->get_primary_component();
+
+    if (imgitem->get_width() != img->get_width(primary_component) ||
+        imgitem->get_height() != img->get_height(primary_component)) {
+      return Error{
+        heif_error_Invalid_input,
+        heif_suberror_Invalid_image_size,
+        "Decoded image does not have the claimed size."
+      };
+    }
+  }
+
+  // --- convert to output chroma format
+
+  auto img_result = convert_to_output_colorspace(img, out_colorspace, out_chroma, options);
+  if (!img_result) {
+    return img_result.error();
+  }
+  else {
+    img = *img_result;
+  }
+
+  img->add_warnings(imgitem->get_decoding_warnings());
+
+  return img;
+}
+
+
+bool nclx_color_profile_equal(std::optional<nclx_profile> a,
+                              const heif_color_profile_nclx* b)
+{
+  if (!a && b==nullptr) {
+    return true;
+  }
+
+  heif_color_profile_nclx* default_nclx = nullptr;
+
+  if (!a || b==nullptr) {
+    default_nclx = heif_nclx_color_profile_alloc();
+
+    if (!a) {
+      a = nclx_profile::defaults();
+    }
+
+    if (b==nullptr) {
+      b = default_nclx;
+    }
+  }
+
+  bool equal = true;
+  if (a->m_matrix_coefficients != b->matrix_coefficients ||
+      a->m_colour_primaries != b->color_primaries ||
+      a->m_transfer_characteristics != b->transfer_characteristics ||
+      a->m_full_range_flag != b->full_range_flag) {
+    equal = false;
+  }
+
+  if (default_nclx) {
+    heif_nclx_color_profile_free(default_nclx);
+  }
+
+  return equal;
+}
+
+
+Result<std::shared_ptr<HeifPixelImage>> HeifContext::convert_to_output_colorspace(std::shared_ptr<HeifPixelImage> img,
+                                                                                  heif_colorspace out_colorspace,
+                                                                                  heif_chroma out_chroma,
+                                                                                  const heif_decoding_options& options) const
+{
+  heif_colorspace target_colorspace = (out_colorspace == heif_colorspace_undefined ?
+                                       img->get_colorspace() :
+                                       out_colorspace);
+
+  heif_chroma target_chroma = (out_chroma == heif_chroma_undefined ?
+                               img->get_chroma_format() : out_chroma);
+
+  bool different_chroma = (target_chroma != img->get_chroma_format());
+  bool different_colorspace = (target_colorspace != img->get_colorspace());
+
+  uint8_t img_bpp = img->get_visual_image_bits_per_pixel();
+  uint8_t converted_output_bpp = (options.convert_hdr_to_8bit && img_bpp > 8) ? 8 : 0 /* keep input depth */;
+
+  nclx_profile img_nclx = img->get_color_profile_nclx_with_fallback();
+  bool different_nclx = !nclx_color_profile_equal(img_nclx, options.output_image_nclx_profile);
+
+  if (different_chroma ||
+      different_colorspace ||
+      converted_output_bpp ||
+      different_nclx ||
+      (img->has_alpha() && options.color_conversion_options_ext && options.color_conversion_options_ext->alpha_composition_mode != heif_alpha_composition_mode_none)) {
+
+    nclx_profile output_profile;
+    if (options.output_image_nclx_profile) {
+      output_profile.set_matrix_coefficients(options.output_image_nclx_profile->matrix_coefficients);
+      output_profile.set_colour_primaries(options.output_image_nclx_profile->color_primaries);
+      output_profile.set_full_range_flag(options.output_image_nclx_profile->full_range_flag);
+    }
+    else {
+      output_profile.set_sRGB_defaults();
+    }
+
+    return convert_colorspace(img, target_colorspace, target_chroma, output_profile, converted_output_bpp,
+                                         options.color_conversion_options, options.color_conversion_options_ext,
+                                         get_security_limits());
+  }
+  else {
+    return img;
+  }
+}
+
+
+Result<std::shared_ptr<HeifPixelImage>>
+create_alpha_image_from_image_alpha_channel(const std::shared_ptr<HeifPixelImage>& image,
+                                            const heif_security_limits* limits)
+{
+  // --- generate alpha image
+
+  std::shared_ptr<HeifPixelImage> alpha_image = std::make_shared<HeifPixelImage>();
+  alpha_image->create(image->get_width(), image->get_height(),
+                      heif_colorspace_monochrome, heif_chroma_monochrome);
+
+  if (image->has_channel(heif_channel_Alpha)) {
+    alpha_image->copy_new_plane_from(image, heif_channel_Alpha, heif_channel_Y, limits);
+  }
+  else if (image->get_chroma_format() == heif_chroma_interleaved_RGBA) {
+    if (auto err = alpha_image->extract_alpha_from_RGBA(image, limits)) {
+      return err;
+    }
+  }
+  // TODO: 16 bit
+
+  // --- set nclx profile with full-range flag
+
+  nclx_profile nclx = nclx_profile::undefined();
+  nclx.set_full_range_flag(true); // this is the default, but just to be sure in case the defaults change
+  alpha_image->set_color_profile_nclx(nclx);
+
+  return alpha_image;
+}
+
+
+Result<std::shared_ptr<ImageItem>> HeifContext::encode_image(const std::shared_ptr<HeifPixelImage>& pixel_image,
+                                heif_encoder* encoder,
+                                const heif_encoding_options& in_options,
+                                heif_image_input_class input_class)
+{
+  std::shared_ptr<ImageItem> output_image_item = ImageItem::alloc_for_compression_format(this, encoder->plugin->compression_format);
+
+
+#if 0
+  // TODO: the hdlr box is not the right place for comments
+  // m_heif_file->set_hdlr_library_info(encoder->plugin->get_plugin_name());
+
+    case heif_compression_mask: {
+      error = encode_image_as_mask(pixel_image,
+                                  encoder,
+                                  options,
+                                  input_class,
+                                  out_image);
+    }
+      break;
+
+    default:
+      return Error(heif_error_Encoder_plugin_error, heif_suberror_Unsupported_codec);
+  }
+#endif
+
+
+  // --- check whether we have to convert the image color space
+
+  // The reason for doing the color conversion here is that the input might be an RGBA image and the color conversion
+  // will extract the alpha plane anyway. We can reuse that plane below instead of having to do a new conversion.
+
+  heif_encoding_options options = in_options;
+
+  std::shared_ptr<HeifPixelImage> colorConvertedImage;
+
+  if (output_image_item->get_encoder()) {
+    if (const auto* nclx = output_image_item->get_encoder()->get_forced_output_nclx()) {
+      options.output_nclx_profile = const_cast<heif_color_profile_nclx*>(nclx);
+    }
+
+    Result<std::shared_ptr<HeifPixelImage>> srcImageResult;
+    srcImageResult = output_image_item->get_encoder()->convert_colorspace_for_encoding(pixel_image,
+                                                                                       encoder,
+                                                                                       options.output_nclx_profile,
+                                                                                       &options.color_conversion_options,
+                                                                                       get_security_limits());
+    if (!srcImageResult) {
+      return srcImageResult.error();
+    }
+
+    colorConvertedImage = *srcImageResult;
+  }
+  else {
+    colorConvertedImage = pixel_image;
+  }
+
+  Error err = output_image_item->encode_to_item(this,
+                                                colorConvertedImage,
+                                                encoder, options, input_class);
+  if (err) {
+    return err;
+  }
+
+  insert_image_item(output_image_item->get_id(), output_image_item);
+
+
+  // --- if there is an alpha channel, add it as an additional image
+
+  if (options.save_alpha_channel &&
+      colorConvertedImage->has_alpha() &&
+      output_image_item->get_auxC_alpha_channel_type() != nullptr) { // does not need a separate alpha aux image
+
+    // --- generate alpha image
+    // TODO: can we directly code a monochrome image instead of the dummy color channels?
+
+    std::shared_ptr<HeifPixelImage> alpha_image;
+    auto alpha_image_result = create_alpha_image_from_image_alpha_channel(colorConvertedImage, get_security_limits());
+    if (!alpha_image_result) {
+      return alpha_image_result.error();
+    }
+
+    alpha_image = *alpha_image_result;
+
+
+    // --- encode the alpha image
+
+    auto alphaEncodingResult = encode_image(alpha_image, encoder, options,
+                         heif_image_input_class_alpha);
+    if (!alphaEncodingResult) {
+      return alphaEncodingResult.error();
+    }
+
+    std::shared_ptr<ImageItem> heif_alpha_image = *alphaEncodingResult;
+
+    m_heif_file->add_iref_reference(heif_alpha_image->get_id(), fourcc("auxl"), {output_image_item->get_id()});
+    m_heif_file->set_auxC_property(heif_alpha_image->get_id(), output_image_item->get_auxC_alpha_channel_type());
+
+    if (pixel_image->is_premultiplied_alpha()) {
+      m_heif_file->add_iref_reference(output_image_item->get_id(), fourcc("prem"), {heif_alpha_image->get_id()});
+    }
+  }
+
+  std::vector<std::shared_ptr<Box>> properties;
+  err = m_heif_file->get_properties(output_image_item->get_id(), properties);
+  if (err) {
+    return err;
+  }
+  output_image_item->set_properties(properties);
+
+  //m_heif_file->set_brand(encoder->plugin->compression_format,
+  //                       output_image_item->is_miaf_compatible());
+
+  return output_image_item;
+}
+
+
+void HeifContext::set_primary_image(const std::shared_ptr<ImageItem>& image)
+{
+  // update heif context
+
+  if (m_primary_image) {
+    m_primary_image->set_primary(false);
+  }
+
+  image->set_primary(true);
+  m_primary_image = image;
+
+
+  // update pitm box in HeifFile
+
+  m_heif_file->set_primary_item_id(image->get_id());
+}
+
+
+Error HeifContext::assign_thumbnail(const std::shared_ptr<ImageItem>& master_image,
+                                    const std::shared_ptr<ImageItem>& thumbnail_image)
+{
+  m_heif_file->add_iref_reference(thumbnail_image->get_id(),
+                                  fourcc("thmb"), {master_image->get_id()});
+
+  return Error::Ok;
+}
+
+
+Result<std::shared_ptr<ImageItem>> HeifContext::encode_thumbnail(const std::shared_ptr<HeifPixelImage>& image,
+                                                                 heif_encoder* encoder,
+                                                                 const heif_encoding_options& options,
+                                                                 int bbox_size)
+{
+  int orig_width = image->get_width();
+  int orig_height = image->get_height();
+
+  int thumb_width, thumb_height;
+
+  if (orig_width <= bbox_size && orig_height <= bbox_size) {
+    // original image is smaller than thumbnail size -> do not encode any thumbnail
+
+    return Error::Ok;
+  }
+  else if (orig_width > orig_height) {
+    thumb_height = orig_height * bbox_size / orig_width;
+    thumb_width = bbox_size;
+  }
+  else {
+    thumb_width = orig_width * bbox_size / orig_height;
+    thumb_height = bbox_size;
+  }
+
+
+  // round size to even width and height
+
+  thumb_width &= ~1;
+  thumb_height &= ~1;
+
+
+  std::shared_ptr<HeifPixelImage> thumbnail_image;
+  Error error = image->scale_nearest_neighbor(thumbnail_image, thumb_width, thumb_height, get_security_limits());
+  if (error) {
+    return error;
+  }
+
+  auto encodingResult = encode_image(thumbnail_image,
+                       encoder, options,
+                       heif_image_input_class_thumbnail);
+  if (!encodingResult) {
+    return encodingResult.error();
+  }
+
+  return *encodingResult;
+}
+
+
+Error HeifContext::add_exif_metadata(const std::shared_ptr<ImageItem>& master_image, const void* data, int size)
+{
+  // find location of TIFF header
+  uint32_t offset = 0;
+  const char* tiffmagic1 = "MM\0*";
+  const char* tiffmagic2 = "II*\0";
+  while (offset + 4 < (unsigned int) size) {
+    if (!memcmp((uint8_t*) data + offset, tiffmagic1, 4)) break;
+    if (!memcmp((uint8_t*) data + offset, tiffmagic2, 4)) break;
+    offset++;
+  }
+  if (offset >= (unsigned int) size) {
+    return Error(heif_error_Usage_error,
+                 heif_suberror_Invalid_parameter_value,
+                 "Could not find location of TIFF header in Exif metadata.");
+  }
+
+
+  std::vector<uint8_t> data_array;
+  data_array.resize(size + 4);
+  data_array[0] = (uint8_t) ((offset >> 24) & 0xFF);
+  data_array[1] = (uint8_t) ((offset >> 16) & 0xFF);
+  data_array[2] = (uint8_t) ((offset >> 8) & 0xFF);
+  data_array[3] = (uint8_t) ((offset) & 0xFF);
+  memcpy(data_array.data() + 4, data, size);
+
+
+  return add_generic_metadata(master_image,
+                              data_array.data(), (int) data_array.size(),
+                              fourcc("Exif"), nullptr, nullptr, heif_metadata_compression_off, nullptr);
+}
+
+
+Error HeifContext::add_XMP_metadata(const std::shared_ptr<ImageItem>& master_image, const void* data, int size,
+                                    heif_metadata_compression compression)
+{
+  return add_generic_metadata(master_image, data, size, fourcc("mime"), "application/rdf+xml", nullptr, compression, nullptr);
+}
+
+
+Error HeifContext::add_generic_metadata(const std::shared_ptr<ImageItem>& master_image, const void* data, int size,
+                                        uint32_t item_type, const char* content_type, const char* item_uri_type, heif_metadata_compression compression,
+                                        heif_item_id* out_item_id)
+{
+  // create an infe box describing what kind of data we are storing (this also creates a new ID)
+
+  auto infe_result = m_heif_file->add_new_infe_box(item_type);
+  if (!infe_result) {
+    return infe_result.error();
+  }
+  auto metadata_infe_box = *infe_result;
+  metadata_infe_box->set_hidden_item(true);
+  if (content_type != nullptr) {
+    metadata_infe_box->set_content_type(content_type);
+  }
+
+  heif_item_id metadata_id = metadata_infe_box->get_item_ID();
+  if (out_item_id) {
+    *out_item_id = metadata_id;
+  }
+
+
+  // we assign this data to the image
+
+  m_heif_file->add_iref_reference(metadata_id,
+                                  fourcc("cdsc"), {master_image->get_id()});
+
+
+  // --- metadata compression
+
+  if (compression == heif_metadata_compression_auto) {
+    compression = heif_metadata_compression_off; // currently, we don't use header compression by default
+  }
+
+  // only set metadata compression for MIME type data which has 'content_encoding' field
+  if (compression != heif_metadata_compression_off &&
+      item_type != fourcc("mime")) {
+    // TODO: error, compression not supported
+  }
+
+
+  std::vector<uint8_t> data_array;
+  if (compression == heif_metadata_compression_zlib) {
+#if HAVE_ZLIB
+    data_array = compress_zlib((const uint8_t*) data, size);
+    metadata_infe_box->set_content_encoding("compress_zlib");
+#else
+    return Error(heif_error_Unsupported_feature,
+                 heif_suberror_Unsupported_header_compression_method);
+#endif
+  }
+  else if (compression == heif_metadata_compression_deflate) {
+#if HAVE_ZLIB
+    data_array = compress_zlib((const uint8_t*) data, size);
+    metadata_infe_box->set_content_encoding("deflate");
+#else
+    return Error(heif_error_Unsupported_feature,
+                 heif_suberror_Unsupported_header_compression_method);
+#endif
+  }
+  else {
+    // uncompressed data, plain copy
+
+    data_array.resize(size);
+    memcpy(data_array.data(), data, size);
+  }
+
+  // copy the data into the file, store the pointer to it in an iloc box entry
+
+  m_heif_file->append_iloc_data(metadata_id, data_array, 0);
+
+  return Error::Ok;
+}
+
+
+heif_property_id HeifContext::add_property(heif_item_id targetItem, std::shared_ptr<Box> property, bool essential)
+{
+  heif_property_id id;
+
+  if (auto img = get_image(targetItem, false)) {
+    id = img->add_property(property, essential);
+  }
+  else {
+    id = m_heif_file->add_property(targetItem, property, essential);
+  }
+
+  return id;
+}
+
+
+Result<heif_item_id> HeifContext::add_pyramid_group(const std::vector<heif_item_id>& layer_item_ids)
+{
+  struct pymd_entry
+  {
+    std::shared_ptr<ImageItem> item;
+    uint32_t width = 0;
+  };
+
+  // --- sort all images by size
+
+  std::vector<pymd_entry> pymd_entries;
+  for (auto id : layer_item_ids) {
+    auto image_item = get_image(id, true);
+    if (auto error = image_item->get_item_error()) {
+      return error;
+    }
+
+    pymd_entry entry;
+    entry.item = image_item;
+    entry.width = image_item->get_width();
+    pymd_entries.emplace_back(entry);
+  }
+
+  std::sort(pymd_entries.begin(), pymd_entries.end(), [](const pymd_entry& a, const pymd_entry& b) {
+    return a.width < b.width;
+  });
+
+
+  // --- generate pymd box
+
+  auto pymd = std::make_shared<Box_pymd>();
+  std::vector<Box_pymd::LayerInfo> layers;
+  std::vector<heif_item_id> ids;
+
+  auto base_item = pymd_entries.back().item;
+
+  uint32_t tile_w=0, tile_h=0;
+  base_item->get_tile_size(tile_w, tile_h);
+
+  uint32_t last_width=0, last_height=0;
+
+  for (const auto& entry : pymd_entries) {
+    auto layer_item = entry.item;
+
+    if (false) {
+      // according to pymd definition, we should check that all layers have the same tile size
+      uint32_t item_tile_w = 0, item_tile_h = 0;
+      base_item->get_tile_size(item_tile_w, item_tile_h);
+      if (item_tile_w != tile_w || item_tile_h != tile_h) {
+        // TODO: add warning that tile sizes are not the same
+      }
+    }
+
+    heif_image_tiling tiling = layer_item->get_heif_image_tiling();
+
+    if (tiling.image_width < last_width || tiling.image_height < last_height) {
+      return Error{
+        heif_error_Invalid_input,
+        heif_suberror_Invalid_parameter_value,
+        "Multi-resolution pyramid images have to be provided ordered from smallest to largest."
+      };
+    }
+
+    last_width = tiling.image_width;
+    last_height = tiling.image_height;
+
+    Box_pymd::LayerInfo layer{};
+    layer.layer_binning = (uint16_t)(base_item->get_width() / tiling.image_width);
+    layer.tiles_in_layer_row_minus1 = static_cast<uint16_t>(tiling.num_rows - 1);
+    layer.tiles_in_layer_column_minus1 = static_cast<uint16_t>(tiling.num_columns - 1);
+    layers.push_back(layer);
+    ids.push_back(layer_item->get_id());
+  }
+
+  auto groupIdResult = m_heif_file->get_id_creator().get_new_id(IDCreator::Namespace::entity_group);
+  if (!groupIdResult) {
+    return groupIdResult.error();
+  }
+  heif_item_id group_id = *groupIdResult;
+
+  pymd->set_group_id(group_id);
+  pymd->set_layers((uint16_t)tile_w, (uint16_t)tile_h, layers, ids);
+
+  m_heif_file->add_entity_group_box(pymd);
+
+  // add back-references to base image
+
+  for (size_t i = 0; i < ids.size() - 1; i++) {
+    m_heif_file->add_iref_reference(ids[i], fourcc("base"), {ids.back()});
+  }
+
+  return {group_id};
+}
+
+
+Result<heif_property_id> HeifContext::add_text_property(heif_item_id itemId, const std::string& language)
+{
+  if (find_property<Box_elng>(itemId)) {
+    return Error{
+      heif_error_Usage_error,
+      heif_suberror_Unspecified,
+      "Item already has an 'elng' language property."
+    };
+  }
+
+  auto elng = std::make_shared<Box_elng>();
+  elng->set_lang(std::string(language));
+
+  heif_property_id id = add_property(itemId, elng, false);
+  return id;
+}
+
+
+Error HeifContext::interpret_heif_file_sequences()
+{
+  m_tracks.clear();
+
+
+  // --- reference all non-hidden images
+
+  auto moov = m_heif_file->get_moov_box();
+  assert(moov);
+
+  auto mvhd = moov->get_child_box<Box_mvhd>();
+  if (!mvhd) {
+    assert(false); // TODO
+  }
+
+  auto tracks = moov->get_child_boxes<Box_trak>();
+  for (const auto& track_box : tracks) {
+    auto trackResult = Track::alloc_track(this, track_box);
+    bool skip_track = false;
+
+    if (auto err = trackResult.error()) {
+      if (err.error_code == heif_error_Unsupported_feature &&
+          err.sub_error_code == heif_suberror_Unsupported_track_type) {
+        // ignore error, skip track
+        skip_track = true;
+      }
+      else {
+        return trackResult.error();
+      }
+    }
+
+    if (!skip_track) {
+      assert(*trackResult);
+      auto track = *trackResult;
+      m_tracks.insert({track->get_id(), track});
+
+      if (track->is_visual_track() && m_visual_track_id == 0) {
+        m_visual_track_id = track->get_id();
+      }
+    }
+  }
+
+  // --- post-parsing initialization
+
+  std::vector<std::shared_ptr<Track>> all_tracks;
+  for (auto& track : m_tracks) {
+   all_tracks.push_back(track.second);
+  }
+
+  for (auto& track : m_tracks) {
+    Error err = track.second->initialize_after_parsing(this, all_tracks);
+    if (err) {
+      return err;
+    }
+  }
+
+  return Error::Ok;
+}
+
+
+std::vector<uint32_t> HeifContext::get_track_IDs() const
+{
+  std::vector<uint32_t> ids;
+
+  for (const auto& track : m_tracks) {
+    ids.push_back(track.first);
+  }
+
+  return ids;
+}
+
+
+Result<std::shared_ptr<Track>> HeifContext::get_track(uint32_t track_id)
+{
+  assert(has_sequence());
+
+  if (track_id != 0) {
+    auto iter = m_tracks.find(track_id);
+    if (iter == m_tracks.end()) {
+      return Error{heif_error_Usage_error,
+                   heif_suberror_Unspecified,
+                   "Invalid track id"};
+    }
+
+    return iter->second;
+  }
+
+  if (m_visual_track_id != 0) {
+    return m_tracks[m_visual_track_id];
+  }
+
+  return m_tracks.begin()->second;
+}
+
+
+Result<std::shared_ptr<const Track>> HeifContext::get_track(uint32_t track_id) const
+{
+  auto result = const_cast<HeifContext*>(this)->get_track(track_id);
+  if (!result) {
+    return result.error();
+  }
+  else {
+    Result<std::shared_ptr<const Track>> my_result(*result);
+    return my_result;
+  }
+}
+
+
+uint32_t HeifContext::get_sequence_timescale() const
+{
+  auto mvhd = m_heif_file->get_mvhd_box();
+  if (!mvhd) {
+    return 0;
+  }
+
+  return mvhd->get_time_scale();
+}
+
+
+void HeifContext::set_sequence_timescale(uint32_t timescale)
+{
+  get_heif_file()->init_for_sequence();
+
+  auto mvhd = m_heif_file->get_mvhd_box();
+
+  /* unnecessary, since mvhd duration is set during writing
+
+  uint32_t old_timescale = mvhd->get_time_scale();
+  if (old_timescale != 0) {
+    uint64_t scaled_duration = mvhd->get_duration() * timescale / old_timescale;
+    mvhd->set_duration(scaled_duration);
+  }
+  */
+
+  mvhd->set_time_scale(timescale);
+}
+
+
+void HeifContext::set_number_of_sequence_repetitions(uint32_t repetitions)
+{
+  m_sequence_repetitions = repetitions;
+}
+
+
+uint64_t HeifContext::get_sequence_duration() const
+{
+  auto mvhd = m_heif_file->get_mvhd_box();
+  if (!mvhd) {
+    return 0;
+  }
+
+  return mvhd->get_duration();
+}
+
+
+Result<std::shared_ptr<Track_Visual>> HeifContext::add_visual_sequence_track(const TrackOptions* options,
+                                                                             uint32_t handler_type,
+                                                                             uint16_t width, uint16_t height)
+{
+  m_heif_file->init_for_sequence();
+
+  std::shared_ptr<Track_Visual> trak = std::make_shared<Track_Visual>(this, 0, width, height, options, handler_type);
+  m_tracks.insert({trak->get_id(), trak});
+
+  return trak;
+}
+
+
+Result<std::shared_ptr<class Track_Metadata>> HeifContext::add_uri_metadata_sequence_track(const TrackOptions* options,
+                                                                                           std::string uri)
+{
+  m_heif_file->init_for_sequence();
+
+  std::shared_ptr<Track_Metadata> trak = std::make_shared<Track_Metadata>(this, 0, uri, options);
+  m_tracks.insert({trak->get_id(), trak});
+
+  return trak;
+}
+
+Result<std::shared_ptr<TextItem>> HeifContext::add_text_item(const char* content_type, const char* text)
+{
+  auto boxResult = m_heif_file->add_new_infe_box(fourcc("mime"));
+  if (!boxResult) {
+    return boxResult.error();
+  }
+  auto box = *boxResult;
+  box->set_hidden_item(true);
+  box->set_content_type(std::string(content_type));
+  auto textItem = std::make_shared<TextItem>(box->get_item_ID(), text);
+  add_text_item(textItem);
+  return textItem;
+}
diff --git a/libheif/context.h b/libheif/context.h
new file mode 100644
index 0000000000..0cc5803462
--- /dev/null
+++ b/libheif/context.h
@@ -0,0 +1,326 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_CONTEXT_H
+#define LIBHEIF_CONTEXT_H
+
+#include <map>
+#include <memory>
+#include <set>
+#include <string>
+#include <vector>
+#include <utility>
+
+#include "error.h"
+
+#include "libheif/heif.h"
+#include "libheif/heif_experimental.h"
+#include "libheif/heif_plugin.h"
+#include "bitstream.h"
+
+#include "box.h" // only for color_profile, TODO: maybe move the color_profiles to its own header
+#include "file.h"
+#include "region.h"
+
+#include "text.h"
+
+class HeifFile;
+
+class HeifPixelImage;
+
+class StreamWriter;
+
+class ImageItem;
+
+class Track;
+
+struct TrackOptions;
+
+
+Result<std::shared_ptr<HeifPixelImage>>
+create_alpha_image_from_image_alpha_channel(const std::shared_ptr<HeifPixelImage>& image,
+                                            const heif_security_limits* limits);
+
+
+// This is a higher-level view than HeifFile.
+// Images are grouped logically into main images and their thumbnails.
+// The class also handles automatic color-space conversion.
+class HeifContext : public ErrorBuffer
+{
+public:
+  HeifContext();
+
+  ~HeifContext();
+
+  void set_max_decoding_threads(int max_threads) { m_max_decoding_threads = max_threads; }
+
+  int get_max_decoding_threads() const { return m_max_decoding_threads; }
+
+  void set_security_limits(const heif_security_limits* limits);
+
+  [[nodiscard]] heif_security_limits* get_security_limits() { return &m_limits; }
+
+  [[nodiscard]] const heif_security_limits* get_security_limits() const { return &m_limits; }
+
+  Error read(const std::shared_ptr<StreamReader>& reader);
+
+  Error read_from_file(const char* input_filename);
+
+  Error read_from_memory(const void* data, size_t size, bool copy);
+
+  std::shared_ptr<HeifFile> get_heif_file() const { return m_heif_file; }
+
+
+  void set_unif(bool flag);
+
+  bool get_unif() const;
+
+  IDCreator& get_id_creator();
+
+  // === image items ===
+
+  std::vector<std::shared_ptr<ImageItem>> get_top_level_images(bool return_error_images);
+
+  void insert_image_item(heif_item_id id, const std::shared_ptr<ImageItem>& img) {
+    m_all_images.insert(std::make_pair(id, img));
+  }
+
+  std::shared_ptr<ImageItem> get_image(heif_item_id id, bool return_error_images);
+
+  std::shared_ptr<const ImageItem> get_image(heif_item_id id, bool return_error_images) const
+  {
+    return const_cast<HeifContext*>(this)->get_image(id, return_error_images);
+  }
+
+  std::shared_ptr<ImageItem> get_primary_image(bool return_error_image);
+
+  std::shared_ptr<const ImageItem> get_primary_image(bool return_error_image) const;
+
+  bool is_image(heif_item_id ID) const;
+
+  bool has_alpha(heif_item_id ID) const;
+
+  Result<std::shared_ptr<HeifPixelImage>> decode_image(heif_item_id ID,
+                                                       heif_colorspace out_colorspace,
+                                                       heif_chroma out_chroma,
+                                                       const heif_decoding_options& options,
+                                                       bool decode_only_tile, uint32_t tx, uint32_t ty,
+                                                       std::set<heif_item_id> processed_ids) const;
+
+  Result<std::shared_ptr<HeifPixelImage>> convert_to_output_colorspace(std::shared_ptr<HeifPixelImage> img,
+                                                                       heif_colorspace out_colorspace,
+                                                                       heif_chroma out_chroma,
+                                                                       const heif_decoding_options& options) const;
+
+  Error get_id_of_non_virtual_child_image(heif_item_id in, heif_item_id& out) const;
+
+  std::string debug_dump_boxes() const;
+
+
+  // === writing ===
+
+  [[nodiscard]] Error write(StreamWriter& writer);
+
+  // Create all boxes necessary for an empty HEIF file.
+  // Note that this is no valid HEIF file, since some boxes (e.g. pitm) are generated, but
+  // contain no valid data yet.
+  void reset_to_empty_heif();
+
+  Result<std::shared_ptr<ImageItem>> encode_image(const std::shared_ptr<HeifPixelImage>& image,
+                                                  heif_encoder* encoder,
+                                                  const heif_encoding_options& options,
+                                                  heif_image_input_class input_class);
+
+  void set_primary_image(const std::shared_ptr<ImageItem>& image);
+
+  bool is_primary_image_set() const { return m_primary_image != nullptr; }
+
+  Error assign_thumbnail(const std::shared_ptr<ImageItem>& master_image,
+                         const std::shared_ptr<ImageItem>& thumbnail_image);
+
+  Result<std::shared_ptr<ImageItem>> encode_thumbnail(const std::shared_ptr<HeifPixelImage>& image,
+                                                      heif_encoder* encoder,
+                                                      const heif_encoding_options& options,
+                                                      int bbox_size);
+
+  Error add_exif_metadata(const std::shared_ptr<ImageItem>& master_image, const void* data, int size);
+
+  Error add_XMP_metadata(const std::shared_ptr<ImageItem>& master_image, const void* data, int size, heif_metadata_compression compression);
+
+  Error add_generic_metadata(const std::shared_ptr<ImageItem>& master_image, const void* data, int size,
+                             uint32_t item_type, const char* content_type, const char* item_uri_type,
+                             heif_metadata_compression compression, heif_item_id* out_item_id);
+
+  heif_property_id add_property(heif_item_id targetItem, std::shared_ptr<Box> property, bool essential);
+
+  Result<heif_item_id> add_pyramid_group(const std::vector<heif_item_id>& layers);
+
+  Result<heif_property_id> add_text_property(heif_item_id, const std::string& language);
+
+
+  // --- region items
+
+  void add_region_item(std::shared_ptr<RegionItem> region_item)
+  {
+    m_region_items.push_back(std::move(region_item));
+  }
+
+  Result<std::shared_ptr<RegionItem>> add_region_item(uint32_t reference_width, uint32_t reference_height);
+
+  std::shared_ptr<RegionItem> get_region_item(heif_item_id id) const
+  {
+    for (auto& item : m_region_items) {
+      if (item->item_id == id)
+        return item;
+    }
+
+    return nullptr;
+  }
+
+  void add_region_referenced_mask_ref(heif_item_id region_item_id, heif_item_id mask_item_id);
+
+
+  // === sequences ==
+
+  bool has_sequence() const { return !m_tracks.empty(); }
+
+  int get_number_of_tracks() const { return static_cast<int>(m_tracks.size()); }
+
+  std::vector<uint32_t> get_track_IDs() const;
+
+  // If 0 is passed as track_id, the main visual track is returned (we assume that there is only one visual track).
+  Result<std::shared_ptr<Track>> get_track(uint32_t track_id);
+
+  Result<std::shared_ptr<const Track>> get_track(uint32_t track_id) const;
+
+  uint32_t get_sequence_timescale() const;
+
+  uint64_t get_sequence_duration() const;
+
+  void set_sequence_timescale(uint32_t timescale);
+
+  void set_number_of_sequence_repetitions(uint32_t repetitions);
+
+  Result<std::shared_ptr<class Track_Visual>> add_visual_sequence_track(const TrackOptions*, uint32_t handler_type,
+                                                                        uint16_t width, uint16_t height);
+
+  Result<std::shared_ptr<class Track_Metadata>> add_uri_metadata_sequence_track(const TrackOptions*, std::string uri);
+
+  void add_text_item(std::shared_ptr<TextItem> text_item)
+  {
+    m_text_items.push_back(std::move(text_item));
+  }
+
+  Result<std::shared_ptr<TextItem>> add_text_item(const char* content_type, const char* text);
+
+  std::shared_ptr<TextItem> get_text_item(heif_item_id id) const
+  {
+    for (auto& item : m_text_items) {
+      if (item->get_item_id() == id)
+        return item;
+    }
+
+    return nullptr;
+  }
+
+  template<typename T>
+  Result<std::shared_ptr<T>> find_property(heif_item_id itemId, heif_property_id propertyId)
+  {
+    auto file = this->get_heif_file();
+
+    // For propertyId == 0, return the first property with this type.
+    if (propertyId == 0) {
+      return find_property<T>(itemId);
+    }
+
+    std::vector<std::shared_ptr<Box>> properties;
+    Error err = file->get_properties(itemId, properties);
+    if (err) {
+      return err;
+    }
+
+    if (propertyId - 1 >= properties.size()) {
+      Error(heif_error_Usage_error, heif_suberror_Invalid_property, "property index out of range");
+    }
+
+    auto box = properties[propertyId - 1];
+    auto box_casted = std::dynamic_pointer_cast<T>(box);
+    if (!box_casted) {
+      return Error(heif_error_Usage_error, heif_suberror_Invalid_property, "wrong property type");
+    }
+
+    return box_casted;
+  }
+
+  template<typename T>
+  Result<std::shared_ptr<T>> find_property(heif_item_id itemId) {
+    auto file = this->get_heif_file();
+    auto result = file->get_property_for_item<T>(itemId);
+    if (!result) {
+      return Error(heif_error_Invalid_input,
+                   heif_suberror_No_properties_assigned_to_item,
+                   "property not found on item");
+    }
+    return result;
+  }
+
+  template<typename T>
+  bool has_property(heif_item_id itemId) const
+  {
+    auto file = this->get_heif_file();
+    auto result = file->get_property_for_item<T>(itemId);
+    return result != nullptr;
+  }
+
+private:
+  std::map<heif_item_id, std::shared_ptr<ImageItem>> m_all_images;
+
+  // We store this in a vector because we need stable indices for the C API.
+  // TODO: stable indices are obsolet now...
+  std::vector<std::shared_ptr<ImageItem>> m_top_level_images;
+
+  std::shared_ptr<ImageItem> m_primary_image; // shortcut to primary image
+
+  std::shared_ptr<HeifFile> m_heif_file;
+
+  int m_max_decoding_threads = 4;
+
+  heif_security_limits m_limits;
+  TotalMemoryTracker m_memory_tracker;
+
+  std::vector<std::shared_ptr<RegionItem>> m_region_items;
+  std::vector<std::shared_ptr<TextItem>> m_text_items;
+
+  // --- sequences
+
+  std::map<uint32_t, std::shared_ptr<Track>> m_tracks;
+  uint32_t m_visual_track_id = 0;
+  uint32_t m_sequence_repetitions = 1;
+
+  Error interpret_heif_file();
+
+  Error interpret_heif_file_images();
+
+  Error interpret_heif_file_sequences();
+
+  void remove_top_level_image(const std::shared_ptr<ImageItem>& image);
+};
+
+#endif
diff --git a/libheif/error.cc b/libheif/error.cc
index 75796b99c1..32da1e5e37 100644
--- a/libheif/error.cc
+++ b/libheif/error.cc
@@ -1,6 +1,6 @@
 /*
  * HEIF codec.
- * Copyright (c) 2017 struktur AG, Dirk Farin <farin@struktur.de>
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
  *
  * This file is part of libheif.
  *
@@ -21,22 +21,34 @@
 #include "error.h"
 
 #include <cassert>
+#include <cstring>
+
+
+const heif_error heif_error_null_pointer_argument {
+  heif_error_Usage_error,
+  heif_suberror_Null_pointer_argument,
+  "NULL argument passed"
+};
+
 
 // static
-const char heif::Error::kSuccess[] = "Success";
+const char Error::kSuccess[] = "Success";
 const char* cUnknownError = "Unknown error";
 
 
-heif::Error::Error()
-    : error_code(heif_error_Ok),
-      sub_error_code(heif_suberror_Unspecified)
-{
-}
+const Error Error::Ok(heif_error_Ok);
+
+const Error Error::InternalError{heif_error_Unsupported_feature, // TODO: use better value
+                                 heif_suberror_Unspecified,
+                                 "Internal error"};
+
+
+Error::Error() = default;
 
 
-heif::Error::Error(heif_error_code c,
+Error::Error(heif_error_code c,
                    heif_suberror_code sc,
-                   std::string msg)
+                   const std::string& msg)
     : error_code(c),
       sub_error_code(sc),
       message(msg)
@@ -44,7 +56,45 @@ heif::Error::Error(heif_error_code c,
 }
 
 
-const char* heif::Error::get_error_string(heif_error_code err)
+// Replacement for C++20 std::string::starts_with()
+static bool starts_with(const std::string& str, const std::string& prefix) {
+    if (str.length() < prefix.length()) {
+        return false;
+    }
+
+  return str.compare(0, prefix.size(), prefix) == 0;
+}
+
+
+Error Error::from_heif_error(const heif_error& c_error)
+{
+  // unpack the concatenated error message and extract the last part only
+
+  const char* err_string = get_error_string(c_error.code);
+  const char* sub_err_string = get_error_string(c_error.subcode);
+
+  std::string msg = c_error.message;
+  if (starts_with(msg, err_string)) {
+    msg = msg.substr(strlen(err_string));
+
+    if (starts_with(msg, ": ")) {
+      msg = msg.substr(2);
+    }
+
+    if (starts_with(msg, sub_err_string)) {
+      msg = msg.substr(strlen(sub_err_string));
+
+      if (starts_with(msg, ": ")) {
+        msg = msg.substr(2);
+      }
+    }
+  }
+
+  return {c_error.code, c_error.subcode, msg};
+}
+
+
+const char* Error::get_error_string(heif_error_code err)
 {
   switch (err) {
     case heif_error_Ok:
@@ -69,13 +119,19 @@ const char* heif::Error::get_error_string(heif_error_code err)
       return "Error during encoding or writing output file";
     case heif_error_Color_profile_does_not_exist:
       return "Color profile does not exist";
+    case heif_error_Plugin_loading_error:
+      return "Error while loading plugin";
+    case heif_error_Canceled:
+      return "Canceled by user";
+    case heif_error_End_of_sequence:
+      return "End of sequence";
   }
 
   assert(false);
   return "Unknown error";
 }
 
-const char* heif::Error::get_error_string(heif_suberror_code err)
+const char* Error::get_error_string(heif_suberror_code err)
 {
   switch (err) {
     case heif_suberror_Unspecified:
@@ -101,8 +157,12 @@ const char* heif::Error::get_error_string(heif_suberror_code err)
       return "No 'hdlr' box";
     case heif_suberror_No_hvcC_box:
       return "No 'hvcC' box";
+    case heif_suberror_No_vvcC_box:
+      return "No 'vvcC' box";
     case heif_suberror_No_av1C_box:
       return "No 'av1C' box";
+    case heif_suberror_No_avcC_box:
+      return "No 'avcC' box";
     case heif_suberror_No_pitm_box:
       return "No 'pitm' box";
     case heif_suberror_No_ipco_box:
@@ -149,12 +209,38 @@ const char* heif::Error::get_error_string(heif_suberror_code err)
       return "Invalid pixi box";
     case heif_suberror_Wrong_tile_image_pixel_depth:
       return "Wrong tile image pixel depth";
+    case heif_suberror_Unknown_NCLX_color_primaries:
+      return "Unknown NCLX color primaries";
+    case heif_suberror_Unknown_NCLX_transfer_characteristics:
+      return "Unknown NCLX transfer characteristics";
+    case heif_suberror_Unknown_NCLX_matrix_coefficients:
+      return "Unknown NCLX matrix coefficients";
+    case heif_suberror_Invalid_region_data:
+      return "Invalid region item data";
+    case heif_suberror_No_ispe_property:
+      return "Image has no 'ispe' property";
+    case heif_suberror_Camera_intrinsic_matrix_undefined:
+      return "Camera intrinsic matrix undefined";
+    case heif_suberror_Camera_extrinsic_matrix_undefined:
+      return "Camera extrinsic matrix undefined";
+    case heif_suberror_Invalid_J2K_codestream:
+      return "Invalid JPEG 2000 codestream";
+    case heif_suberror_Decompression_invalid_data:
+      return "Invalid data in generic compression inflation";
+    case heif_suberror_No_moov_box:
+      return "No 'moov' box";
+    case heif_suberror_No_icbr_box:
+      return "No 'icbr' box";
+    case heif_suberror_Invalid_mini_box:
+      return "Unsupported or invalid 'mini' box";
 
 
       // --- Memory_allocation_error ---
 
     case heif_suberror_Security_limit_exceeded:
       return "Security limit exceeded";
+    case heif_suberror_Compression_initialisation_error:
+      return "Compression initialisation method error";
 
       // --- Usage_error ---
 
@@ -172,6 +258,10 @@ const char* heif::Error::get_error_string(heif_suberror_code err)
       return "Unsupported parameter";
     case heif_suberror_Invalid_parameter_value:
       return "Invalid parameter value";
+    case heif_suberror_Invalid_property:
+      return "Invalid property";
+    case heif_suberror_Item_reference_cycle:
+      return "Image reference cycle";
 
       // --- Unsupported_feature ---
 
@@ -185,6 +275,14 @@ const char* heif::Error::get_error_string(heif_suberror_code err)
       return "Unsupported color conversion";
     case heif_suberror_Unsupported_item_construction_method:
       return "Unsupported item construction method";
+    case heif_suberror_Unsupported_header_compression_method:
+      return "Unsupported header compression method";
+    case heif_suberror_Unsupported_generic_compression_method:
+      return "Unsupported generic compression method";
+    case heif_suberror_Unsupported_essential_property:
+      return "Unsupported essential item property";
+    case heif_suberror_Unsupported_track_type:
+      return "Unsupported track type";
 
       // --- Encoder_plugin_error --
 
@@ -195,6 +293,29 @@ const char* heif::Error::get_error_string(heif_suberror_code err)
 
     case heif_suberror_Cannot_write_output_data:
       return "Cannot write output data";
+    case heif_suberror_Encoder_initialization:
+      return "Initialization problem";
+    case heif_suberror_Encoder_encoding:
+      return "Encoding problem";
+    case heif_suberror_Encoder_cleanup:
+      return "Cleanup problem";
+    case heif_suberror_Too_many_regions:
+      return "Too many regions (>255) in an 'rgan' item.";
+
+      // --- Plugin_loading_error ---
+
+    case heif_suberror_Plugin_loading_error:
+      return "Plugin file cannot be loaded";
+    case heif_suberror_Plugin_is_not_loaded:
+      return "Trying to remove a plugin that is not loaded";
+    case heif_suberror_Cannot_read_plugin_directory:
+      return "Error while scanning the directory for plugins";
+    case heif_suberror_No_matching_decoder_installed:
+#if ENABLE_PLUGIN_LOADING
+      return "No decoding plugin installed for this compression format";
+#else
+      return "Support for this compression format has not been built in";
+#endif
   }
 
   assert(false);
@@ -202,7 +323,7 @@ const char* heif::Error::get_error_string(heif_suberror_code err)
 }
 
 
-heif_error heif::Error::error_struct(ErrorBuffer* error_buffer) const
+heif_error Error::error_struct(ErrorBuffer* error_buffer) const
 {
   if (error_buffer) {
     if (error_code == heif_error_Ok) {
diff --git a/libheif/error.h b/libheif/error.h
index bc28be404a..0d6292d8cc 100644
--- a/libheif/error.h
+++ b/libheif/error.h
@@ -1,6 +1,6 @@
 /*
  * HEIF codec.
- * Copyright (c) 2017 struktur AG, Dirk Farin <farin@struktur.de>
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
  *
  * This file is part of libheif.
  *
@@ -21,10 +21,6 @@
 #ifndef LIBHEIF_ERROR_H
 #define LIBHEIF_ERROR_H
 
-#if defined(HAVE_CONFIG_H)
-#include "config.h"
-#endif
-
 #include <cinttypes>
 #include <cstddef>
 
@@ -36,83 +32,146 @@
 #include <ostream>
 #include <sstream>
 
+#include "libheif/heif.h"
+#include <cassert>
+#include <variant>
+#include <utility>
+
 
-#include "heif.h"
+extern const heif_error heif_error_null_pointer_argument;
 
 
-static constexpr char kSuccess[] = "Success";
+class ErrorBuffer
+{
+public:
+  ErrorBuffer() = default;
 
+  void set_success()
+  {
+    m_error_message = c_success;
+  }
 
-namespace heif {
+  void set_error(const std::string& err)
+  {
+    m_buffer = err;
+    m_error_message = m_buffer.c_str();
+  }
 
-  class ErrorBuffer
+  const char* get_error() const
   {
-  public:
-    ErrorBuffer()
-    {}
+    return m_error_message;
+  }
 
-    void set_success()
-    {
-      m_error_message = c_success;
-    }
+private:
+  constexpr static const char* c_success = "Success";
+  std::string m_buffer;
+  const char* m_error_message = c_success;
+};
 
-    void set_error(std::string err)
-    {
-      m_buffer = err;
-      m_error_message = m_buffer.c_str();
-    }
 
-    const char* get_error() const
-    {
-      return m_error_message;
+class Error
+{
+public:
+  heif_error_code error_code = heif_error_Ok;
+  heif_suberror_code sub_error_code = heif_suberror_Unspecified;
+  std::string message;
+
+  Error();
+
+  Error(heif_error_code c,
+        heif_suberror_code sc = heif_suberror_Unspecified,
+        const std::string& msg = "");
+
+  static Error from_heif_error(const heif_error&);
+
+  static const Error Ok;
+
+  static const Error InternalError;
+
+  static const char kSuccess[];
+
+  bool operator==(const Error& other) const { return error_code == other.error_code; }
+
+  bool operator!=(const Error& other) const { return !(*this == other); }
+
+  Error operator||(const Error& other) const {
+    if (error_code != heif_error_Ok) {
+      return *this;
     }
+    else {
+      return other;
+    }
+  }
 
-  private:
-    constexpr static const char* c_success = "Success";
-    std::string m_buffer;
-    const char* m_error_message = c_success;
-  };
+  operator bool() const { return error_code != heif_error_Ok; }
 
+  static const char* get_error_string(heif_error_code err);
 
-  class Error
-  {
-  public:
-    enum heif_error_code error_code;
-    enum heif_suberror_code sub_error_code;
-    std::string message;
+  static const char* get_error_string(heif_suberror_code err);
 
-    Error();
+  heif_error error_struct(ErrorBuffer* error_buffer) const;
+};
 
-    Error(heif_error_code c,
-          heif_suberror_code sc = heif_suberror_Unspecified,
-          std::string msg = "");
 
-    static Error Ok;
+inline std::ostream& operator<<(std::ostream& ostr, const Error& err)
+{
+  ostr << err.error_code << "/" << err.sub_error_code;
+  return ostr;
+}
+
 
-    static const char kSuccess[];
+template <typename T> class Result
+{
+public:
+  Result() = default;
 
-    bool operator==(const Error& other) const
-    { return error_code == other.error_code; }
+  Result(T v) : m_data(std::move(v)) {}
 
-    bool operator!=(const Error& other) const
-    { return !(*this == other); }
+  Result(const Error& e) : m_data(e) {}
 
-    operator bool() const
-    { return error_code != heif_error_Ok; }
+  operator bool() const { return std::holds_alternative<T>(m_data); }
 
-    static const char* get_error_string(heif_error_code err);
+  //void set(const T& v) { m_data = v; }
 
-    static const char* get_error_string(heif_suberror_code err);
+  // Pointer-like access for `r->member`
+  T* operator->()
+  {
+    assert(*this); // Uses the operator bool() above
+    return &std::get<T>(m_data);
+  }
 
-    heif_error error_struct(ErrorBuffer* error_buffer) const;
-  };
+  // Dereference access for `*r`
+  T& operator*()
+  {
+    assert(*this);
+    return std::get<T>(m_data);
+  }
 
+  [[nodiscard]] bool is_error() const {
+    return std::holds_alternative<Error>(m_data);
+  }
 
-  inline std::ostream& operator<<(std::ostream& ostr, const Error& err)
+  // Accessor for the error, if it exists
+  [[nodiscard]] const Error& error() const
   {
-    ostr << err.error_code << "/" << err.sub_error_code;
-    return ostr;
+    if (*this) {
+      return Error::Ok;
+    }
+
+    return std::get<Error>(m_data);
   }
-}
+
+  // Directly get the C error struct.
+  heif_error error_struct(ErrorBuffer* error_buffer) const
+  {
+    if (*this) {
+      return heif_error_success;
+    }
+
+    return std::get<Error>(m_data).error_struct(error_buffer);
+  }
+
+  std::variant<T, Error> m_data;
+};
 
 #endif
diff --git a/libheif/file.cc b/libheif/file.cc
new file mode 100644
index 0000000000..f4c70dd9e6
--- /dev/null
+++ b/libheif/file.cc
@@ -0,0 +1,1354 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "file.h"
+#include "box.h"
+#include "libheif/heif.h"
+#include "libheif/heif_properties.h"
+#include "compression.h"
+#include "image-items/jpeg2000.h"
+#include "image-items/jpeg.h"
+#include "image-items/vvc.h"
+#include "codecs/avif_boxes.h"
+#include "codecs/hevc_boxes.h"
+#include "sequences/seq_boxes.h"
+
+#include <cstdint>
+#include <fstream>
+#include <limits>
+#include <sstream>
+#include <utility>
+#include <cstring>
+#include <cassert>
+#include <algorithm>
+
+#include "libheif/heif_cxx.h"
+
+#if defined(__MINGW32__) || defined(__MINGW64__) || defined(_MSC_VER)
+
+#ifndef NOMINMAX
+#define NOMINMAX 1
+#endif
+
+#include <windows.h>
+#endif
+
+
+#if WITH_UNCOMPRESSED_CODEC
+#include "image-items/unc_image.h"
+#endif
+
+// TODO: make this a decoder option
+#define STRICT_PARSING false
+
+
+HeifFile::HeifFile()
+{
+  m_file_layout = std::make_shared<FileLayout>();
+}
+
+HeifFile::~HeifFile() = default;
+
+std::vector<heif_item_id> HeifFile::get_item_IDs() const
+{
+  std::vector<heif_item_id> IDs;
+
+  for (const auto& infe : m_infe_boxes) {
+    IDs.push_back(infe.second->get_item_ID());
+  }
+
+  return IDs;
+}
+
+
+std::shared_ptr<const Box_infe> HeifFile::get_infe_box(heif_item_id ID) const
+{
+  auto iter = m_infe_boxes.find(ID);
+  if (iter == m_infe_boxes.end()) {
+    return nullptr;
+  }
+
+  return iter->second;
+}
+
+
+std::shared_ptr<Box_infe> HeifFile::get_infe_box(heif_item_id ID)
+{
+  auto iter = m_infe_boxes.find(ID);
+  if (iter == m_infe_boxes.end()) {
+    return nullptr;
+  }
+
+  return iter->second;
+}
+
+
+Error HeifFile::read_from_file(const char* input_filename)
+{
+#if defined(__MINGW32__) || defined(__MINGW64__) || defined(_MSC_VER)
+  auto input_stream_istr = std::unique_ptr<std::istream>(new std::ifstream(convert_utf8_path_to_utf16(input_filename).c_str(), std::ios_base::binary));
+#else
+  auto input_stream_istr = std::unique_ptr<std::istream>(new std::ifstream(input_filename, std::ios_base::binary));
+#endif
+  if (!input_stream_istr->good()) {
+    std::stringstream sstr;
+    sstr << "Error opening file: " << strerror(errno) << " (" << errno << ")\n";
+    return Error(heif_error_Input_does_not_exist, heif_suberror_Unspecified, sstr.str());
+  }
+
+  auto input_stream = std::make_shared<StreamReader_istream>(std::move(input_stream_istr));
+  return read(input_stream);
+}
+
+
+Error HeifFile::read_from_memory(const void* data, size_t size, bool copy)
+{
+  auto input_stream = std::make_shared<StreamReader_memory>((const uint8_t*) data, size, copy);
+
+  return read(input_stream);
+}
+
+
+Error HeifFile::read(const std::shared_ptr<StreamReader>& reader)
+{
+  assert(m_limits);
+
+  m_input_stream = reader;
+
+  Error err;
+  err = m_file_layout->read(reader, m_limits);
+  if (err) {
+    return err;
+  }
+
+  Error error = parse_heif_file();
+  return error;
+}
+
+
+bool HeifFile::has_images() const
+{
+  if (!m_meta_box) {
+    return false;
+  }
+
+  return m_hdlr_box && m_hdlr_box->get_handler_type() == fourcc("pict");
+}
+
+
+void HeifFile::new_empty_file()
+{
+  //m_input_stream.reset();
+  m_top_level_boxes.clear();
+
+  m_ftyp_box = std::make_shared<Box_ftyp>();
+  m_top_level_boxes.push_back(m_ftyp_box);
+}
+
+
+void HeifFile::init_for_meta_item()
+{
+  if (!m_meta_box) {
+    m_meta_box = std::make_shared<Box_meta>();
+    m_top_level_boxes.push_back(m_meta_box);
+  }
+
+  if (!m_hdlr_box) {
+    m_hdlr_box = std::make_shared<Box_hdlr>();
+    m_hdlr_box->set_handler_type(fourcc("null"));
+    m_meta_box->append_child_box(m_hdlr_box);
+  }
+
+  if (!m_iloc_box) {
+    m_iloc_box = std::make_shared<Box_iloc>();
+    m_meta_box->append_child_box(m_iloc_box);
+  }
+
+  if (!m_iinf_box) {
+    m_iinf_box = std::make_shared<Box_iinf>();
+    m_meta_box->append_child_box(m_iinf_box);
+  }
+}
+
+
+void HeifFile::init_for_image()
+{
+  init_for_meta_item();
+
+  // Upgrade handler from "null" to "pict" if needed
+  if (m_hdlr_box->get_handler_type() == fourcc("null")) {
+    m_hdlr_box->set_handler_type(fourcc("pict"));
+  }
+
+  if (!m_pitm_box) {
+    m_pitm_box = std::make_shared<Box_pitm>();
+    m_meta_box->append_child_box(m_pitm_box);
+  }
+
+  if (!m_iprp_box) {
+    m_iprp_box = std::make_shared<Box_iprp>();
+    m_meta_box->append_child_box(m_iprp_box);
+  }
+
+  if (!m_ipco_box) {
+    m_ipco_box = std::make_shared<Box_ipco>();
+    m_iprp_box->append_child_box(m_ipco_box);
+  }
+
+  if (!m_ipma_box) {
+    m_ipma_box = std::make_shared<Box_ipma>();
+    m_iprp_box->append_child_box(m_ipma_box);
+  }
+}
+
+
+void HeifFile::init_for_sequence()
+{
+  if (m_moov_box) {
+    return;
+  }
+
+  m_moov_box = std::make_shared<Box_moov>();
+  m_top_level_boxes.push_back(m_moov_box);
+
+  m_mvhd_box = std::make_shared<Box_mvhd>();
+  m_moov_box->append_child_box(m_mvhd_box);
+}
+
+
+size_t HeifFile::append_mdat_data(const std::vector<uint8_t>& data)
+{
+  if (!m_mdat_data) {
+    m_mdat_data = std::make_unique<MdatData_Memory>();
+  }
+
+  return m_mdat_data->append_data(data);
+}
+
+
+void HeifFile::derive_box_versions()
+{
+  for (auto& box : m_top_level_boxes) {
+    box->derive_box_version_recursive();
+  }
+}
+
+
+void HeifFile::write(StreamWriter& writer)
+{
+  for (auto& box : m_top_level_boxes) {
+#if ENABLE_EXPERIMENTAL_MINI_FORMAT
+    if (box == nullptr) {
+      // Either mini or meta will be null, just ignore that one
+      continue;
+    }
+#endif
+    Error err = box->write(writer);
+    (void)err; // TODO: error ?
+  }
+
+  if (m_iloc_box) {
+    // TODO: rewrite to use MdatData class
+    Error err = m_iloc_box->write_mdat_after_iloc(writer);
+    (void)err; // TODO: error ?
+  }
+
+  if (m_mdat_data) {
+    Result<size_t> mdatResult = write_mdat(writer);
+    if (!mdatResult) {
+      return; // TODO: error ?
+    }
+
+    for (auto& box : m_top_level_boxes) {
+      box->patch_file_pointers_recursively(writer, *mdatResult);
+    }
+  }
+}
+
+
+std::string HeifFile::debug_dump_boxes() const
+{
+  std::stringstream sstr;
+
+  bool first = true;
+
+  for (const auto& box : m_top_level_boxes) {
+#if ENABLE_EXPERIMENTAL_MINI_FORMAT
+    if (box == nullptr) {
+      // Either mini or meta will be null, just ignore that one
+      continue;
+    }
+#endif
+    // dump box content for debugging
+
+    if (first) {
+      first = false;
+    }
+    else {
+      sstr << "\n";
+    }
+
+    Indent indent;
+    sstr << box->dump(indent);
+  }
+
+  return sstr.str();
+}
+
+
+Error HeifFile::parse_heif_file()
+{
+  // --- read all top-level boxes
+
+#if 0
+  for (;;) {
+    std::shared_ptr<Box> box;
+    Error error = Box::read(range, &box);
+
+    if (range.error() || range.eof()) {
+      break;
+    }
+
+    // When an EOF error is returned, this is not really a fatal exception,
+    // but simply the indication that we reached the end of the file.
+    // TODO: this design should be cleaned up
+    if (error.error_code == heif_error_Invalid_input && error.sub_error_code == heif_suberror_End_of_data) {
+      break;
+    }
+
+    if (error != Error::Ok) {
+      return error;
+    }
+
+    m_top_level_boxes.push_back(box);
+
+
+    // extract relevant boxes (ftyp, meta)
+
+    if (box->get_short_type() == fourcc("meta")) {
+      m_meta_box = std::dynamic_pointer_cast<Box_meta>(box);
+    }
+
+    if (box->get_short_type() == fourcc("ftyp")) {
+      m_ftyp_box = std::dynamic_pointer_cast<Box_ftyp>(box);
+    }
+  }
+#endif
+
+  m_ftyp_box = m_file_layout->get_ftyp_box();
+  if (!m_ftyp_box) {
+    return Error(heif_error_Invalid_input,
+                 heif_suberror_No_ftyp_box);
+  }
+
+  m_top_level_boxes.push_back(m_ftyp_box);
+
+  bool is_sequence_brand = (m_ftyp_box->has_compatible_brand(heif_brand2_msf1) ||
+                            m_ftyp_box->has_compatible_brand(heif_brand2_isom) ||
+                            m_ftyp_box->has_compatible_brand(heif_brand2_mp41) ||
+                            m_ftyp_box->has_compatible_brand(heif_brand2_mp42));
+
+  // --- check whether this is a HEIF file and its structural format
+
+  if (!m_ftyp_box->has_compatible_brand(heif_brand2_heic) &&
+      !m_ftyp_box->has_compatible_brand(heif_brand2_heix) &&
+      !m_ftyp_box->has_compatible_brand(heif_brand2_mif1) &&
+      !m_ftyp_box->has_compatible_brand(heif_brand2_avif) &&
+      !m_ftyp_box->has_compatible_brand(heif_brand2_1pic) &&
+#if ENABLE_EXPERIMENTAL_MINI_FORMAT
+      !(m_ftyp_box->get_major_brand() == heif_brand2_mif3) &&
+#endif
+      !m_ftyp_box->has_compatible_brand(heif_brand2_jpeg) &&
+      !m_ftyp_box->has_compatible_brand(heif_brand2_isom) &&
+      !m_ftyp_box->has_compatible_brand(heif_brand2_mp42) &&
+      !m_ftyp_box->has_compatible_brand(heif_brand2_mp41) &&
+      !m_ftyp_box->has_compatible_brand(heif_brand2_msf1)) {
+    std::stringstream sstr;
+    sstr << "File does not include any supported brands.\n";
+
+    return Error(heif_error_Unsupported_filetype,
+                 heif_suberror_Unspecified,
+                 sstr.str());
+      }
+
+#if ENABLE_EXPERIMENTAL_MINI_FORMAT
+  m_mini_box = m_file_layout->get_mini_box();
+  m_top_level_boxes.push_back(m_mini_box);
+
+  if (m_mini_box) {
+    Error err = m_mini_box->create_expanded_boxes(this);
+    if (err) {
+      return err;
+    }
+    return Error::Ok;
+  }
+#endif
+
+  m_meta_box = m_file_layout->get_meta_box();
+  if (m_meta_box) {
+    m_top_level_boxes.push_back(m_meta_box);
+  }
+
+  // TODO: we are missing 'mdat' top level boxes
+
+  m_moov_box = m_file_layout->get_moov_box();
+  if (m_moov_box) {
+    m_top_level_boxes.push_back(m_moov_box);
+  }
+
+  // if we didn't find the mini box, meta is required
+
+  if (!m_meta_box && !is_sequence_brand) {
+    return Error(heif_error_Invalid_input,
+                 heif_suberror_No_meta_box);
+  }
+
+  if (!m_moov_box && is_sequence_brand) {
+    return Error(heif_error_Invalid_input,
+                 heif_suberror_No_moov_box);
+  }
+
+  if (m_meta_box) {
+    auto err = parse_heif_images();
+    if (err) {
+      return err;
+    }
+  }
+
+  if (m_moov_box) {
+    auto err = parse_heif_sequences();
+    if (err) {
+      return err;
+    }
+  }
+
+  return Error::Ok;
+}
+
+
+Error HeifFile::parse_heif_images()
+{
+  m_hdlr_box = m_meta_box->get_child_box<Box_hdlr>();
+  if (STRICT_PARSING && !m_hdlr_box) {
+    return Error(heif_error_Invalid_input,
+                 heif_suberror_No_hdlr_box);
+  }
+
+  // --- assign item boxes
+
+  m_iinf_box = m_meta_box->get_child_box<Box_iinf>();
+  if (!m_iinf_box) {
+    return Error(heif_error_Invalid_input,
+                 heif_suberror_No_iinf_box);
+  }
+
+  std::vector<std::shared_ptr<Box_infe>> infe_boxes = m_iinf_box->get_child_boxes<Box_infe>();
+
+  for (auto& infe_box : infe_boxes) {
+    if (!infe_box) {
+      return Error(heif_error_Invalid_input,
+                   heif_suberror_No_infe_box);
+    }
+
+    m_infe_boxes.insert(std::make_pair(infe_box->get_item_ID(), infe_box));
+  }
+
+
+  if (has_images()) {
+    // --- find mandatory boxes needed for image decoding
+
+    m_pitm_box = m_meta_box->get_child_box<Box_pitm>();
+    if (!m_pitm_box) {
+      return Error(heif_error_Invalid_input,
+                   heif_suberror_No_pitm_box);
+    }
+
+    m_iprp_box = m_meta_box->get_child_box<Box_iprp>();
+    if (!m_iprp_box) {
+      return Error(heif_error_Invalid_input,
+                   heif_suberror_No_iprp_box);
+    }
+
+    m_ipco_box = m_iprp_box->get_child_box<Box_ipco>();
+    if (!m_ipco_box) {
+      return Error(heif_error_Invalid_input,
+                   heif_suberror_No_ipco_box);
+    }
+
+    auto ipma_boxes = m_iprp_box->get_child_boxes<Box_ipma>();
+    if (ipma_boxes.empty()) {
+      return Error(heif_error_Invalid_input,
+                   heif_suberror_No_ipma_box);
+    }
+    for (size_t i=1;i<ipma_boxes.size();i++) {
+      ipma_boxes[0]->insert_entries_from_other_ipma_box(*ipma_boxes[i]);
+    }
+    m_ipma_box = ipma_boxes[0];
+  }
+
+  m_iloc_box = m_meta_box->get_child_box<Box_iloc>();
+  if (!m_iloc_box) {
+    return Error(heif_error_Invalid_input,
+                 heif_suberror_No_iloc_box);
+  }
+
+  m_idat_box = m_meta_box->get_child_box<Box_idat>();
+
+  m_iref_box = m_meta_box->get_child_box<Box_iref>();
+  if (m_iref_box && m_pitm_box) {
+    Error error = check_for_ref_cycle(get_primary_image_ID(), m_iref_box);
+    if (error) {
+      return error;
+    }
+  }
+
+  m_grpl_box = m_meta_box->get_child_box<Box_grpl>();
+
+
+  return Error::Ok;
+}
+
+
+Error HeifFile::parse_heif_sequences()
+{
+  m_mvhd_box = m_moov_box->get_child_box<Box_mvhd>();
+  if (!m_mvhd_box) {
+    return {heif_error_Invalid_input,
+            heif_suberror_Unspecified,
+            "No mvhd box in image sequence."};
+  }
+
+  return Error::Ok;
+}
+
+
+Error HeifFile::check_for_ref_cycle(heif_item_id ID,
+                                    const std::shared_ptr<Box_iref>& iref_box) const
+{
+  std::unordered_set<heif_item_id> parent_items;
+  return check_for_ref_cycle_recursion(ID, iref_box, parent_items);
+}
+
+
+Error HeifFile::check_for_ref_cycle_recursion(heif_item_id ID,
+                                    const std::shared_ptr<Box_iref>& iref_box,
+                                    std::unordered_set<heif_item_id>& parent_items) const {
+  if (parent_items.find(ID) != parent_items.end()) {
+    return Error(heif_error_Invalid_input,
+                 heif_suberror_Item_reference_cycle,
+                 "Image reference cycle");
+  }
+  parent_items.insert(ID);
+
+  std::vector<heif_item_id> image_references = iref_box->get_references(ID, fourcc("dimg"));
+  for (heif_item_id reference_idx : image_references) {
+    Error error = check_for_ref_cycle_recursion(reference_idx, iref_box, parent_items);
+    if (error) {
+      return error;
+    }
+  }
+
+  parent_items.erase(ID);
+  return Error::Ok;
+}
+
+
+bool HeifFile::item_exists(heif_item_id ID) const
+{
+  auto image_iter = m_infe_boxes.find(ID);
+  return image_iter != m_infe_boxes.end();
+}
+
+
+bool HeifFile::has_item_with_id(heif_item_id ID) const
+{
+  auto infe_box = get_infe_box(ID);
+  return infe_box != nullptr;
+}
+
+
+uint32_t HeifFile::get_item_type_4cc(heif_item_id ID) const
+{
+  auto infe_box = get_infe_box(ID);
+  if (!infe_box) {
+    return 0;
+  }
+
+  return infe_box->get_item_type_4cc();
+}
+
+
+std::string HeifFile::get_content_type(heif_item_id ID) const
+{
+  auto infe_box = get_infe_box(ID);
+  if (!infe_box) {
+    return "";
+  }
+
+  return infe_box->get_content_type();
+}
+
+std::string HeifFile::get_item_uri_type(heif_item_id ID) const
+{
+  auto infe_box = get_infe_box(ID);
+  if (!infe_box) {
+    return "";
+  }
+
+  return infe_box->get_item_uri_type();
+}
+
+
+Error HeifFile::get_properties(heif_item_id imageID,
+                               std::vector<std::shared_ptr<Box>>& properties) const
+{
+  if (!m_ipco_box) {
+    return Error(heif_error_Invalid_input,
+                 heif_suberror_No_ipco_box);
+  }
+  else if (!m_ipma_box) {
+    return Error(heif_error_Invalid_input,
+                 heif_suberror_No_ipma_box);
+  }
+
+  return m_ipco_box->get_properties_for_item_ID(imageID, m_ipma_box, properties);
+}
+
+
+Result<std::vector<uint8_t>> HeifFile::get_uncompressed_item_data(heif_item_id ID) const
+{
+  assert(m_limits);
+
+#if ENABLE_PARALLEL_TILE_DECODING
+  // std::lock_guard<std::mutex> guard(m_read_mutex);   // TODO: I think that this is not needed anymore because this function is not used for image data anymore.
+#endif
+
+  if (!m_iloc_box) {
+    return Error(heif_error_Invalid_input, heif_suberror_No_iloc_box);
+  }
+
+  if (!item_exists(ID)) {
+    return Error(heif_error_Usage_error,
+                 heif_suberror_Nonexisting_item_referenced);
+  }
+
+  auto infe_box = get_infe_box(ID);
+  if (!infe_box) {
+    return Error(heif_error_Usage_error,
+                 heif_suberror_Nonexisting_item_referenced);
+  }
+
+
+  uint32_t item_type = infe_box->get_item_type_4cc();
+  std::string content_type = infe_box->get_content_type();
+
+  // --- decompress data
+
+  Error error;
+
+  if (item_type == fourcc("mime")) {
+    std::string encoding = infe_box->get_content_encoding();
+    if (encoding == "compress_zlib") {
+#if HAVE_ZLIB
+      std::vector<uint8_t> compressed_data;
+      error = m_iloc_box->read_data(ID, m_input_stream, m_idat_box, &compressed_data, m_limits);
+      if (error) {
+        return error;
+      }
+
+      return decompress_zlib(compressed_data);
+#else
+      return Error(heif_error_Unsupported_feature,
+                   heif_suberror_Unsupported_header_compression_method,
+                   encoding);
+#endif
+    }
+    else if (encoding == "deflate") {
+#if HAVE_ZLIB
+      std::vector<uint8_t> compressed_data;
+      error = m_iloc_box->read_data(ID, m_input_stream, m_idat_box, &compressed_data, m_limits);
+      if (error) {
+        return error;
+      }
+      return decompress_deflate(compressed_data);
+#else
+      return Error(heif_error_Unsupported_feature,
+                   heif_suberror_Unsupported_header_compression_method,
+                   encoding);
+#endif
+    }
+    else if (encoding == "br") {
+#if HAVE_BROTLI
+      std::vector<uint8_t> compressed_data;
+      error = m_iloc_box->read_data(ID, m_input_stream, m_idat_box, &compressed_data, m_limits);
+      if (error) {
+        return error;
+      }
+      return decompress_brotli(compressed_data);
+#else
+      return Error(heif_error_Unsupported_feature,
+                   heif_suberror_Unsupported_header_compression_method,
+                   encoding);
+#endif
+    }
+    else if (!encoding.empty()) {
+      return Error(heif_error_Unsupported_feature, heif_suberror_Unsupported_codec);
+    }
+  }
+
+
+  // --- read uncompressed
+
+  std::vector<uint8_t> data;
+  error = m_iloc_box->read_data(ID, m_input_stream, m_idat_box, &data, m_limits);
+  if (error) {
+    return error;
+  }
+  else {
+    return data;
+  }
+}
+
+
+Error HeifFile::append_data_from_file_range(std::vector<uint8_t>& out_data, uint64_t offset, uint32_t size) const
+{
+  bool success = m_input_stream->seek(offset);
+  if (!success) {
+    // TODO: error
+  }
+
+  auto old_size = out_data.size();
+  out_data.resize(old_size + size);
+
+  success = m_input_stream->read(out_data.data() + old_size, size);
+  if (!success) {
+    // TODO: error
+  }
+
+  return {};
+}
+
+
+Error HeifFile::append_data_from_iloc(heif_item_id ID, std::vector<uint8_t>& out_data, uint64_t offset, uint64_t size) const
+{
+  if (!m_iloc_box) {
+    return Error(heif_error_Invalid_input, heif_suberror_No_iloc_box);
+  }
+
+  const auto& items = m_iloc_box->get_items();
+  const Box_iloc::Item* item = nullptr;
+  for (const auto& i : items) {
+    if (i.item_ID == ID) {
+      item = &i;
+      break;
+    }
+  }
+  if (!item) {
+    std::stringstream sstr;
+    sstr << "Item with ID " << ID << " has no compressed data";
+
+    return {heif_error_Invalid_input,
+            heif_suberror_No_item_data,
+            sstr.str()};
+  }
+
+  return m_iloc_box->read_data(ID, m_input_stream, m_idat_box, &out_data, offset, size, m_limits);
+}
+
+
+Result<std::vector<uint8_t>> HeifFile::get_item_data(heif_item_id ID, heif_metadata_compression* out_compression) const
+{
+  Error error;
+
+  assert(m_limits);
+
+  if (!m_iloc_box) {
+    return Error(heif_error_Invalid_input, heif_suberror_No_iloc_box);
+  }
+
+  auto infe_box = get_infe_box(ID);
+  if (!infe_box) {
+    return Error{heif_error_Usage_error,
+                 heif_suberror_Nonexisting_item_referenced};
+  }
+
+  uint32_t item_type = infe_box->get_item_type_4cc();
+  std::string content_type = infe_box->get_content_type();
+
+  // --- non 'mime' data (uncompressed)
+
+  if (item_type != fourcc("mime")) {
+    if (out_compression) {
+      *out_compression = heif_metadata_compression_off;
+    }
+
+    std::vector<uint8_t> out_data;
+    Error err = m_iloc_box->read_data(ID, m_input_stream, m_idat_box, &out_data, m_limits);
+    if (err) {
+      return err;
+    }
+    else {
+      return out_data;
+    }
+  }
+
+
+  // --- mime data
+
+  std::string encoding = infe_box->get_content_encoding();
+
+  heif_metadata_compression compression;
+
+  if (encoding.empty()) {
+    // shortcut for case of uncompressed mime data
+
+    if (out_compression) {
+      *out_compression = heif_metadata_compression_off;
+    }
+
+    std::vector<uint8_t> out_data;
+    Error err = m_iloc_box->read_data(ID, m_input_stream, m_idat_box, &out_data, m_limits);
+    if (err) {
+      return err;
+    }
+    else {
+      return out_data;
+    }
+  }
+  else if (encoding == "compress_zlib") {
+    compression = heif_metadata_compression_zlib;
+  }
+  else if (encoding == "deflate") {
+    compression = heif_metadata_compression_deflate;
+  }
+  else if (encoding == "br") {
+    compression = heif_metadata_compression_brotli;
+  }
+  else {
+    compression = heif_metadata_compression_unknown;
+  }
+
+  // read compressed data
+
+  std::vector<uint8_t> compressed_data;
+  error = m_iloc_box->read_data(ID, m_input_stream, m_idat_box, &compressed_data, m_limits);
+  if (error) {
+    return error;
+  }
+
+  // return compressed data, if we do not want to have it uncompressed
+
+  const bool return_compressed = (out_compression != nullptr);
+  if (return_compressed) {
+    *out_compression = compression;
+    return compressed_data;
+  }
+
+  // decompress the data
+
+  switch (compression) {
+#if HAVE_ZLIB
+    case heif_metadata_compression_zlib:
+      return decompress_zlib(compressed_data);
+    case heif_metadata_compression_deflate:
+      return decompress_deflate(compressed_data);
+#endif
+#if HAVE_BROTLI
+    case heif_metadata_compression_brotli:
+      return decompress_brotli(compressed_data);
+#endif
+    default:
+      return Error{heif_error_Unsupported_filetype, heif_suberror_Unsupported_header_compression_method};
+  }
+}
+
+
+Result<heif_item_id> HeifFile::get_unused_item_id()
+{
+  return m_id_creator.get_new_id(IDCreator::Namespace::item);
+}
+
+
+Result<heif_item_id> HeifFile::add_new_image(uint32_t item_type)
+{
+  auto result = add_new_infe_box(item_type);
+  if (!result) {
+    return result.error();
+  }
+  return (*result)->get_item_ID();
+}
+
+
+Result<std::shared_ptr<Box_infe>> HeifFile::add_new_infe_box(uint32_t item_type)
+{
+  init_for_image();
+
+  auto idResult = get_unused_item_id();
+  if (!idResult) {
+    return idResult.error();
+  }
+  heif_item_id id = *idResult;
+
+  auto infe = std::make_shared<Box_infe>();
+  infe->set_item_ID(id);
+  infe->set_hidden_item(false);
+  infe->set_item_type_4cc(item_type);
+
+  m_infe_boxes[id] = infe;
+  m_iinf_box->append_child_box(infe);
+
+  return infe;
+}
+
+
+Result<std::shared_ptr<Box_infe>> HeifFile::add_new_meta_infe_box(uint32_t item_type)
+{
+  init_for_meta_item();
+
+  auto idResult = get_unused_item_id();
+  if (!idResult) {
+    return idResult.error();
+  }
+  heif_item_id id = *idResult;
+
+  auto infe = std::make_shared<Box_infe>();
+  infe->set_item_ID(id);
+  infe->set_hidden_item(false);
+  infe->set_item_type_4cc(item_type);
+
+  m_infe_boxes[id] = infe;
+  m_iinf_box->append_child_box(infe);
+
+  return infe;
+}
+
+
+void HeifFile::add_ispe_property(heif_item_id id, uint32_t width, uint32_t height, bool essential)
+{
+  auto ispe = std::make_shared<Box_ispe>();
+  ispe->set_size(width, height);
+
+  uint32_t index = m_ipco_box->find_or_append_child_box(ispe);
+
+  m_ipma_box->add_property_for_item_ID(id, Box_ipma::PropertyAssociation{essential, uint16_t(index + 1)});
+}
+
+
+
+heif_property_id HeifFile::add_property(heif_item_id id, const std::shared_ptr<Box>& property, bool essential)
+{
+  uint32_t index = m_ipco_box->find_or_append_child_box(property);
+
+  m_ipma_box->add_property_for_item_ID(id, Box_ipma::PropertyAssociation{essential, uint16_t(index + 1)});
+
+  return index + 1;
+}
+
+
+heif_property_id HeifFile::add_property_without_deduplication(heif_item_id id, const std::shared_ptr<Box>& property, bool essential)
+{
+  uint32_t index = m_ipco_box->append_child_box(property);
+
+  m_ipma_box->add_property_for_item_ID(id, Box_ipma::PropertyAssociation{essential, uint16_t(index + 1)});
+
+  return index + 1;
+}
+
+
+void HeifFile::add_orientation_properties(heif_item_id id, heif_orientation orientation)
+{
+  // Note: ISO/IEC 23000-22:2019(E) (MIAF) 7.3.6.7 requires the following order:
+  // clean aperture first, then rotation, then mirror
+
+  int rotation_ccw = 0;
+  heif_transform_mirror_direction mirror;
+  bool has_mirror = false;
+
+  switch (orientation) {
+    case heif_orientation_normal:
+      break;
+    case heif_orientation_flip_horizontally:
+      mirror = heif_transform_mirror_direction_horizontal;
+      has_mirror = true;
+      break;
+    case heif_orientation_rotate_180:
+      rotation_ccw = 180;
+      break;
+    case heif_orientation_flip_vertically:
+      mirror = heif_transform_mirror_direction_vertical;
+      has_mirror = true;
+      break;
+    case heif_orientation_rotate_90_cw_then_flip_horizontally:
+      rotation_ccw = 270;
+      mirror = heif_transform_mirror_direction_horizontal;
+      has_mirror = true;
+      break;
+    case heif_orientation_rotate_90_cw:
+      rotation_ccw = 270;
+      break;
+    case heif_orientation_rotate_90_cw_then_flip_vertically:
+      rotation_ccw = 270;
+      mirror = heif_transform_mirror_direction_vertical;
+      has_mirror = true;
+      break;
+    case heif_orientation_rotate_270_cw:
+      rotation_ccw = 90;
+      break;
+  }
+
+  // omit rotation when angle is 0
+  if (rotation_ccw!=0) {
+    auto irot = std::make_shared<Box_irot>();
+    irot->set_rotation_ccw(rotation_ccw);
+
+    uint32_t index = m_ipco_box->find_or_append_child_box(irot);
+
+    m_ipma_box->add_property_for_item_ID(id, Box_ipma::PropertyAssociation{true, uint16_t(index + 1)});
+  }
+
+  if (has_mirror) {
+    auto imir = std::make_shared<Box_imir>();
+    imir->set_mirror_direction(mirror);
+
+    uint32_t index = m_ipco_box->find_or_append_child_box(imir);
+
+    m_ipma_box->add_property_for_item_ID(id, Box_ipma::PropertyAssociation{true, uint16_t(index + 1)});
+  }
+}
+
+
+Result<heif_item_id> HeifFile::add_infe(uint32_t item_type, const uint8_t* data, size_t size)
+{
+  // create an infe box describing what kind of data we are storing (this also creates a new ID)
+
+  auto infe_result = add_new_infe_box(item_type);
+  if (!infe_result) {
+    return infe_result.error();
+  }
+  auto infe_box = *infe_result;
+  infe_box->set_hidden_item(true);
+
+  heif_item_id metadata_id = infe_box->get_item_ID();
+
+  set_item_data(infe_box, data, size, heif_metadata_compression_off);
+
+  return metadata_id;
+}
+
+
+void HeifFile::add_infe_box(heif_item_id id, std::shared_ptr<Box_infe> infe)
+{
+  m_infe_boxes.insert(std::make_pair(id, std::move(infe)));
+}
+
+
+Result<heif_item_id> HeifFile::add_infe_mime(const char* content_type, heif_metadata_compression content_encoding, const uint8_t* data, size_t size)
+{
+  // create an infe box describing what kind of data we are storing (this also creates a new ID)
+
+  auto infe_result = add_new_meta_infe_box(fourcc("mime"));
+  if (!infe_result) {
+    return infe_result.error();
+  }
+  auto infe_box = *infe_result;
+  infe_box->set_hidden_item(true);
+  infe_box->set_content_type(content_type);
+
+  heif_item_id metadata_id = infe_box->get_item_ID();
+
+  set_item_data(infe_box, data, size, content_encoding);
+
+  return metadata_id;
+}
+
+
+Result<heif_item_id> HeifFile::add_precompressed_infe_mime(const char* content_type, std::string content_encoding, const uint8_t* data, size_t size)
+{
+  // create an infe box describing what kind of data we are storing (this also creates a new ID)
+
+  auto infe_result = add_new_meta_infe_box(fourcc("mime"));
+  if (!infe_result) {
+    return infe_result.error();
+  }
+  auto infe_box = *infe_result;
+  infe_box->set_hidden_item(true);
+  infe_box->set_content_type(content_type);
+
+  heif_item_id metadata_id = infe_box->get_item_ID();
+
+  set_precompressed_item_data(infe_box, data, size, std::move(content_encoding));
+
+  return metadata_id;
+}
+
+
+Result<heif_item_id> HeifFile::add_infe_uri(const char* item_uri_type, const uint8_t* data, size_t size)
+{
+  // create an infe box describing what kind of data we are storing (this also creates a new ID)
+
+  auto infe_result = add_new_meta_infe_box(fourcc("uri "));
+  if (!infe_result) {
+    return infe_result.error();
+  }
+  auto infe_box = *infe_result;
+  infe_box->set_hidden_item(true);
+  infe_box->set_item_uri_type(item_uri_type);
+
+  heif_item_id metadata_id = infe_box->get_item_ID();
+
+  set_item_data(infe_box, data, size, heif_metadata_compression_off);
+
+  return metadata_id;
+}
+
+
+Error HeifFile::set_item_data(const std::shared_ptr<Box_infe>& item, const uint8_t* data, size_t size, heif_metadata_compression compression)
+{
+  // --- metadata compression
+
+  if (compression == heif_metadata_compression_auto) {
+    compression = heif_metadata_compression_off; // currently, we don't use header compression by default
+  }
+
+  // only set metadata compression for MIME type data which has 'content_encoding' field
+  if (compression != heif_metadata_compression_off &&
+      item->get_item_type_4cc() != fourcc("mime")) {
+    // TODO: error, compression not supported
+  }
+
+
+  std::vector<uint8_t> data_array;
+  if (compression == heif_metadata_compression_zlib) {
+#if HAVE_ZLIB
+    data_array = compress_zlib((const uint8_t*) data, size);
+    item->set_content_encoding("compress_zlib");
+#else
+    return Error(heif_error_Unsupported_feature,
+                 heif_suberror_Unsupported_header_compression_method);
+#endif
+  }
+  else if (compression == heif_metadata_compression_deflate) {
+#if HAVE_ZLIB
+    data_array = compress_deflate((const uint8_t*) data, size);
+    item->set_content_encoding("deflate");
+#else
+    return Error(heif_error_Unsupported_feature,
+                 heif_suberror_Unsupported_header_compression_method);
+#endif
+  }
+  else if (compression == heif_metadata_compression_brotli) {
+#if HAVE_BROTLI
+    data_array = compress_brotli((const uint8_t*)data, size);
+    item->set_content_encoding("br");
+#else
+    return Error(heif_error_Unsupported_feature,
+                 heif_suberror_Unsupported_header_compression_method);
+#endif
+  }
+  else {
+    // uncompressed data, plain copy
+
+    if (size > 0) { // Note: this 'if' is not necessary, but a workaround to a compiler bug (https://github.com/strukturag/libheif/issues/1421)
+      data_array.resize(size);
+      memcpy(data_array.data(), data, size);
+    }
+  }
+
+  // copy the data into the file, store the pointer to it in an iloc box entry
+
+  append_iloc_data(item->get_item_ID(), data_array, 0);
+
+  return Error::Ok;
+}
+
+
+Error HeifFile::set_precompressed_item_data(const std::shared_ptr<Box_infe>& item, const uint8_t* data, size_t size, std::string content_encoding)
+{
+  // only set metadata compression for MIME type data which has 'content_encoding' field
+  if (!content_encoding.empty() &&
+      item->get_item_type_4cc() != fourcc("mime")) {
+    // TODO: error, compression not supported
+  }
+
+
+  std::vector<uint8_t> data_array;
+  data_array.resize(size);
+  memcpy(data_array.data(), data, size);
+
+  item->set_content_encoding(content_encoding);
+
+  // copy the data into the file, store the pointer to it in an iloc box entry
+
+  append_iloc_data(item->get_item_ID(), data_array, 0);
+
+  return Error::Ok;
+}
+
+
+void HeifFile::append_iloc_data(heif_item_id id, const std::vector<uint8_t>& nal_packets, uint8_t construction_method)
+{
+  m_iloc_box->append_data(id, nal_packets, construction_method);
+}
+
+
+void HeifFile::replace_iloc_data(heif_item_id id, uint64_t offset, const std::vector<uint8_t>& data, uint8_t construction_method)
+{
+  m_iloc_box->replace_data(id, offset, data, construction_method);
+}
+
+
+void HeifFile::set_primary_item_id(heif_item_id id)
+{
+  if (!m_pitm_box) {
+    m_pitm_box = std::make_shared<Box_pitm>();
+    m_meta_box->replace_child_box(m_pitm_box);
+  }
+
+  m_pitm_box->set_item_ID(id);
+}
+
+
+void HeifFile::set_ipco_box(std::shared_ptr<Box_ipco> ipco)
+{
+  m_ipco_box = ipco;
+  m_meta_box->replace_child_box(ipco);
+}
+
+
+void HeifFile::set_ipma_box(std::shared_ptr<Box_ipma> ipma)
+{
+  m_ipma_box = ipma;
+  m_meta_box->replace_child_box(ipma);
+}
+
+
+void HeifFile::set_iloc_box(std::shared_ptr<Box_iloc> iloc)
+{
+  m_iloc_box = iloc;
+  m_meta_box->replace_child_box(iloc);
+}
+
+
+void HeifFile::set_iref_box(std::shared_ptr<Box_iref> iref)
+{
+  m_iref_box = iref;
+  m_meta_box->replace_child_box(iref);
+}
+
+
+void HeifFile::add_iref_reference(heif_item_id from, uint32_t type,
+                                  const std::vector<heif_item_id>& to)
+{
+  if (!m_iref_box) {
+    m_iref_box = std::make_shared<Box_iref>();
+    m_meta_box->append_child_box(m_iref_box);
+  }
+
+  m_iref_box->add_references(from, type, to);
+}
+
+
+void HeifFile::set_iref_reference(heif_item_id from, uint32_t type, int reference_idx, heif_item_id to_item)
+{
+  assert(m_iref_box);
+  m_iref_box->overwrite_reference(from, type, reference_idx, to_item);
+}
+
+
+void HeifFile::add_entity_group_box(const std::shared_ptr<Box>& entity_group_box)
+{
+  if (!m_grpl_box) {
+    m_grpl_box = std::make_shared<Box_grpl>();
+    m_meta_box->append_child_box(m_grpl_box);
+  }
+
+  m_grpl_box->append_child_box(entity_group_box);
+}
+
+
+std::shared_ptr<Box_EntityToGroup> HeifFile::get_entity_group(heif_entity_group_id id)
+{
+  if (!m_grpl_box) {
+    return nullptr;
+  }
+
+  const auto& entityGroups = m_grpl_box->get_all_child_boxes();
+  for (auto& groupBase : entityGroups) {
+    auto group = std::dynamic_pointer_cast<Box_EntityToGroup>(groupBase);
+    assert(group);
+
+    if (group->get_group_id() == id) {
+      return group;
+    }
+  }
+
+  return nullptr;
+}
+
+
+void HeifFile::set_auxC_property(heif_item_id id, const std::string& type)
+{
+  auto auxC = std::make_shared<Box_auxC>();
+  auxC->set_aux_type(type);
+
+  uint32_t index = m_ipco_box->find_or_append_child_box(auxC);
+
+  m_ipma_box->add_property_for_item_ID(id, Box_ipma::PropertyAssociation{true, uint16_t(index + 1)});
+}
+
+#if defined(__MINGW32__) || defined(__MINGW64__) || defined(_MSC_VER)
+std::wstring HeifFile::convert_utf8_path_to_utf16(std::string str)
+{
+  std::wstring ret;
+  int len = MultiByteToWideChar(CP_UTF8, 0, str.c_str(), (int)str.length(), NULL, 0);
+  if (len > 0)
+  {
+    ret.resize(len);
+    MultiByteToWideChar(CP_UTF8, 0, str.c_str(), (int)str.length(), &ret[0], len);
+  }
+  return ret;
+}
+#endif
+
+
+Result<size_t> HeifFile::write_mdat(StreamWriter& writer)
+{
+  // --- write mdat box
+
+  size_t mdatSize = m_mdat_data->get_data_size();
+
+  if (mdatSize <= 0xFFFFFFFF - 8) {
+    writer.write32((uint32_t) (mdatSize + 8));
+    writer.write32(fourcc("mdat"));
+  }
+  else {
+    // box size > 4 GB
+
+    writer.write32(1);
+    writer.write32(fourcc("mdat"));
+    writer.write64(mdatSize+8+8);
+  }
+
+  size_t dataStartPos = writer.get_position();
+
+  m_mdat_data->write(writer);
+
+  return dataStartPos;
+}
diff --git a/libheif/file.h b/libheif/file.h
new file mode 100644
index 0000000000..4790a364dc
--- /dev/null
+++ b/libheif/file.h
@@ -0,0 +1,313 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_FILE_H
+#define LIBHEIF_FILE_H
+
+#include "box.h"
+#include "id_creator.h"
+#include "nclx.h"
+#include "image-items/avif.h"
+#include "image-items/hevc.h"
+#include "image-items/vvc.h"
+//#include "codecs/uncompressed/unc_boxes.h"
+#include "file_layout.h"
+
+#include <map>
+#include <memory>
+#include <string>
+#include <map>
+#include <vector>
+#include <unordered_set>
+#include <limits>
+#include <utility>
+#include "mdat_data.h"
+
+#if ENABLE_PARALLEL_TILE_DECODING
+
+#include <mutex>
+
+#endif
+
+
+class HeifPixelImage;
+
+class Box_j2kH;
+
+class Box_moov;
+
+class Box_mvhd;
+
+
+
+class HeifFile
+{
+public:
+  HeifFile();
+
+  ~HeifFile();
+
+  // The limits will be shared from the HeifContext limits.
+  // You have to make sure that the pointer points to a valid object as long as the HeifFile is used.
+  void set_security_limits(const heif_security_limits* limits) { m_limits = limits; }
+
+  Error read(const std::shared_ptr<StreamReader>& reader);
+
+  Error read_from_file(const char* input_filename);
+
+  Error read_from_memory(const void* data, size_t size, bool copy);
+
+  bool has_images() const;
+
+  bool has_sequences() const { return m_moov_box != nullptr; }
+
+  std::shared_ptr<StreamReader> get_reader() { return m_input_stream; }
+
+  void new_empty_file();
+
+  void init_for_meta_item();
+
+  void init_for_image();
+
+  void init_for_sequence();
+
+  void set_hdlr_box(std::shared_ptr<Box_hdlr> box) { m_hdlr_box = std::move(box); }
+
+  size_t append_mdat_data(const std::vector<uint8_t>& data);
+
+  void derive_box_versions();
+
+  void write(StreamWriter& writer);
+
+  int get_num_images() const { return static_cast<int>(m_infe_boxes.size()); }
+
+  heif_item_id get_primary_image_ID() const { return m_pitm_box ? m_pitm_box->get_item_ID() : 0; }
+
+  size_t get_number_of_items() const { return m_infe_boxes.size(); }
+
+  std::vector<heif_item_id> get_item_IDs() const;
+
+  bool item_exists(heif_item_id ID) const;
+
+  bool has_item_with_id(heif_item_id ID) const;
+
+  uint32_t get_item_type_4cc(heif_item_id ID) const;
+
+  std::string get_content_type(heif_item_id ID) const;
+
+  std::string get_item_uri_type(heif_item_id ID) const;
+
+  Result<std::vector<uint8_t>> get_uncompressed_item_data(heif_item_id ID) const;
+
+  Error append_data_from_file_range(std::vector<uint8_t>& out_data, uint64_t offset, uint32_t size) const;
+
+  Error append_data_from_iloc(heif_item_id ID, std::vector<uint8_t>& out_data, uint64_t offset, uint64_t size) const;
+
+  Error append_data_from_iloc(heif_item_id ID, std::vector<uint8_t>& out_data) const {
+    return append_data_from_iloc(ID, out_data, 0, std::numeric_limits<uint64_t>::max());
+  }
+
+  // If `out_compression` is not NULL, the compression method is returned there and the compressed data is returned.
+  // If `out_compression` is NULL, the data is returned decompressed.
+  Result<std::vector<uint8_t>> get_item_data(heif_item_id ID, heif_metadata_compression* out_compression) const;
+
+  std::shared_ptr<Box_ftyp> get_ftyp_box() { return m_ftyp_box; }
+
+  void init_meta_box() { m_meta_box = std::make_shared<Box_meta>(); }
+
+  std::shared_ptr<const Box_infe> get_infe_box(heif_item_id imageID) const;
+
+  std::shared_ptr<Box_infe> get_infe_box(heif_item_id imageID);
+
+  void set_iref_box(std::shared_ptr<Box_iref>);
+
+  std::shared_ptr<Box_iref> get_iref_box() { return m_iref_box; }
+
+  std::shared_ptr<const Box_iref> get_iref_box() const { return m_iref_box; }
+
+  std::shared_ptr<Box_ipco> get_ipco_box() { return m_ipco_box; }
+
+  void set_ipco_box(std::shared_ptr<Box_ipco>);
+
+  std::shared_ptr<Box_ipco> get_ipco_box() const { return m_ipco_box; }
+
+  void set_ipma_box(std::shared_ptr<Box_ipma>);
+
+  std::shared_ptr<Box_ipma> get_ipma_box() { return m_ipma_box; }
+
+  std::shared_ptr<Box_ipma> get_ipma_box() const { return m_ipma_box; }
+
+  std::shared_ptr<Box_grpl> get_grpl_box() const { return m_grpl_box; }
+
+  std::shared_ptr<Box_meta> get_meta_box() const { return m_meta_box; }
+
+  std::shared_ptr<Box_EntityToGroup> get_entity_group(heif_entity_group_id id);
+
+  Error get_properties(heif_item_id imageID,
+                       std::vector<std::shared_ptr<Box>>& properties) const;
+
+  template<class BoxType>
+  std::shared_ptr<BoxType> get_property_for_item(heif_item_id imageID) const
+  {
+    std::vector<std::shared_ptr<Box>> properties;
+    Error err = get_properties(imageID, properties);
+    if (err) {
+      return nullptr;
+    }
+
+    for (auto& property : properties) {
+      if (auto box = std::dynamic_pointer_cast<BoxType>(property)) {
+        return box;
+      }
+    }
+
+    return nullptr;
+  }
+
+  std::string debug_dump_boxes() const;
+
+
+  // --- writing ---
+
+  IDCreator& get_id_creator() { return m_id_creator; }
+
+  const IDCreator& get_id_creator() const { return m_id_creator; }
+
+  Result<heif_item_id> get_unused_item_id();
+
+  Result<heif_item_id> add_new_image(uint32_t item_type);
+
+  Result<std::shared_ptr<Box_infe>> add_new_infe_box(uint32_t item_type);
+
+  Result<std::shared_ptr<Box_infe>> add_new_meta_infe_box(uint32_t item_type);
+
+  void add_ispe_property(heif_item_id id, uint32_t width, uint32_t height, bool essential);
+
+  // set irot/imir according to heif_orientation
+  void add_orientation_properties(heif_item_id id, heif_orientation);
+
+  // TODO: can we remove the 'essential' parameter and take this from the box? Or is that depending on the context?
+  heif_property_id add_property(heif_item_id id, const std::shared_ptr<Box>& property, bool essential);
+
+  heif_property_id add_property_without_deduplication(heif_item_id id, const std::shared_ptr<Box>& property, bool essential);
+
+  Result<heif_item_id> add_infe(uint32_t item_type, const uint8_t* data, size_t size);
+
+  void add_infe_box(heif_item_id, std::shared_ptr<Box_infe> infe);
+
+  Result<heif_item_id> add_infe_mime(const char* content_type, heif_metadata_compression content_encoding, const uint8_t* data, size_t size);
+
+  Result<heif_item_id> add_precompressed_infe_mime(const char* content_type, std::string content_encoding, const uint8_t* data, size_t size);
+
+  Result<heif_item_id> add_infe_uri(const char* item_uri_type, const uint8_t* data, size_t size);
+
+  Error set_item_data(const std::shared_ptr<Box_infe>& item, const uint8_t* data, size_t size, heif_metadata_compression compression);
+
+  Error set_precompressed_item_data(const std::shared_ptr<Box_infe>& item, const uint8_t* data, size_t size, std::string content_encoding);
+
+  void append_iloc_data(heif_item_id id, const std::vector<uint8_t>& nal_packets, uint8_t construction_method);
+
+  void replace_iloc_data(heif_item_id id, uint64_t offset, const std::vector<uint8_t>& data, uint8_t construction_method = 0);
+
+  void set_iloc_box(std::shared_ptr<Box_iloc>);
+
+  std::shared_ptr<Box_iloc> get_iloc_box() { return m_iloc_box; }
+
+  void set_primary_item_id(heif_item_id id);
+
+  void add_iref_reference(heif_item_id from, uint32_t type,
+                          const std::vector<heif_item_id>& to);
+
+  void set_iref_reference(heif_item_id from, uint32_t type, int reference_idx, heif_item_id to_item);
+
+  void add_entity_group_box(const std::shared_ptr<Box>& entity_group_box);
+
+  void set_auxC_property(heif_item_id id, const std::string& type);
+
+#if defined(__MINGW32__) || defined(__MINGW64__) || defined(_MSC_VER)
+  static std::wstring convert_utf8_path_to_utf16(std::string pathutf8);
+#endif
+
+
+  // --- sequences
+
+  std::shared_ptr<Box_moov> get_moov_box() { return m_moov_box; }
+
+  std::shared_ptr<Box_mvhd> get_mvhd_box() { return m_mvhd_box; }
+
+private:
+#if ENABLE_PARALLEL_TILE_DECODING
+  mutable std::mutex m_read_mutex;
+#endif
+
+  std::shared_ptr<FileLayout> m_file_layout;
+
+  std::shared_ptr<StreamReader> m_input_stream;
+
+  std::vector<std::shared_ptr<Box> > m_top_level_boxes;
+
+  std::shared_ptr<Box_ftyp> m_ftyp_box;
+  std::shared_ptr<Box_hdlr> m_hdlr_box;
+  std::shared_ptr<Box_meta> m_meta_box;
+#if ENABLE_EXPERIMENTAL_MINI_FORMAT
+  std::shared_ptr<Box_mini> m_mini_box; // meta alternative
+#endif
+
+  std::shared_ptr<Box_iloc> m_iloc_box;
+  std::shared_ptr<Box_idat> m_idat_box;
+  std::shared_ptr<Box_iref> m_iref_box;
+  std::shared_ptr<Box_iinf> m_iinf_box;
+  std::shared_ptr<Box_grpl> m_grpl_box;
+  std::shared_ptr<Box_pitm> m_pitm_box; // only non-null if has_images()==true
+  std::shared_ptr<Box_iprp> m_iprp_box; // only non-null if has_images()==true
+  std::shared_ptr<Box_ipco> m_ipco_box; // only non-null if has_images()==true
+  std::shared_ptr<Box_ipma> m_ipma_box; // only non-null if has_images()==true
+
+
+  std::map<heif_item_id, std::shared_ptr<Box_infe> > m_infe_boxes;
+
+  std::unique_ptr<MdatData> m_mdat_data;
+
+  // returns the position of the first data byte in the file
+  Result<size_t> write_mdat(StreamWriter& writer);
+
+  // --- sequences
+
+  std::shared_ptr<Box_moov> m_moov_box;
+  std::shared_ptr<Box_mvhd> m_mvhd_box;
+
+  const heif_security_limits* m_limits = nullptr;
+  IDCreator m_id_creator;
+
+  Error parse_heif_file();
+
+  Error parse_heif_images();
+
+  Error parse_heif_sequences();
+
+  Error check_for_ref_cycle(heif_item_id ID,
+                            const std::shared_ptr<Box_iref>& iref_box) const;
+
+  Error check_for_ref_cycle_recursion(heif_item_id ID,
+                                      const std::shared_ptr<Box_iref>& iref_box,
+                                      std::unordered_set<heif_item_id>& parent_items) const;
+};
+
+#endif
diff --git a/libheif/file_layout.cc b/libheif/file_layout.cc
new file mode 100644
index 0000000000..4ce83cf640
--- /dev/null
+++ b/libheif/file_layout.cc
@@ -0,0 +1,268 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "file_layout.h"
+#include "sequences/seq_boxes.h"
+#include <limits>
+
+
+FileLayout::FileLayout()
+{
+  auto ftyp = std::make_shared<Box_ftyp>();
+  ftyp->set_output_position(0);
+  m_boxes.push_back(ftyp);
+
+  // TODO: these variables are not used yet
+  (void)m_writeMode;
+  (void)m_file_size;
+}
+
+
+Error FileLayout::read(const std::shared_ptr<StreamReader>& stream, const heif_security_limits* limits)
+{
+  m_boxes.clear();
+
+  m_stream_reader = stream;
+
+  // --- read initial range, large enough to cover 'ftyp' box
+
+  m_max_length = stream->request_range(0, INITIAL_FTYP_REQUEST);
+
+  if (m_max_length < MAXIMUM_BOX_HEADER_SIZE) {
+    return {heif_error_Invalid_input,
+            heif_suberror_Unspecified,
+            "File size too small."};
+  }
+
+  // --- read 'ftyp' box header
+
+  BitstreamRange ftyp_hdr_range(m_stream_reader, m_max_length);
+  BoxHeader ftyp_header;
+  Error err;
+  err = ftyp_header.parse_header(ftyp_hdr_range);
+  if (err) {
+    return err;
+  }
+
+  // --- check whether it is a valid 'ftyp' box header
+
+  if (ftyp_header.get_short_type() != fourcc("ftyp")) {
+    return {heif_error_Invalid_input,
+            heif_suberror_No_ftyp_box,
+            "File does not start with 'ftyp' box."};
+  }
+
+  uint64_t ftyp_size = ftyp_header.get_box_size();
+
+  if (ftyp_size == 0) {
+    return {heif_error_Invalid_input,
+            heif_suberror_No_ftyp_box,
+            "ftyp box shall not be the only box in the file"};
+  }
+
+  if (ftyp_size > m_max_length) {
+    return {heif_error_Invalid_input,
+            heif_suberror_No_ftyp_box,
+            "ftyp box larger than initial read range"};
+  }
+
+  // --- read the 'ftyp' box
+
+  BitstreamRange ftyp_range(m_stream_reader, 0, ftyp_size);
+  std::shared_ptr<Box> ftyp_box;
+  err = Box::read(ftyp_range, &ftyp_box, limits);
+
+  m_boxes.push_back(ftyp_box);
+  m_ftyp_box = std::dynamic_pointer_cast<Box_ftyp>(ftyp_box);
+
+
+  // --- skip through box headers until we find the 'meta' box
+
+  uint64_t next_box_start = ftyp_size;
+
+  bool meta_found = false;
+  bool mini_found = false;
+  bool moov_found = false;
+
+  for (;;) {
+    // TODO: overflow
+    uint64_t next_box_header_end = next_box_start + MAXIMUM_BOX_HEADER_SIZE;
+    if (next_box_header_end > m_max_length) {
+      m_max_length = stream->request_range(next_box_start, next_box_header_end);
+    }
+
+    if (next_box_header_end > m_max_length) {
+      if (meta_found || mini_found || moov_found) {
+        return Error::Ok;
+      }
+      else {
+        return {heif_error_Invalid_input,
+                heif_suberror_Unspecified,
+                "Insufficient input data"};
+      }
+    }
+
+    BitstreamRange box_range(m_stream_reader, next_box_start, m_max_length);
+    BoxHeader box_header;
+    err = box_header.parse_header(box_range);
+    if (err) {
+      return err;
+    }
+
+    if (box_header.get_short_type() == fourcc("meta")) {
+      const uint64_t meta_box_start = next_box_start;
+      if (box_header.get_box_size() == 0) {
+        // TODO: get file-size from stream and compute box size
+        return {heif_error_Invalid_input,
+                heif_suberror_No_meta_box,
+                "Cannot read meta box with unspecified size"};
+      }
+
+      // TODO: overflow
+      uint64_t end_of_meta_box = meta_box_start + box_header.get_box_size();
+      if (m_max_length < end_of_meta_box) {
+        m_max_length = m_stream_reader->request_range(meta_box_start, end_of_meta_box);
+      }
+
+      if (m_max_length < end_of_meta_box) {
+        return {heif_error_Invalid_input,
+                heif_suberror_No_meta_box,
+                "Cannot read full meta box"};
+      }
+
+      BitstreamRange meta_box_range(m_stream_reader, meta_box_start, end_of_meta_box);
+      std::shared_ptr<Box> meta_box;
+      err = Box::read(meta_box_range, &meta_box, limits);
+      if (err) {
+        return err;
+      }
+
+      m_boxes.push_back(meta_box);
+      m_meta_box = std::dynamic_pointer_cast<Box_meta>(meta_box);
+      meta_found = true;
+    }
+
+#if ENABLE_EXPERIMENTAL_MINI_FORMAT
+    // TODO: this is basically the same as the meta box case above, with different error handling.
+    if (box_header.get_short_type() == fourcc("mini")) {
+      const uint64_t mini_box_start = next_box_start;
+      if (box_header.get_box_size() == 0) {
+        // TODO: get file-size from stream and compute box size
+        return {heif_error_Invalid_input,
+                heif_suberror_Invalid_mini_box,
+                "Cannot read mini box with unspecified size"};
+      }
+      uint64_t end_of_mini_box = mini_box_start + box_header.get_box_size();
+      if (m_max_length < end_of_mini_box) {
+        m_max_length = m_stream_reader->request_range(mini_box_start, end_of_mini_box);
+      }
+
+      if (m_max_length < end_of_mini_box) {
+        return {heif_error_Invalid_input,
+                heif_suberror_Invalid_mini_box,
+                "Cannot read full mini box"};
+      }
+      BitstreamRange mini_box_range(m_stream_reader, mini_box_start, end_of_mini_box);
+      std::shared_ptr<Box> mini_box;
+      err = Box::read(mini_box_range, &mini_box, heif_get_global_security_limits());
+      if (err) {
+        std::cout << "error reading mini box" << std::endl;
+        return err;
+      }
+
+      m_boxes.push_back(mini_box);
+      m_mini_box = std::dynamic_pointer_cast<Box_mini>(mini_box);
+      if (m_mini_box == nullptr) {
+        std::cout << "error casting mini box" << std::endl;
+      }
+
+      mini_found = true;
+    }
+#endif
+
+    if (box_header.get_short_type() == fourcc("moov")) {
+      const uint64_t moov_box_start = next_box_start;
+      if (box_header.get_box_size() == 0) {
+        // TODO: get file-size from stream and compute box size
+        return {heif_error_Invalid_input,
+                heif_suberror_No_moov_box,
+                "Cannot read moov box with unspecified size"};
+      }
+
+      // TODO: overflow
+      uint64_t end_of_moov_box = moov_box_start + box_header.get_box_size();
+      if (m_max_length < end_of_moov_box) {
+        m_max_length = m_stream_reader->request_range(moov_box_start, end_of_moov_box);
+      }
+
+      if (m_max_length < end_of_moov_box) {
+        return {heif_error_Invalid_input,
+                heif_suberror_No_moov_box,
+                "Cannot read full moov box"};
+      }
+
+      BitstreamRange moov_box_range(m_stream_reader, moov_box_start, end_of_moov_box);
+      std::shared_ptr<Box> moov_box;
+      err = Box::read(moov_box_range, &moov_box, limits);
+      if (err) {
+        return err;
+      }
+
+      m_boxes.push_back(moov_box);
+      m_moov_box = std::dynamic_pointer_cast<Box_moov>(moov_box);
+
+      moov_found = true;
+    }
+
+    uint64_t boxSize = box_header.get_box_size();
+    if (boxSize == Box::size_until_end_of_file) {
+      if (meta_found || mini_found || moov_found) {
+        return Error::Ok;
+      }
+      else {
+        return {heif_error_Invalid_input,
+                heif_suberror_Unspecified,
+                "No meta box found"};
+      }
+    }
+
+    if (std::numeric_limits<uint64_t>::max() - boxSize < next_box_start) {
+      return {heif_error_Invalid_input,
+              heif_suberror_Unspecified,
+              "Box size too large, integer overflow"};
+    }
+
+    next_box_start = next_box_start + boxSize;
+  }
+
+  return Error::Ok;
+}
+
+
+void FileLayout::set_write_mode(WriteMode writeMode, const std::shared_ptr<StreamWriter>& writer)
+{
+
+}
+
+
+Error FileLayout::write(std::shared_ptr<StreamWriter>& stream)
+{
+  return Error::Ok;
+}
diff --git a/libheif/file_layout.h b/libheif/file_layout.h
new file mode 100644
index 0000000000..d7aaf145af
--- /dev/null
+++ b/libheif/file_layout.h
@@ -0,0 +1,97 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_FILELAYOUT_H
+#define LIBHEIF_FILELAYOUT_H
+
+#include "error.h"
+#include "bitstream.h"
+#include "box.h"
+#if ENABLE_EXPERIMENTAL_MINI_FORMAT
+#include "mini.h"
+#endif
+
+#include <memory>
+#include <vector>
+
+class Box_moov;
+
+
+class FileLayout
+{
+public:
+  enum class WriteMode {
+    Streaming, // 'mdat' data will be written to output immediately
+    Floating,  // 'mdat' data will be held in memory until written
+    TmpFile    // 'mdat' data will be written to temporary file and copied into final file
+  };
+
+  // Generate a file in WriteMode::Floating
+  FileLayout();
+
+  Error read(const std::shared_ptr<StreamReader>& stream, const heif_security_limits* limits);
+
+  // For WriteMode::Streaming, writer cannot be null.
+  void set_write_mode(WriteMode writeMode, const std::shared_ptr<StreamWriter>& writer = nullptr);
+
+  // For WriteMode::Streaming, stream must be null.
+  Error write(std::shared_ptr<StreamWriter>& stream);
+
+
+  // --- access to boxes
+
+  std::shared_ptr<Box_ftyp> get_ftyp_box() { return m_ftyp_box; }
+
+  std::shared_ptr<Box_meta> get_meta_box() { return m_meta_box; }
+
+#if ENABLE_EXPERIMENTAL_MINI_FORMAT
+  std::shared_ptr<Box_mini> get_mini_box() { return m_mini_box; }
+#endif
+
+  std::shared_ptr<Box_moov> get_moov_box() { return m_moov_box; }
+
+private:
+  WriteMode m_writeMode = WriteMode::Floating;
+
+  const static uint64_t INVALID_FILE_SIZE = 0xFFFFFFFFFFFFFFFF;
+
+  uint64_t m_file_size = INVALID_FILE_SIZE;
+
+  // the first one is always 'ftyp'
+  std::vector<std::shared_ptr<Box>> m_boxes; // TODO: do we need this ?
+
+  std::shared_ptr<Box_ftyp> m_ftyp_box;
+  std::shared_ptr<Box_meta> m_meta_box;
+#if ENABLE_EXPERIMENTAL_MINI_FORMAT
+  std::shared_ptr<Box_mini> m_mini_box;
+#endif
+  std::shared_ptr<Box_moov> m_moov_box;
+
+
+  uint64_t m_max_length = 0; // Length seen so far. It can grow over time.
+
+  std::shared_ptr<StreamReader> m_stream_reader;
+  std::shared_ptr<StreamWriter> m_stream_writer;
+
+  static const uint64_t INITIAL_FTYP_REQUEST = 1024; // should be enough to read ftyp and next box header
+  static const uint16_t MAXIMUM_BOX_HEADER_SIZE = 32;
+};
+
+#endif //LIBHEIF_FILELAYOUT_H
diff --git a/libheif/heif.cc b/libheif/heif.cc
deleted file mode 100644
index 0ce51531b8..0000000000
--- a/libheif/heif.cc
+++ /dev/null
@@ -1,2339 +0,0 @@
-/*
- * HEIF codec.
- * Copyright (c) 2017 struktur AG, Dirk Farin <farin@struktur.de>
- *
- * This file is part of libheif.
- *
- * libheif is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as
- * published by the Free Software Foundation, either version 3 of
- * the License, or (at your option) any later version.
- *
- * libheif is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#if defined(HAVE_CONFIG_H)
-#include "config.h"
-#endif
-
-#include "heif.h"
-#include "heif_file.h"
-#include "heif_image.h"
-#include "heif_api_structs.h"
-#include "heif_context.h"
-#include "heif_plugin_registry.h"
-#include "error.h"
-#include "bitstream.h"
-
-#if defined(__EMSCRIPTEN__)
-#include "heif_emscripten.h"
-#endif
-
-#include <algorithm>
-#include <iostream>
-#include <fstream>
-#include <memory>
-#include <string>
-#include <utility>
-#include <vector>
-#include <cstring>
-
-#if (defined(__MINGW32__) || defined(__MINGW64__) || defined(_MSC_VER)) && !defined(HAVE_UNISTD_H)
-// for _write
-#include <io.h>
-#else
-
-#include <unistd.h>
-
-#endif
-
-using namespace heif;
-
-static struct heif_error error_Ok = {heif_error_Ok, heif_suberror_Unspecified, kSuccess};
-static struct heif_error error_unsupported_parameter = {heif_error_Usage_error,
-                                                        heif_suberror_Unsupported_parameter,
-                                                        "Unsupported encoder parameter"};
-static struct heif_error error_invalid_parameter_value = {heif_error_Usage_error,
-                                                          heif_suberror_Invalid_parameter_value,
-                                                          "Invalid parameter value"};
-static struct heif_error error_unsupported_plugin_version = {heif_error_Usage_error,
-                                                             heif_suberror_Unsupported_plugin_version,
-                                                             "Unsupported plugin version"};
-static struct heif_error error_null_parameter = {heif_error_Usage_error,
-                                                 heif_suberror_Null_pointer_argument,
-                                                 "NULL passed"};
-
-const char* heif_get_version(void)
-{
-  return (LIBHEIF_VERSION);
-}
-
-uint32_t heif_get_version_number(void)
-{
-  return (LIBHEIF_NUMERIC_VERSION);
-}
-
-int heif_get_version_number_major(void)
-{
-  return ((LIBHEIF_NUMERIC_VERSION) >> 24) & 0xFF;
-}
-
-int heif_get_version_number_minor(void)
-{
-  return ((LIBHEIF_NUMERIC_VERSION) >> 16) & 0xFF;
-}
-
-int heif_get_version_number_maintenance(void)
-{
-  return ((LIBHEIF_NUMERIC_VERSION) >> 8) & 0xFF;
-}
-
-
-heif_filetype_result heif_check_filetype(const uint8_t* data, int len)
-{
-  if (len < 8) {
-    return heif_filetype_maybe;
-  }
-
-  if (data[4] != 'f' ||
-      data[5] != 't' ||
-      data[6] != 'y' ||
-      data[7] != 'p') {
-    return heif_filetype_no;
-  }
-
-  if (len >= 12) {
-    heif_brand brand = heif_main_brand(data, len);
-
-    if (brand == heif_heic) {
-      return heif_filetype_yes_supported;
-    }
-    else if (brand == heif_heix) {
-      return heif_filetype_yes_supported;
-    }
-    else if (brand == heif_avif) {
-      return heif_filetype_yes_supported;
-    }
-    else if (brand == heif_unknown_brand) {
-      return heif_filetype_no;
-    }
-    else if (brand == heif_mif1) {
-      return heif_filetype_maybe;
-    }
-    else {
-      return heif_filetype_yes_unsupported;
-    }
-  }
-
-  return heif_filetype_maybe;
-}
-
-
-heif_brand heif_fourcc_to_brand_enum(const char* fourcc)
-{
-  if (fourcc==nullptr || !fourcc[0] || !fourcc[1] || !fourcc[2] || !fourcc[3]) {
-    return heif_unknown_brand;
-  }
-  
-  char brand[5];
-  brand[0] = fourcc[0];
-  brand[1] = fourcc[1];
-  brand[2] = fourcc[2];
-  brand[3] = fourcc[3];
-  brand[4] = 0;
-
-  if (strcmp(brand, "heic") == 0) {
-    return heif_heic;
-  }
-  else if (strcmp(brand, "heix") == 0) {
-    return heif_heix;
-  }
-  else if (strcmp(brand, "hevc") == 0) {
-    return heif_hevc;
-  }
-  else if (strcmp(brand, "hevx") == 0) {
-    return heif_hevx;
-  }
-  else if (strcmp(brand, "heim") == 0) {
-    return heif_heim;
-  }
-  else if (strcmp(brand, "heis") == 0) {
-    return heif_heis;
-  }
-  else if (strcmp(brand, "hevm") == 0) {
-    return heif_hevm;
-  }
-  else if (strcmp(brand, "hevs") == 0) {
-    return heif_hevs;
-  }
-  else if (strcmp(brand, "mif1") == 0) {
-    return heif_mif1;
-  }
-  else if (strcmp(brand, "msf1") == 0) {
-    return heif_msf1;
-  }
-  else if (strcmp(brand, "avif") == 0) {
-    return heif_avif;
-  }
-  else if (strcmp(brand, "avis") == 0) {
-    return heif_avis;
-  }
-  else {
-    return heif_unknown_brand;
-  }
-}
-
-
-enum heif_brand heif_main_brand(const uint8_t* data, int len)
-{
-  if (len < 12) {
-    return heif_unknown_brand;
-  }
-
-  return heif_fourcc_to_brand_enum((char*)(data+8));
-}
-
-
-heif_brand2 heif_read_main_brand(const uint8_t* data, int len)
-{
-  if (len < 12) {
-    return heif_unknown_brand;
-  }
-
-  return heif_fourcc_to_brand((char*)(data+8));
-}
-
-
-#define fourcc_to_uint32(id) (((uint32_t)(id[0])<<24) | (id[1]<<16) | (id[2]<<8) | (id[3]))
-
-heif_brand2 heif_fourcc_to_brand(const char* fourcc)
-{
-  if (fourcc==nullptr || !fourcc[0] || !fourcc[1] || !fourcc[2] || !fourcc[3]) {
-    return 0;
-  }
-
-  return fourcc_to_uint32(fourcc);
-}
-
-
-void heif_brand_to_fourcc(heif_brand2 brand, char* out_fourcc)
-{
-  if (out_fourcc) {
-    out_fourcc[0] = (char)((brand >> 24) & 0xFF);
-    out_fourcc[1] = (char)((brand >> 16) & 0xFF);
-    out_fourcc[2] = (char)((brand >>  8) & 0xFF);
-    out_fourcc[3] = (char)((brand >>  0) & 0xFF);
-  }
-}
-
-
-int heif_has_compatible_brand(const uint8_t* data, int len, const char* brand_fourcc)
-{
-  if (data == nullptr || len<=0 || brand_fourcc == nullptr || !brand_fourcc[0] || !brand_fourcc[1] || !brand_fourcc[2] || !brand_fourcc[3]) {
-    return -1;
-  }
-  
-  auto stream = std::make_shared<StreamReader_memory>(data, len, false);
-  BitstreamRange range(stream, len);
-
-  std::shared_ptr<heif::Box> box;
-  Error err = Box::read(range, &box);
-  if (err) {
-    if (err.sub_error_code == heif_suberror_End_of_data) {
-      return -1;
-    }
-    
-    return -2;
-  }
-
-  auto ftyp = std::dynamic_pointer_cast<Box_ftyp>(box);
-  if (!ftyp) {
-    return -2;
-  }
-
-  return ftyp->has_compatible_brand(fourcc_to_uint32(brand_fourcc)) ? 1 : 0;
-}
-
-
-
-struct heif_error heif_list_compatible_brands(const uint8_t* data, int len, heif_brand2** out_brands, int* out_size)
-{
-  if (data == nullptr || out_brands==nullptr || out_size==nullptr) {
-    return {heif_error_Usage_error, heif_suberror_Null_pointer_argument, "NULL argument"};
-  }
-
-  if (len<=0) {
-    return {heif_error_Usage_error, heif_suberror_Invalid_parameter_value, "data length must be positive"};
-  }
-  
-  auto stream = std::make_shared<StreamReader_memory>(data, len, false);
-  BitstreamRange range(stream, len);
-
-  std::shared_ptr<heif::Box> box;
-  Error err = Box::read(range, &box);
-  if (err) {
-    if (err.sub_error_code == heif_suberror_End_of_data) {
-      return {err.error_code, err.sub_error_code, "insufficient input data"};
-    }
-    
-    return {err.error_code, err.sub_error_code, "error reading ftyp box"};
-  }
-
-  auto ftyp = std::dynamic_pointer_cast<Box_ftyp>(box);
-  if (!ftyp) {
-    return {heif_error_Invalid_input, heif_suberror_No_ftyp_box, "input is no ftyp box"};
-  }
-
-  auto brands = ftyp->list_brands();
-  *out_brands = (heif_brand2*)malloc(sizeof(heif_brand2) * brands.size());
-  *out_size = (int)brands.size();
-  
-  for (int i=0;i<(int)brands.size();i++) {
-    (*out_brands)[i] = brands[i];
-  }
-  
-  return {heif_error_Ok, heif_suberror_Unspecified, Error::kSuccess};
-}
-
-
-void heif_free_list_of_compatible_brands(heif_brand2* brands_list)
-{
-  if (brands_list) {
-    free(brands_list);
-  }
-}
-
-
-enum class TriBool
-{
-  No, Yes, Unknown
-};
-
-TriBool is_jpeg(const uint8_t* data, int len)
-{
-  if (len < 12) {
-    return TriBool::Unknown;
-  }
-
-  if (data[0] == 0xFF && data[1] == 0xD8 && data[2] == 0xFF && data[3] == 0xE0 &&
-      data[4] == 0x00 && data[5] == 0x10 && data[6] == 0x4A && data[7] == 0x46 &&
-      data[8] == 0x49 && data[9] == 0x46 && data[10] == 0x00 && data[11] == 0x01) {
-    return TriBool::Yes;
-  }
-  if (data[0] == 0xFF && data[1] == 0xD8 && data[2] == 0xFF && data[3] == 0xE1 &&
-      data[6] == 0x45 && data[7] == 0x78 && data[8] == 0x69 && data[9] == 0x66 &&
-      data[10] == 0x00 && data[11] == 0x00) {
-    return TriBool::Yes;
-  }
-  else {
-    return TriBool::No;
-  }
-}
-
-
-TriBool is_png(const uint8_t* data, int len)
-{
-  if (len < 8) {
-    return TriBool::Unknown;
-  }
-
-  if (data[0] == 0x89 && data[1] == 0x50 && data[2] == 0x4E && data[3] == 0x47 &&
-      data[4] == 0x0D && data[5] == 0x0A && data[6] == 0x1A && data[7] == 0x0A) {
-    return TriBool::Yes;
-  }
-  else {
-    return TriBool::No;
-  }
-}
-
-
-const char* heif_get_file_mime_type(const uint8_t* data, int len)
-{
-  heif_brand mainBrand = heif_main_brand(data, len);
-
-  if (mainBrand == heif_heic ||
-      mainBrand == heif_heix ||
-      mainBrand == heif_heim ||
-      mainBrand == heif_heis) {
-    return "image/heic";
-  }
-  else if (mainBrand == heif_mif1) {
-    return "image/heif";
-  }
-  else if (mainBrand == heif_hevc ||
-           mainBrand == heif_hevx ||
-           mainBrand == heif_hevm ||
-           mainBrand == heif_hevs) {
-    return "image/heic-sequence";
-  }
-  else if (mainBrand == heif_msf1) {
-    return "image/heif-sequence";
-  }
-  else if (mainBrand == heif_avif) {
-    return "image/avif";
-  }
-  else if (mainBrand == heif_avis) {
-    return "image/avif-sequence";
-  }
-  else if (is_jpeg(data, len) == TriBool::Yes) {
-    return "image/jpeg";
-  }
-  else if (is_png(data, len) == TriBool::Yes) {
-    return "image/png";
-  }
-  else {
-    return "";
-  }
-}
-
-
-heif_context* heif_context_alloc()
-{
-  struct heif_context* ctx = new heif_context;
-  ctx->context = std::make_shared<HeifContext>();
-
-  return ctx;
-}
-
-void heif_context_free(heif_context* ctx)
-{
-  delete ctx;
-}
-
-heif_error heif_context_read_from_file(heif_context* ctx, const char* filename,
-                                       const struct heif_reading_options*)
-{
-  Error err = ctx->context->read_from_file(filename);
-  return err.error_struct(ctx->context.get());
-}
-
-heif_error heif_context_read_from_memory(heif_context* ctx, const void* mem, size_t size,
-                                         const struct heif_reading_options*)
-{
-  Error err = ctx->context->read_from_memory(mem, size, true);
-  return err.error_struct(ctx->context.get());
-}
-
-heif_error heif_context_read_from_memory_without_copy(heif_context* ctx, const void* mem, size_t size,
-                                                      const struct heif_reading_options*)
-{
-  Error err = ctx->context->read_from_memory(mem, size, false);
-  return err.error_struct(ctx->context.get());
-}
-
-heif_error heif_context_read_from_reader(struct heif_context* ctx,
-                                         const struct heif_reader* reader_func_table,
-                                         void* userdata,
-                                         const struct heif_reading_options*)
-{
-  auto reader = std::make_shared<StreamReader_CApi>(reader_func_table, userdata);
-
-  Error err = ctx->context->read(reader);
-  return err.error_struct(ctx->context.get());
-}
-
-// TODO: heif_error heif_context_read_from_file_descriptor(heif_context*, int fd);
-
-void heif_context_debug_dump_boxes_to_file(struct heif_context* ctx, int fd)
-{
-  if (!ctx) {
-    return;
-  }
-
-  std::string dump = ctx->context->debug_dump_boxes();
-  // TODO(fancycode): Should we return an error if writing fails?
-#if (defined(__MINGW32__) || defined(__MINGW64__) || defined(_MSC_VER)) && !defined(HAVE_UNISTD_H)
-  auto written = _write(fd, dump.c_str(), dump.size());
-#else
-  auto written = write(fd, dump.c_str(), dump.size());
-#endif
-  (void) written;
-}
-
-heif_error heif_context_get_primary_image_handle(heif_context* ctx, heif_image_handle** img)
-{
-  if (!img) {
-    Error err(heif_error_Usage_error,
-              heif_suberror_Null_pointer_argument);
-    return err.error_struct(ctx->context.get());
-  }
-
-  std::shared_ptr<HeifContext::Image> primary_image = ctx->context->get_primary_image();
-
-  // It is a requirement of an HEIF file there is always a primary image.
-  // If there is none, an error is generated when loading the file.
-  if (!primary_image) {
-    Error err(heif_error_Invalid_input,
-              heif_suberror_No_or_invalid_primary_item);
-    return err.error_struct(ctx->context.get());
-  }
-
-  *img = new heif_image_handle();
-  (*img)->image = std::move(primary_image);
-  (*img)->context = ctx->context;
-
-  return Error::Ok.error_struct(ctx->context.get());
-}
-
-
-struct heif_error heif_context_get_primary_image_ID(struct heif_context* ctx, heif_item_id* id)
-{
-  if (!id) {
-    return Error(heif_error_Usage_error,
-                 heif_suberror_Null_pointer_argument).error_struct(ctx->context.get());
-  }
-
-  std::shared_ptr<HeifContext::Image> primary = ctx->context->get_primary_image();
-  if (!primary) {
-    return Error(heif_error_Invalid_input,
-                 heif_suberror_No_or_invalid_primary_item).error_struct(ctx->context.get());
-  }
-
-  *id = primary->get_id();
-
-  return Error::Ok.error_struct(ctx->context.get());
-}
-
-
-int heif_context_is_top_level_image_ID(struct heif_context* ctx, heif_item_id id)
-{
-  const std::vector<std::shared_ptr<HeifContext::Image>> images = ctx->context->get_top_level_images();
-
-  for (const auto& img : images) {
-    if (img->get_id() == id) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-
-int heif_context_get_number_of_top_level_images(heif_context* ctx)
-{
-  return (int) ctx->context->get_top_level_images().size();
-}
-
-
-int heif_context_get_list_of_top_level_image_IDs(struct heif_context* ctx,
-                                                 heif_item_id* ID_array,
-                                                 int count)
-{
-  if (ID_array == nullptr || count == 0 || ctx == nullptr) {
-    return 0;
-  }
-
-
-  // fill in ID values into output array
-
-  const std::vector<std::shared_ptr<HeifContext::Image>> imgs = ctx->context->get_top_level_images();
-  int n = (int) std::min(count, (int) imgs.size());
-  for (int i = 0; i < n; i++) {
-    ID_array[i] = imgs[i]->get_id();
-  }
-
-  return n;
-}
-
-
-struct heif_error heif_context_get_image_handle(struct heif_context* ctx,
-                                                heif_item_id id,
-                                                struct heif_image_handle** imgHdl)
-{
-  if (!imgHdl) {
-    Error err(heif_error_Usage_error,
-              heif_suberror_Null_pointer_argument);
-    return err.error_struct(ctx->context.get());
-  }
-
-  const std::vector<std::shared_ptr<HeifContext::Image>> images = ctx->context->get_top_level_images();
-
-  std::shared_ptr<HeifContext::Image> image;
-  for (auto& img : images) {
-    if (img->get_id() == id) {
-      image = img;
-      break;
-    }
-  }
-
-  if (!image) {
-    Error err(heif_error_Usage_error, heif_suberror_Nonexisting_item_referenced);
-    return err.error_struct(ctx->context.get());
-  }
-
-  *imgHdl = new heif_image_handle();
-  (*imgHdl)->image = image;
-  (*imgHdl)->context = ctx->context;
-
-  return Error::Ok.error_struct(ctx->context.get());
-}
-
-
-int heif_image_handle_is_primary_image(const struct heif_image_handle* handle)
-{
-  return handle->image->is_primary();
-}
-
-
-int heif_image_handle_get_number_of_thumbnails(const struct heif_image_handle* handle)
-{
-  return (int) handle->image->get_thumbnails().size();
-}
-
-
-int heif_image_handle_get_list_of_thumbnail_IDs(const struct heif_image_handle* handle,
-                                                heif_item_id* ids, int count)
-{
-  if (ids == nullptr) {
-    return 0;
-  }
-
-  auto thumbnails = handle->image->get_thumbnails();
-  int n = (int) std::min(count, (int) thumbnails.size());
-
-  for (int i = 0; i < n; i++) {
-    ids[i] = thumbnails[i]->get_id();
-  }
-
-  return n;
-}
-
-
-heif_error heif_image_handle_get_thumbnail(const struct heif_image_handle* handle,
-                                           heif_item_id thumbnail_id,
-                                           struct heif_image_handle** out_thumbnail_handle)
-{
-  if (!out_thumbnail_handle) {
-    return Error(heif_error_Usage_error,
-                 heif_suberror_Null_pointer_argument).error_struct(handle->image.get());
-  }
-
-  auto thumbnails = handle->image->get_thumbnails();
-  for (auto thumb : thumbnails) {
-    if (thumb->get_id() == thumbnail_id) {
-      *out_thumbnail_handle = new heif_image_handle();
-      (*out_thumbnail_handle)->image = thumb;
-      (*out_thumbnail_handle)->context = handle->context;
-
-      return Error::Ok.error_struct(handle->image.get());
-    }
-  }
-
-  Error err(heif_error_Usage_error, heif_suberror_Nonexisting_item_referenced);
-  return err.error_struct(handle->image.get());
-}
-
-
-int heif_image_handle_get_number_of_auxiliary_images(const struct heif_image_handle* handle,
-                                                     int include_alpha_image)
-{
-  return (int) handle->image->get_aux_images(include_alpha_image).size();
-}
-
-
-int heif_image_handle_get_list_of_auxiliary_image_IDs(const struct heif_image_handle* handle,
-                                                      int include_alpha_image,
-                                                      heif_item_id* ids, int count)
-{
-  if (ids == nullptr) {
-    return 0;
-  }
-
-  auto auxImages = handle->image->get_aux_images(include_alpha_image);
-  int n = (int) std::min(count, (int) auxImages.size());
-
-  for (int i = 0; i < n; i++) {
-    ids[i] = auxImages[i]->get_id();
-  }
-
-  return n;
-}
-
-
-struct heif_error heif_image_handle_get_auxiliary_type(const struct heif_image_handle* handle,
-                                                       const char** out_type)
-{
-  if (out_type == nullptr) {
-    return Error(heif_error_Usage_error,
-                 heif_suberror_Null_pointer_argument).error_struct(handle->image.get());
-  }
-
-  auto auxType = handle->image->get_aux_type();
-
-  char* buf = (char*)malloc(auxType.length()+1);
-  
-  if (buf == nullptr) {
-    return Error(heif_error_Memory_allocation_error,
-                 heif_suberror_Unspecified,
-                 "Failed to allocate memory for the type string").error_struct(handle->image.get());
-  }
-  
-  strcpy(buf, auxType.c_str());
-  *out_type = buf;
-
-  return {heif_error_Ok, heif_suberror_Unspecified, Error::kSuccess};
-}
-
-
-void heif_image_handle_free_auxiliary_types(const struct heif_image_handle* handle,
-                                            const char** out_type)
-{
-  if (out_type && *out_type) {
-    free((void*)*out_type);
-    *out_type = nullptr;
-  }
-}
-
-
-struct heif_error heif_image_handle_get_auxiliary_image_handle(const struct heif_image_handle* main_image_handle,
-                                                               heif_item_id auxiliary_id,
-                                                               struct heif_image_handle** out_auxiliary_handle)
-{
-  if (!out_auxiliary_handle) {
-    return Error(heif_error_Usage_error,
-                 heif_suberror_Null_pointer_argument).error_struct(main_image_handle->image.get());
-  }
-
-  auto auxImages = main_image_handle->image->get_aux_images();
-  for (auto aux : auxImages) {
-    if (aux->get_id() == auxiliary_id) {
-      *out_auxiliary_handle = new heif_image_handle();
-      (*out_auxiliary_handle)->image = aux;
-      (*out_auxiliary_handle)->context = main_image_handle->context;
-
-      return Error::Ok.error_struct(main_image_handle->image.get());
-    }
-  }
-
-  Error err(heif_error_Usage_error, heif_suberror_Nonexisting_item_referenced);
-  return err.error_struct(main_image_handle->image.get());
-}
-
-
-int heif_image_handle_get_width(const struct heif_image_handle* handle)
-{
-  if (handle && handle->image) {
-    return handle->image->get_width();
-  }
-  else {
-    return 0;
-  }
-}
-
-
-int heif_image_handle_get_height(const struct heif_image_handle* handle)
-{
-  if (handle && handle->image) {
-    return handle->image->get_height();
-  }
-  else {
-    return 0;
-  }
-}
-
-
-int heif_image_handle_get_ispe_width(const struct heif_image_handle* handle)
-{
-  if (handle && handle->image) {
-    return handle->image->get_ispe_width();
-  }
-  else {
-    return 0;
-  }
-}
-
-
-int heif_image_handle_get_ispe_height(const struct heif_image_handle* handle)
-{
-  if (handle && handle->image) {
-    return handle->image->get_ispe_height();
-  }
-  else {
-    return 0;
-  }
-}
-
-
-int heif_image_handle_has_alpha_channel(const struct heif_image_handle* handle)
-{
-  return handle->image->get_alpha_channel() != nullptr;
-}
-
-
-int heif_image_handle_is_premultiplied_alpha(const struct heif_image_handle* handle)
-{
-  return handle->image->is_premultiplied_alpha();
-}
-
-
-int heif_image_handle_get_luma_bits_per_pixel(const struct heif_image_handle* handle)
-{
-  return handle->image->get_luma_bits_per_pixel();
-}
-
-
-int heif_image_handle_get_chroma_bits_per_pixel(const struct heif_image_handle* handle)
-{
-  return handle->image->get_chroma_bits_per_pixel();
-}
-
-
-int heif_image_handle_has_depth_image(const struct heif_image_handle* handle)
-{
-  return handle->image->get_depth_channel() != nullptr;
-}
-
-void heif_depth_representation_info_free(const struct heif_depth_representation_info* info)
-{
-  delete info;
-}
-
-int heif_image_handle_get_depth_image_representation_info(const struct heif_image_handle* handle,
-                                                          heif_item_id depth_image_id,
-                                                          const struct heif_depth_representation_info** out)
-{
-  std::shared_ptr<HeifContext::Image> depth_image;
-
-  if (out) {
-    if (handle->image->is_depth_channel()) {
-      // Because of an API bug before v1.11.0, the input handle may be the depth image (#422).
-      depth_image = handle->image;
-    }
-    else {
-      depth_image = handle->image->get_depth_channel();
-    }
-
-    if (depth_image->has_depth_representation_info()) {
-      auto info = new heif_depth_representation_info;
-      *info = depth_image->get_depth_representation_info();
-      *out = info;
-      return true;
-    }
-    else {
-      *out = nullptr;
-    }
-  }
-
-  return false;
-}
-
-
-int heif_image_handle_get_number_of_depth_images(const struct heif_image_handle* handle)
-{
-  auto depth_image = handle->image->get_depth_channel();
-
-  if (depth_image) {
-    return 1;
-  }
-  else {
-    return 0;
-  }
-}
-
-
-int heif_image_handle_get_list_of_depth_image_IDs(const struct heif_image_handle* handle,
-                                                  heif_item_id* ids, int count)
-{
-  auto depth_image = handle->image->get_depth_channel();
-
-  if (count == 0) {
-    return 0;
-  }
-
-  if (depth_image) {
-    ids[0] = depth_image->get_id();
-    return 1;
-  }
-  else {
-    return 0;
-  }
-}
-
-
-struct heif_error heif_image_handle_get_depth_image_handle(const struct heif_image_handle* handle,
-                                                           heif_item_id depth_id,
-                                                           struct heif_image_handle** out_depth_handle)
-{
-  auto depth_image = handle->image->get_depth_channel();
-
-  if (depth_image->get_id() != depth_id) {
-    *out_depth_handle = nullptr;
-
-    Error err(heif_error_Usage_error, heif_suberror_Nonexisting_item_referenced);
-    return err.error_struct(handle->image.get());
-  }
-
-  *out_depth_handle = new heif_image_handle();
-  (*out_depth_handle)->image = depth_image;
-  (*out_depth_handle)->context = handle->context;
-
-  return Error::Ok.error_struct(handle->image.get());
-}
-
-
-heif_decoding_options* heif_decoding_options_alloc()
-{
-  auto options = new heif_decoding_options;
-
-  options->version = 2;
-
-  options->ignore_transformations = false;
-
-  options->start_progress = NULL;
-  options->on_progress = NULL;
-  options->end_progress = NULL;
-  options->progress_user_data = NULL;
-
-  // version 2
-
-  options->convert_hdr_to_8bit = false;
-
-  return options;
-}
-
-
-void heif_decoding_options_free(heif_decoding_options* options)
-{
-  delete options;
-}
-
-
-struct heif_error heif_decode_image(const struct heif_image_handle* in_handle,
-                                    struct heif_image** out_img,
-                                    heif_colorspace colorspace,
-                                    heif_chroma chroma,
-                                    const struct heif_decoding_options* options)
-{
-  std::shared_ptr<HeifPixelImage> img;
-
-  heif_item_id id = in_handle->image->get_id();
-
-  Error err = in_handle->context->decode_image_user(id, img,
-                                                    colorspace,
-                                                    chroma,
-                                                    options);
-  if (err.error_code != heif_error_Ok) {
-    return err.error_struct(in_handle->image.get());
-  }
-
-  *out_img = new heif_image();
-  (*out_img)->image = std::move(img);
-
-  return Error::Ok.error_struct(in_handle->image.get());
-}
-
-
-struct heif_error heif_image_create(int width, int height,
-                                    heif_colorspace colorspace,
-                                    heif_chroma chroma,
-                                    struct heif_image** image)
-{
-  struct heif_image* img = new heif_image;
-  img->image = std::make_shared<HeifPixelImage>();
-
-  img->image->create(width, height, colorspace, chroma);
-
-  *image = img;
-
-  struct heif_error err = {heif_error_Ok, heif_suberror_Unspecified, Error::kSuccess};
-  return err;
-}
-
-void heif_image_release(const struct heif_image* img)
-{
-  delete img;
-}
-
-void heif_image_handle_release(const struct heif_image_handle* handle)
-{
-  delete handle;
-}
-
-
-enum heif_colorspace heif_image_get_colorspace(const struct heif_image* img)
-{
-  return img->image->get_colorspace();
-}
-
-enum heif_chroma heif_image_get_chroma_format(const struct heif_image* img)
-{
-  return img->image->get_chroma_format();
-}
-
-
-int heif_image_get_width(const struct heif_image* img, enum heif_channel channel)
-{
-  return img->image->get_width(channel);
-}
-
-
-int heif_image_get_height(const struct heif_image* img, enum heif_channel channel)
-{
-  return img->image->get_height(channel);
-}
-
-
-int heif_image_get_primary_width(const struct heif_image* img)
-{
-  if (img->image->get_colorspace() == heif_colorspace_RGB) {
-    if (img->image->get_chroma_format() == heif_chroma_444) {
-      return img->image->get_width(heif_channel_G);
-    }
-    else {
-      return img->image->get_width(heif_channel_interleaved);
-    }
-  }
-  else {
-    return img->image->get_width(heif_channel_Y);
-  }
-}
-
-
-int heif_image_get_primary_height(const struct heif_image* img)
-{
-  if (img->image->get_colorspace() == heif_colorspace_RGB) {
-    if (img->image->get_chroma_format() == heif_chroma_444) {
-      return img->image->get_height(heif_channel_G);
-    }
-    else {
-      return img->image->get_height(heif_channel_interleaved);
-    }
-  }
-  else {
-    return img->image->get_height(heif_channel_Y);
-  }
-}
-
-
-heif_error heif_image_crop(struct heif_image* img,
-                           int left, int right, int top, int bottom)
-{
-  std::shared_ptr<HeifPixelImage> out_img;
-
-  int w = img->image->get_width();
-  int h = img->image->get_height();
-
-  Error err = img->image->crop(left, w - 1 - right, top, h - 1 - bottom, out_img);
-  if (err) {
-    return err.error_struct(img->image.get());
-  }
-
-  img->image = out_img;
-
-  return heif_error{heif_error_Ok, heif_suberror_Unspecified, Error::kSuccess};
-}
-
-
-int heif_image_get_bits_per_pixel(const struct heif_image* img, enum heif_channel channel)
-{
-  return img->image->get_storage_bits_per_pixel(channel);
-}
-
-
-int heif_image_get_bits_per_pixel_range(const struct heif_image* img, enum heif_channel channel)
-{
-  return img->image->get_bits_per_pixel(channel);
-}
-
-
-int heif_image_has_channel(const struct heif_image* img, enum heif_channel channel)
-{
-  return img->image->has_channel(channel);
-}
-
-
-struct heif_error heif_image_add_plane(struct heif_image* image,
-                                       heif_channel channel, int width, int height, int bit_depth)
-{
-  if (!image->image->add_plane(channel, width, height, bit_depth)) {
-    struct heif_error err = {heif_error_Memory_allocation_error,
-                             heif_suberror_Unspecified,
-                             "Cannot allocate memory for image plane"};
-    return err;
-  }
-  else {
-    struct heif_error err = {heif_error_Ok, heif_suberror_Unspecified, Error::kSuccess};
-    return err;
-  }
-}
-
-
-const uint8_t* heif_image_get_plane_readonly(const struct heif_image* image,
-                                             enum heif_channel channel,
-                                             int* out_stride)
-{
-  if (!image || !image->image) {
-    *out_stride = 0;
-    return nullptr;
-  }
-
-  return image->image->get_plane(channel, out_stride);
-}
-
-
-uint8_t* heif_image_get_plane(struct heif_image* image,
-                              enum heif_channel channel,
-                              int* out_stride)
-{
-  if (!image || !image->image) {
-    *out_stride = 0;
-    return nullptr;
-  }
-
-  return image->image->get_plane(channel, out_stride);
-}
-
-
-void heif_image_set_premultiplied_alpha(struct heif_image* image,
-                                        int is_premultiplied_alpha)
-{
-  if (image == nullptr) {
-    return;
-  }
-
-  image->image->set_premultiplied_alpha(is_premultiplied_alpha);
-}
-
-
-int heif_image_is_premultiplied_alpha(struct heif_image* image)
-{
-  if (image == nullptr) {
-    return 0;
-  }
-
-  return image->image->is_premultiplied_alpha();
-}
-
-
-struct heif_error heif_image_scale_image(const struct heif_image* input,
-                                         struct heif_image** output,
-                                         int width, int height,
-                                         const struct heif_scaling_options* options)
-{
-  std::shared_ptr<HeifPixelImage> out_img;
-
-  Error err = input->image->scale_nearest_neighbor(out_img, width, height);
-  if (err) {
-    return err.error_struct(input->image.get());
-  }
-
-  *output = new heif_image;
-  (*output)->image = out_img;
-
-  return Error::Ok.error_struct(input->image.get());
-}
-
-struct heif_error heif_image_set_raw_color_profile(struct heif_image* image,
-                                                   const char* color_profile_type_fourcc,
-                                                   const void* profile_data,
-                                                   const size_t profile_size)
-{
-  if (strlen(color_profile_type_fourcc) != 4) {
-    heif_error err = {heif_error_Usage_error,
-                      heif_suberror_Unspecified,
-                      "Invalid color_profile_type (must be 4 characters)"};
-    return err;
-  }
-
-  uint32_t color_profile_type = fourcc(color_profile_type_fourcc);
-
-  std::vector<uint8_t> data;
-  data.insert(data.end(),
-              (const uint8_t*) profile_data,
-              (const uint8_t*) profile_data + profile_size);
-
-  auto color_profile = std::make_shared<color_profile_raw>(color_profile_type, data);
-
-  image->image->set_color_profile_icc(color_profile);
-
-  struct heif_error err = {heif_error_Ok, heif_suberror_Unspecified, Error::kSuccess};
-  return err;
-}
-
-
-struct heif_error heif_image_set_nclx_color_profile(struct heif_image* image,
-                                                    const struct heif_color_profile_nclx* color_profile)
-{
-  auto nclx = std::make_shared<color_profile_nclx>();
-
-  nclx->set_colour_primaries(color_profile->color_primaries);
-  nclx->set_transfer_characteristics(color_profile->transfer_characteristics);
-  nclx->set_matrix_coefficients(color_profile->matrix_coefficients);
-  nclx->set_full_range_flag(color_profile->full_range_flag);
-
-  image->image->set_color_profile_nclx(nclx);
-
-  return error_Ok;
-}
-
-
-/*
-void heif_image_remove_color_profile(struct heif_image* image)
-{
-  image->image->set_color_profile(nullptr);
-}
-*/
-
-
-int heif_image_handle_get_number_of_metadata_blocks(const struct heif_image_handle* handle,
-                                                    const char* type_filter)
-{
-  int cnt = 0;
-  for (const auto& metadata : handle->image->get_metadata()) {
-    if (type_filter == nullptr ||
-        metadata->item_type == type_filter) {
-      cnt++;
-    }
-  }
-
-  return cnt;
-}
-
-
-int heif_image_handle_get_list_of_metadata_block_IDs(const struct heif_image_handle* handle,
-                                                     const char* type_filter,
-                                                     heif_item_id* ids, int count)
-{
-  int cnt = 0;
-  for (const auto& metadata : handle->image->get_metadata()) {
-    if (type_filter == nullptr ||
-        metadata->item_type == type_filter) {
-      if (cnt < count) {
-        ids[cnt] = metadata->item_id;
-        cnt++;
-      }
-      else {
-        break;
-      }
-    }
-  }
-
-  return cnt;
-}
-
-
-const char* heif_image_handle_get_metadata_type(const struct heif_image_handle* handle,
-                                                heif_item_id metadata_id)
-{
-  for (auto& metadata : handle->image->get_metadata()) {
-    if (metadata->item_id == metadata_id) {
-      return metadata->item_type.c_str();
-    }
-  }
-
-  return nullptr;
-}
-
-
-const char* heif_image_handle_get_metadata_content_type(const struct heif_image_handle* handle,
-                                                        heif_item_id metadata_id)
-{
-  for (auto& metadata : handle->image->get_metadata()) {
-    if (metadata->item_id == metadata_id) {
-      return metadata->content_type.c_str();
-    }
-  }
-
-  return nullptr;
-}
-
-
-size_t heif_image_handle_get_metadata_size(const struct heif_image_handle* handle,
-                                           heif_item_id metadata_id)
-{
-  for (auto& metadata : handle->image->get_metadata()) {
-    if (metadata->item_id == metadata_id) {
-      return metadata->m_data.size();
-    }
-  }
-
-  return 0;
-}
-
-
-struct heif_error heif_image_handle_get_metadata(const struct heif_image_handle* handle,
-                                                 heif_item_id metadata_id,
-                                                 void* out_data)
-{
-  for (auto& metadata : handle->image->get_metadata()) {
-    if (metadata->item_id == metadata_id) {
-
-      if (!metadata->m_data.empty()) {
-        if (out_data == nullptr) {
-          Error err(heif_error_Usage_error,
-                    heif_suberror_Null_pointer_argument);
-          return err.error_struct(handle->image.get());
-        }
-
-        memcpy(out_data,
-               metadata->m_data.data(),
-               metadata->m_data.size());
-      }
-
-      return Error::Ok.error_struct(handle->image.get());
-    }
-  }
-
-  Error err(heif_error_Usage_error,
-            heif_suberror_Nonexisting_item_referenced);
-  return err.error_struct(handle->image.get());
-}
-
-heif_color_profile_type heif_image_handle_get_color_profile_type(const struct heif_image_handle* handle)
-{
-  auto profile_icc = handle->image->get_color_profile_icc();
-  if (profile_icc) {
-    return (heif_color_profile_type) profile_icc->get_type();
-  }
-
-  auto profile_nclx = handle->image->get_color_profile_nclx();
-  if (profile_nclx) {
-    return (heif_color_profile_type) profile_nclx->get_type();
-  }
-  else {
-    return heif_color_profile_type_not_present;
-  }
-}
-
-size_t heif_image_handle_get_raw_color_profile_size(const struct heif_image_handle* handle)
-{
-  auto profile_icc = handle->image->get_color_profile_icc();
-  if (profile_icc) {
-    return profile_icc->get_data().size();
-  }
-  else {
-    return 0;
-  }
-}
-
-
-struct heif_error heif_image_handle_get_nclx_color_profile(const struct heif_image_handle* handle,
-                                                           struct heif_color_profile_nclx** out_data)
-{
-  if (!out_data) {
-    Error err(heif_error_Usage_error,
-              heif_suberror_Null_pointer_argument);
-    return err.error_struct(handle->image.get());
-  }
-
-  auto nclx_profile = handle->image->get_color_profile_nclx();
-  if (!nclx_profile) {
-    Error err(heif_error_Color_profile_does_not_exist,
-              heif_suberror_Unspecified);
-    return err.error_struct(handle->image.get());
-  }
-
-  Error err = nclx_profile->get_nclx_color_profile(out_data);
-
-  return err.error_struct(handle->image.get());
-}
-
-
-struct heif_error heif_image_handle_get_raw_color_profile(const struct heif_image_handle* handle,
-                                                          void* out_data)
-{
-  if (out_data == nullptr) {
-    Error err(heif_error_Usage_error,
-              heif_suberror_Null_pointer_argument);
-    return err.error_struct(handle->image.get());
-  }
-
-  auto raw_profile = handle->image->get_color_profile_icc();
-  if (raw_profile) {
-    memcpy(out_data,
-           raw_profile->get_data().data(),
-           raw_profile->get_data().size());
-  }
-  else {
-    Error err(heif_error_Color_profile_does_not_exist,
-              heif_suberror_Unspecified);
-    return err.error_struct(handle->image.get());
-  }
-
-  return Error::Ok.error_struct(handle->image.get());
-}
-
-
-enum heif_color_profile_type heif_image_get_color_profile_type(const struct heif_image* image)
-{
-  std::shared_ptr<const color_profile> profile;
-
-  profile = image->image->get_color_profile_icc();
-  if (!profile) {
-    profile = image->image->get_color_profile_nclx();
-  }
-
-  if (!profile) {
-    return heif_color_profile_type_not_present;
-  }
-  else {
-    return (heif_color_profile_type) profile->get_type();
-  }
-}
-
-
-size_t heif_image_get_raw_color_profile_size(const struct heif_image* image)
-{
-  auto raw_profile = image->image->get_color_profile_icc();
-  if (raw_profile) {
-    return raw_profile->get_data().size();
-  }
-  else {
-    return 0;
-  }
-}
-
-
-struct heif_error heif_image_get_raw_color_profile(const struct heif_image* image,
-                                                   void* out_data)
-{
-  if (out_data == nullptr) {
-    Error err(heif_error_Usage_error,
-              heif_suberror_Null_pointer_argument);
-    return err.error_struct(image->image.get());
-  }
-
-  auto raw_profile = image->image->get_color_profile_icc();
-  if (raw_profile) {
-    memcpy(out_data,
-           raw_profile->get_data().data(),
-           raw_profile->get_data().size());
-  }
-
-  return Error::Ok.error_struct(image->image.get());
-}
-
-
-struct heif_error heif_image_get_nclx_color_profile(const struct heif_image* image,
-                                                    struct heif_color_profile_nclx** out_data)
-{
-  if (!out_data) {
-    Error err(heif_error_Usage_error,
-              heif_suberror_Null_pointer_argument);
-    return err.error_struct(image->image.get());
-  }
-
-  auto nclx_profile = image->image->get_color_profile_nclx();
-  
-  if (!nclx_profile) {
-    Error err(heif_error_Color_profile_does_not_exist,
-              heif_suberror_Unspecified);
-    return err.error_struct(image->image.get());
-  }
-  
-  Error err = nclx_profile->get_nclx_color_profile(out_data);
-
-  return err.error_struct(image->image.get());
-}
-
-
-struct heif_color_profile_nclx* heif_nclx_color_profile_alloc()
-{
-  return color_profile_nclx::alloc_nclx_color_profile();
-}
-
-
-void heif_nclx_color_profile_free(struct heif_color_profile_nclx* nclx_profile)
-{
-  color_profile_nclx::free_nclx_color_profile(nclx_profile);
-}
-
-
-// DEPRECATED
-struct heif_error heif_register_decoder(heif_context* heif, const heif_decoder_plugin* decoder_plugin)
-{
-  if (!decoder_plugin) {
-    return error_null_parameter;
-  }
-  else if (decoder_plugin->plugin_api_version != 1) {
-    return error_unsupported_plugin_version;
-  }
-
-  heif->context->register_decoder(decoder_plugin);
-  return Error::Ok.error_struct(heif->context.get());
-}
-
-
-struct heif_error heif_register_decoder_plugin(const heif_decoder_plugin* decoder_plugin)
-{
-  if (!decoder_plugin) {
-    return error_null_parameter;
-  }
-  else if (decoder_plugin->plugin_api_version != 1) {
-    return error_unsupported_plugin_version;
-  }
-
-  register_decoder(decoder_plugin);
-  return error_Ok;
-}
-
-
-struct heif_error heif_register_encoder_plugin(const heif_encoder_plugin* encoder_plugin)
-{
-  if (!encoder_plugin) {
-    return error_null_parameter;
-  }
-  else if (encoder_plugin->plugin_api_version != 1) {
-    return error_unsupported_plugin_version;
-  }
-
-  register_encoder(encoder_plugin);
-  return error_Ok;
-}
-
-
-
-
-/*
-int  heif_image_get_number_of_data_chunks(heif_image* img);
-
-void heif_image_get_data_chunk(heif_image* img, int chunk_index,
-                               uint8_t const*const* dataptr,
-                               int const* data_size);
-
-void heif_image_free_data_chunk(heif_image* img, int chunk_index);
-*/
-
-
-/*
-void heif_context_reset(struct heif_context* ctx)
-{
-  ctx->context->reset_to_empty_heif();
-}
-*/
-
-static struct heif_error heif_file_writer_write(struct heif_context* ctx,
-                                                const void* data, size_t size, void* userdata)
-{
-  const char* filename = static_cast<const char*>(userdata);
-
-#ifdef _MSC_VER
-  std::ofstream ostr(HeifFile::convert_utf8_path_to_utf16(filename).c_str(), std::ios_base::binary);
-#else
-  std::ofstream ostr(filename, std::ios_base::binary);
-#endif
-  ostr.write(static_cast<const char*>(data), size);
-  // TODO: handle write errors
-  return Error::Ok.error_struct(ctx->context.get());
-}
-
-
-struct heif_error heif_context_write_to_file(struct heif_context* ctx,
-                                             const char* filename)
-{
-  heif_writer writer;
-  writer.writer_api_version = 1;
-  writer.write = heif_file_writer_write;
-  return heif_context_write(ctx, &writer, (void*) filename);
-}
-
-
-struct heif_error heif_context_write(struct heif_context* ctx,
-                                     struct heif_writer* writer,
-                                     void* userdata)
-{
-  if (!writer) {
-    return Error(heif_error_Usage_error,
-                 heif_suberror_Null_pointer_argument).error_struct(ctx->context.get());
-  }
-  else if (writer->writer_api_version != 1) {
-    Error err(heif_error_Usage_error, heif_suberror_Unsupported_writer_version);
-    return err.error_struct(ctx->context.get());
-  }
-
-  StreamWriter swriter;
-  ctx->context->write(swriter);
-
-  const auto& data = swriter.get_data();
-  return writer->write(ctx, data.data(), data.size(), userdata);
-}
-
-
-int heif_context_get_encoder_descriptors(struct heif_context* ctx,
-                                         enum heif_compression_format format,
-                                         const char* name,
-                                         const struct heif_encoder_descriptor** out_encoder_descriptors,
-                                         int count)
-{
-  if (out_encoder_descriptors == nullptr || count <= 0) {
-    return 0;
-  }
-
-  std::vector<const struct heif_encoder_descriptor*> descriptors;
-  descriptors = get_filtered_encoder_descriptors(format, name);
-
-  int i;
-  for (i = 0; i < count && static_cast<size_t>(i) < descriptors.size(); i++) {
-    out_encoder_descriptors[i] = descriptors[i];
-  }
-
-  return i;
-}
-
-
-const char* heif_encoder_descriptor_get_name(const struct heif_encoder_descriptor* descriptor)
-{
-  return descriptor->plugin->get_plugin_name();
-}
-
-
-const char* heif_encoder_descriptor_get_id_name(const struct heif_encoder_descriptor* descriptor)
-{
-  return descriptor->plugin->id_name;
-}
-
-
-enum heif_compression_format
-heif_encoder_descriptor_get_compression_format(const struct heif_encoder_descriptor* descriptor)
-{
-  return descriptor->plugin->compression_format;
-}
-
-
-int heif_encoder_descriptor_supports_lossy_compression(const struct heif_encoder_descriptor* descriptor)
-{
-  return descriptor->plugin->supports_lossy_compression;
-}
-
-
-int heif_encoder_descriptor_supports_lossless_compression(const struct heif_encoder_descriptor* descriptor)
-{
-  return descriptor->plugin->supports_lossless_compression;
-}
-
-
-// DEPRECATED: typo in functino name
-int heif_encoder_descriptor_supportes_lossy_compression(const struct heif_encoder_descriptor* descriptor)
-{
-  return descriptor->plugin->supports_lossy_compression;
-}
-
-
-// DEPRECATED: typo in functino name
-int heif_encoder_descriptor_supportes_lossless_compression(const struct heif_encoder_descriptor* descriptor)
-{
-  return descriptor->plugin->supports_lossless_compression;
-}
-
-
-const char* heif_encoder_get_name(const struct heif_encoder* encoder)
-{
-  return encoder->plugin->get_plugin_name();
-}
-
-
-struct heif_error heif_context_get_encoder(struct heif_context* context,
-                                           const struct heif_encoder_descriptor* descriptor,
-                                           struct heif_encoder** encoder)
-{
-  // Note: be aware that context may be NULL as we explicitly allowed that in an earlier documentation.
-
-  if (!descriptor || !encoder) {
-    Error err(heif_error_Usage_error,
-              heif_suberror_Null_pointer_argument);
-    return err.error_struct(context ? context->context.get() : nullptr);
-  }
-
-  *encoder = new struct heif_encoder(descriptor->plugin);
-  return (*encoder)->alloc();
-}
-
-
-int heif_have_decoder_for_format(enum heif_compression_format format)
-{
-  auto plugin = heif::get_decoder(format);
-  return plugin != nullptr;
-}
-
-
-int heif_have_encoder_for_format(enum heif_compression_format format)
-{
-  auto plugin = heif::get_encoder(format);
-  return plugin != nullptr;
-}
-
-
-struct heif_error heif_context_get_encoder_for_format(struct heif_context* context,
-                                                      enum heif_compression_format format,
-                                                      struct heif_encoder** encoder)
-{
-  // Note: be aware that context may be NULL as we explicitly allowed that in an earlier documentation.
-
-  if (!encoder) {
-    Error err(heif_error_Usage_error,
-              heif_suberror_Null_pointer_argument);
-    return err.error_struct(context ? context->context.get() : nullptr);
-  }
-
-  std::vector<const struct heif_encoder_descriptor*> descriptors;
-  descriptors = get_filtered_encoder_descriptors(format, nullptr);
-
-  if (descriptors.size() > 0) {
-    *encoder = new struct heif_encoder(descriptors[0]->plugin);
-    return (*encoder)->alloc();
-  }
-  else {
-    Error err(heif_error_Unsupported_filetype, // TODO: is this the right error code?
-              heif_suberror_Unspecified);
-    return err.error_struct(context ? context->context.get() : nullptr);
-  }
-}
-
-
-void heif_encoder_release(struct heif_encoder* encoder)
-{
-  if (encoder) {
-    delete encoder;
-  }
-}
-
-
-//struct heif_encoder_param* heif_encoder_get_param(struct heif_encoder* encoder)
-//{
-//  return nullptr;
-//}
-
-
-//void heif_encoder_release_param(struct heif_encoder_param* param)
-//{
-//}
-
-
-// Set a 'quality' factor (0-100). How this is mapped to actual encoding parameters is
-// encoder dependent.
-struct heif_error heif_encoder_set_lossy_quality(struct heif_encoder* encoder,
-                                                 int quality)
-{
-  if (!encoder) {
-    return Error(heif_error_Usage_error,
-                 heif_suberror_Null_pointer_argument).error_struct(nullptr);
-  }
-
-  return encoder->plugin->set_parameter_quality(encoder->encoder, quality);
-}
-
-
-struct heif_error heif_encoder_set_lossless(struct heif_encoder* encoder, int enable)
-{
-  if (!encoder) {
-    return Error(heif_error_Usage_error,
-                 heif_suberror_Null_pointer_argument).error_struct(nullptr);
-  }
-
-  return encoder->plugin->set_parameter_lossless(encoder->encoder, enable);
-}
-
-
-struct heif_error heif_encoder_set_logging_level(struct heif_encoder* encoder, int level)
-{
-  if (!encoder) {
-    return Error(heif_error_Usage_error,
-                 heif_suberror_Null_pointer_argument).error_struct(nullptr);
-  }
-
-  if (encoder->plugin->set_parameter_logging_level) {
-    return encoder->plugin->set_parameter_logging_level(encoder->encoder, level);
-  }
-
-  struct heif_error err = {heif_error_Ok, heif_suberror_Unspecified, kSuccess};
-  return err;
-}
-
-
-const struct heif_encoder_parameter* const* heif_encoder_list_parameters(struct heif_encoder* encoder)
-{
-  return encoder->plugin->list_parameters(encoder->encoder);
-}
-
-
-const char* heif_encoder_parameter_get_name(const struct heif_encoder_parameter* param)
-{
-  return param->name;
-}
-
-enum heif_encoder_parameter_type
-heif_encoder_parameter_get_type(const struct heif_encoder_parameter* param)
-{
-  return param->type;
-}
-
-
-struct heif_error heif_encoder_set_parameter_integer(struct heif_encoder* encoder,
-                                                     const char* parameter_name,
-                                                     int value)
-{
-  // --- check if parameter is valid
-
-  for (const struct heif_encoder_parameter* const* params = heif_encoder_list_parameters(encoder);
-       *params;
-       params++) {
-    if (strcmp((*params)->name, parameter_name) == 0) {
-
-      int have_minimum = 0, have_maximum = 0, minimum = 0, maximum = 0, num_valid_values = 0;
-      const int* valid_values = nullptr;
-      heif_error err = heif_encoder_parameter_get_valid_integer_values((*params), &have_minimum, &have_maximum,
-                                                                       &minimum, &maximum,
-                                                                       &num_valid_values,
-                                                                       &valid_values);
-      if (err.code) {
-        return err;
-      }
-
-      if ((have_minimum && value < minimum) ||
-          (have_maximum && value > maximum)) {
-        return error_invalid_parameter_value;
-      }
-
-      if (num_valid_values > 0) {
-        bool found = false;
-        for (int i = 0; i < num_valid_values; i++) {
-          if (valid_values[i] == value) {
-            found = true;
-            break;
-          }
-        }
-
-        if (!found) {
-          return error_invalid_parameter_value;
-        }
-      }
-    }
-  }
-
-
-  // --- parameter is ok, pass it to the encoder plugin
-
-  return encoder->plugin->set_parameter_integer(encoder->encoder, parameter_name, value);
-}
-
-struct heif_error heif_encoder_get_parameter_integer(struct heif_encoder* encoder,
-                                                     const char* parameter_name,
-                                                     int* value_ptr)
-{
-  return encoder->plugin->get_parameter_integer(encoder->encoder, parameter_name, value_ptr);
-}
-
-struct heif_error
-heif_encoder_parameter_get_valid_integer_range(const struct heif_encoder_parameter* param,
-                                               int* have_minimum_maximum,
-                                               int* minimum, int* maximum)
-{
-  if (param->type != heif_encoder_parameter_type_integer) {
-    return error_unsupported_parameter; // TODO: correct error ?
-  }
-
-  if (param->integer.have_minimum_maximum) {
-    if (minimum) {
-      *minimum = param->integer.minimum;
-    }
-
-    if (maximum) {
-      *maximum = param->integer.maximum;
-    }
-  }
-
-  if (have_minimum_maximum) {
-    *have_minimum_maximum = param->integer.have_minimum_maximum;
-  }
-
-  return error_Ok;
-}
-
-LIBHEIF_API
-struct heif_error heif_encoder_parameter_get_valid_integer_values(const struct heif_encoder_parameter* param,
-                                                                  int* have_minimum, int* have_maximum,
-                                                                  int* minimum, int* maximum,
-                                                                  int* num_valid_values,
-                                                                  const int** out_integer_array)
-{
-  if (param->type != heif_encoder_parameter_type_integer) {
-    return error_unsupported_parameter; // TODO: correct error ?
-  }
-
-
-  // --- range of values
-
-  if (param->integer.have_minimum_maximum) {
-    if (minimum) {
-      *minimum = param->integer.minimum;
-    }
-
-    if (maximum) {
-      *maximum = param->integer.maximum;
-    }
-  }
-
-  if (have_minimum) {
-    *have_minimum = param->integer.have_minimum_maximum;
-  }
-
-  if (have_maximum) {
-    *have_maximum = param->integer.have_minimum_maximum;
-  }
-
-
-  // --- set of valid values
-
-  if (param->integer.num_valid_values > 0) {
-    if (out_integer_array) {
-      *out_integer_array = param->integer.valid_values;
-    }
-  }
-
-  if (num_valid_values) {
-    *num_valid_values = param->integer.num_valid_values;
-  }
-
-  return error_Ok;
-}
-
-
-struct heif_error
-heif_encoder_parameter_get_valid_string_values(const struct heif_encoder_parameter* param,
-                                               const char* const** out_stringarray)
-{
-  if (param->type != heif_encoder_parameter_type_string) {
-    return error_unsupported_parameter; // TODO: correct error ?
-  }
-
-  if (out_stringarray) {
-    *out_stringarray = param->string.valid_values;
-  }
-
-  return error_Ok;
-}
-
-struct heif_error heif_encoder_parameter_integer_valid_range(struct heif_encoder* encoder,
-                                                             const char* parameter_name,
-                                                             int* have_minimum_maximum,
-                                                             int* minimum, int* maximum)
-{
-  for (const struct heif_encoder_parameter* const* params = heif_encoder_list_parameters(encoder);
-       *params;
-       params++) {
-    if (strcmp((*params)->name, parameter_name) == 0) {
-      return heif_encoder_parameter_get_valid_integer_range(*params, have_minimum_maximum,
-                                                            minimum, maximum);
-    }
-  }
-
-  return error_unsupported_parameter;
-}
-
-struct heif_error heif_encoder_set_parameter_boolean(struct heif_encoder* encoder,
-                                                     const char* parameter_name,
-                                                     int value)
-{
-  return encoder->plugin->set_parameter_boolean(encoder->encoder, parameter_name, value);
-}
-
-struct heif_error heif_encoder_get_parameter_boolean(struct heif_encoder* encoder,
-                                                     const char* parameter_name,
-                                                     int* value_ptr)
-{
-  return encoder->plugin->get_parameter_boolean(encoder->encoder, parameter_name, value_ptr);
-}
-
-struct heif_error heif_encoder_set_parameter_string(struct heif_encoder* encoder,
-                                                    const char* parameter_name,
-                                                    const char* value)
-{
-  return encoder->plugin->set_parameter_string(encoder->encoder, parameter_name, value);
-}
-
-struct heif_error heif_encoder_get_parameter_string(struct heif_encoder* encoder,
-                                                    const char* parameter_name,
-                                                    char* value_ptr, int value_size)
-{
-  return encoder->plugin->get_parameter_string(encoder->encoder, parameter_name,
-                                               value_ptr, value_size);
-}
-
-struct heif_error heif_encoder_parameter_string_valid_values(struct heif_encoder* encoder,
-                                                             const char* parameter_name,
-                                                             const char* const** out_stringarray)
-{
-  for (const struct heif_encoder_parameter* const* params = heif_encoder_list_parameters(encoder);
-       *params;
-       params++) {
-    if (strcmp((*params)->name, parameter_name) == 0) {
-      return heif_encoder_parameter_get_valid_string_values(*params, out_stringarray);
-    }
-  }
-
-  return error_unsupported_parameter;
-}
-
-struct heif_error heif_encoder_parameter_integer_valid_values(struct heif_encoder* encoder,
-                                                              const char* parameter_name,
-                                                              int* have_minimum, int* have_maximum,
-                                                              int* minimum, int* maximum,
-                                                              int* num_valid_values,
-                                                              const int** out_integer_array)
-{
-  for (const struct heif_encoder_parameter* const* params = heif_encoder_list_parameters(encoder);
-       *params;
-       params++) {
-    if (strcmp((*params)->name, parameter_name) == 0) {
-      return heif_encoder_parameter_get_valid_integer_values(*params, have_minimum, have_maximum, minimum, maximum,
-                                                             num_valid_values, out_integer_array);
-    }
-  }
-
-  return error_unsupported_parameter;
-}
-
-
-static bool parse_boolean(const char* value)
-{
-  if (strcmp(value, "true") == 0) {
-    return true;
-  }
-  else if (strcmp(value, "false") == 0) {
-    return false;
-  }
-  else if (strcmp(value, "1") == 0) {
-    return true;
-  }
-  else if (strcmp(value, "0") == 0) {
-    return false;
-  }
-
-  return false;
-}
-
-
-struct heif_error heif_encoder_set_parameter(struct heif_encoder* encoder,
-                                             const char* parameter_name,
-                                             const char* value)
-{
-  for (const struct heif_encoder_parameter* const* params = heif_encoder_list_parameters(encoder);
-       *params;
-       params++) {
-    if (strcmp((*params)->name, parameter_name) == 0) {
-      switch ((*params)->type) {
-        case heif_encoder_parameter_type_integer:
-          return heif_encoder_set_parameter_integer(encoder, parameter_name, atoi(value));
-
-        case heif_encoder_parameter_type_boolean:
-          return heif_encoder_set_parameter_boolean(encoder, parameter_name, parse_boolean(value));
-
-        case heif_encoder_parameter_type_string:
-          return heif_encoder_set_parameter_string(encoder, parameter_name, value);
-          break;
-      }
-
-      return error_Ok;
-    }
-  }
-
-  return heif_encoder_set_parameter_string(encoder, parameter_name, value);
-
-  //return error_unsupported_parameter;
-}
-
-
-struct heif_error heif_encoder_get_parameter(struct heif_encoder* encoder,
-                                             const char* parameter_name,
-                                             char* value_ptr, int value_size)
-{
-  for (const struct heif_encoder_parameter* const* params = heif_encoder_list_parameters(encoder);
-       *params;
-       params++) {
-    if (strcmp((*params)->name, parameter_name) == 0) {
-      switch ((*params)->type) {
-        case heif_encoder_parameter_type_integer: {
-          int value;
-          struct heif_error error = heif_encoder_get_parameter_integer(encoder, parameter_name, &value);
-          if (error.code) {
-            return error;
-          }
-          else {
-            snprintf(value_ptr, value_size, "%d", value);
-          }
-        }
-          break;
-
-        case heif_encoder_parameter_type_boolean: {
-          int value;
-          struct heif_error error = heif_encoder_get_parameter_boolean(encoder, parameter_name, &value);
-          if (error.code) {
-            return error;
-          }
-          else {
-            snprintf(value_ptr, value_size, "%d", value);
-          }
-        }
-          break;
-
-        case heif_encoder_parameter_type_string: {
-          struct heif_error error = heif_encoder_get_parameter_string(encoder, parameter_name,
-                                                                      value_ptr, value_size);
-          if (error.code) {
-            return error;
-          }
-        }
-          break;
-      }
-
-      return error_Ok;
-    }
-  }
-
-  return error_unsupported_parameter;
-}
-
-
-int heif_encoder_has_default(struct heif_encoder* encoder,
-                             const char* parameter_name)
-{
-  for (const struct heif_encoder_parameter* const* params = heif_encoder_list_parameters(encoder);
-       *params;
-       params++) {
-    if (strcmp((*params)->name, parameter_name) == 0) {
-
-      if ((*params)->version >= 2) {
-        return (*params)->has_default;
-      }
-      else {
-        return true;
-      }
-    }
-  }
-
-  return false;
-}
-
-
-static void set_default_options(heif_encoding_options& options)
-{
-  options.version = 4;
-
-  options.save_alpha_channel = true;
-  options.macOS_compatibility_workaround = true;
-  options.save_two_colr_boxes_when_ICC_and_nclx_available = false;
-  options.output_nclx_profile = nullptr;
-  options.macOS_compatibility_workaround_no_nclx_profile = true;
-}
-
-static void copy_options(heif_encoding_options& options, const heif_encoding_options& input_options)
-{
-  set_default_options(options);
-
-  switch (input_options.version) {
-    case 4:
-      options.output_nclx_profile = input_options.output_nclx_profile;
-      options.macOS_compatibility_workaround_no_nclx_profile = input_options.macOS_compatibility_workaround_no_nclx_profile;
-      // fallthrough
-    case 3:
-      options.save_two_colr_boxes_when_ICC_and_nclx_available = input_options.save_two_colr_boxes_when_ICC_and_nclx_available;
-      // fallthrough
-    case 2:
-      options.macOS_compatibility_workaround = input_options.macOS_compatibility_workaround;
-      // fallthrough
-    case 1:
-      options.save_alpha_channel = input_options.save_alpha_channel;
-  }
-}
-
-
-heif_encoding_options* heif_encoding_options_alloc()
-{
-  auto options = new heif_encoding_options;
-
-  set_default_options(*options);
-
-  return options;
-}
-
-
-void heif_encoding_options_free(heif_encoding_options* options)
-{
-  delete options;
-}
-
-struct heif_error heif_context_encode_image(struct heif_context* ctx,
-                                            const struct heif_image* input_image,
-                                            struct heif_encoder* encoder,
-                                            const struct heif_encoding_options* input_options,
-                                            struct heif_image_handle** out_image_handle)
-{
-  if (!encoder) {
-    return Error(heif_error_Usage_error,
-                 heif_suberror_Null_pointer_argument).error_struct(ctx->context.get());
-  }
-
-  heif_encoding_options options;
-  heif_color_profile_nclx nclx;
-  if (input_options == nullptr) {
-    set_default_options(options);
-  }
-  else {
-    copy_options(options, *input_options);
-
-    if (options.output_nclx_profile == nullptr) {
-      auto input_nclx = input_image->image->get_color_profile_nclx();
-      if (input_nclx) {
-        options.output_nclx_profile = &nclx;
-        nclx.version = 1;
-        nclx.color_primaries = (enum heif_color_primaries)input_nclx->get_colour_primaries();
-        nclx.transfer_characteristics = (enum heif_transfer_characteristics)input_nclx->get_transfer_characteristics();
-        nclx.matrix_coefficients = (enum heif_matrix_coefficients)input_nclx->get_matrix_coefficients();
-        nclx.full_range_flag = input_nclx->get_full_range_flag();
-      }
-    }
-  }
-
-  std::shared_ptr<HeifContext::Image> image;
-  Error error;
-
-
-  error = ctx->context->encode_image(input_image->image,
-                                     encoder,
-                                     &options,
-                                     heif_image_input_class_normal,
-                                     image);
-  if (error != Error::Ok) {
-    return error.error_struct(ctx->context.get());
-  }
-
-  // mark the new image as primary image
-
-  if (ctx->context->is_primary_image_set() == false) {
-    ctx->context->set_primary_image(image);
-  }
-
-  if (out_image_handle) {
-    *out_image_handle = new heif_image_handle;
-    (*out_image_handle)->image = image;
-    (*out_image_handle)->context = ctx->context;
-  }
-
-  return error_Ok;
-}
-
-
-struct heif_error heif_context_assign_thumbnail(struct heif_context* ctx,
-                                                const struct heif_image_handle* master_image,
-                                                const struct heif_image_handle* thumbnail_image)
-{
-  Error error = ctx->context->assign_thumbnail(thumbnail_image->image, master_image->image);
-  return error.error_struct(ctx->context.get());
-}
-
-
-struct heif_error heif_context_encode_thumbnail(struct heif_context* ctx,
-                                                const struct heif_image* image,
-                                                const struct heif_image_handle* image_handle,
-                                                struct heif_encoder* encoder,
-                                                const struct heif_encoding_options* options,
-                                                int bbox_size,
-                                                struct heif_image_handle** out_image_handle)
-{
-  std::shared_ptr<HeifContext::Image> thumbnail_image;
-
-  heif_encoding_options default_options;
-  if (options == nullptr) {
-    set_default_options(default_options);
-    options = &default_options;
-  }
-
-  Error error = ctx->context->encode_thumbnail(image->image,
-                                               encoder,
-                                               options,
-                                               bbox_size,
-                                               thumbnail_image);
-  if (error != Error::Ok) {
-    return error.error_struct(ctx->context.get());
-  }
-  else if (!thumbnail_image) {
-    Error err(heif_error_Usage_error,
-              heif_suberror_Invalid_parameter_value,
-              "Thumbnail images must be smaller than the original image.");
-    return err.error_struct(ctx->context.get());
-  }
-
-  error = ctx->context->assign_thumbnail(image_handle->image, thumbnail_image);
-  if (error != Error::Ok) {
-    return error.error_struct(ctx->context.get());
-  }
-
-
-  if (out_image_handle) {
-    if (thumbnail_image) {
-      *out_image_handle = new heif_image_handle;
-      (*out_image_handle)->image = thumbnail_image;
-      (*out_image_handle)->context = ctx->context;
-    }
-    else {
-      *out_image_handle = nullptr;
-    }
-  }
-
-  return error_Ok;
-}
-
-
-struct heif_error heif_context_set_primary_image(struct heif_context* ctx,
-                                                 struct heif_image_handle* image_handle)
-{
-  ctx->context->set_primary_image(image_handle->image);
-
-  return error_Ok;
-}
-
-
-struct heif_error heif_context_add_exif_metadata(struct heif_context* ctx,
-                                                 const struct heif_image_handle* image_handle,
-                                                 const void* data, int size)
-{
-  Error error = ctx->context->add_exif_metadata(image_handle->image, data, size);
-  if (error != Error::Ok) {
-    return error.error_struct(ctx->context.get());
-  }
-  else {
-    return error_Ok;
-  }
-}
-
-
-struct heif_error heif_context_add_XMP_metadata(struct heif_context* ctx,
-                                                const struct heif_image_handle* image_handle,
-                                                const void* data, int size)
-{
-  Error error = ctx->context->add_XMP_metadata(image_handle->image, data, size);
-  if (error != Error::Ok) {
-    return error.error_struct(ctx->context.get());
-  }
-  else {
-    return error_Ok;
-  }
-}
-
-
-struct heif_error heif_context_add_generic_metadata(struct heif_context* ctx,
-                                                    const struct heif_image_handle* image_handle,
-                                                    const void* data, int size,
-                                                    const char* item_type, const char* content_type)
-{
-  Error error = ctx->context->add_generic_metadata(image_handle->image, data, size,
-                                                   item_type, content_type);
-  if (error != Error::Ok) {
-    return error.error_struct(ctx->context.get());
-  }
-  else {
-    return error_Ok;
-  }
-}
-
-
-void heif_context_set_maximum_image_size_limit(struct heif_context* ctx, int maximum_width)
-{
-  ctx->context->set_maximum_image_size_limit(maximum_width);
-}
diff --git a/libheif/heif.h b/libheif/heif.h
deleted file mode 100644
index fffc98d156..0000000000
--- a/libheif/heif.h
+++ /dev/null
@@ -1,1449 +0,0 @@
-/*
- * HEIF codec.
- * Copyright (c) 2017 struktur AG, Dirk Farin <farin@struktur.de>
- *
- * This file is part of libheif.
- *
- * libheif is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as
- * published by the Free Software Foundation, either version 3 of
- * the License, or (at your option) any later version.
- *
- * libheif is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef LIBHEIF_HEIF_H
-#define LIBHEIF_HEIF_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <libheif/heif_version.h>
-
-
-// API versions table
-//
-// release    depth.rep   dec.options   enc.options   heif_reader   heif_writer  col.profile
-// -----------------------------------------------------------------------------------------
-//  1.0          1             1           N/A           N/A           N/A          N/A
-//  1.1          1             1           N/A           N/A            1           N/A
-//  1.3          1             1            1             1             1           N/A
-//  1.4          1             1            1             1             1            1
-//  1.7          1             2            1             1             1            1
-//  1.9.2        1             2            2             1             1            1
-//  1.10         1             2            3             1             1            1
-//  1.11         1             2            4             1             1            1
-
-
-#if defined(_MSC_VER) && !defined(LIBHEIF_STATIC_BUILD)
-#ifdef LIBHEIF_EXPORTS
-#define LIBHEIF_API __declspec(dllexport)
-#else
-#define LIBHEIF_API __declspec(dllimport)
-#endif
-#elif defined(HAVE_VISIBILITY) && HAVE_VISIBILITY
-#ifdef LIBHEIF_EXPORTS
-#define LIBHEIF_API __attribute__((__visibility__("default")))
-#else
-#define LIBHEIF_API
-#endif
-#else
-#define LIBHEIF_API
-#endif
-
-#define heif_fourcc(a, b, c, d) ((a<<24) | (b<<16) | (c<<8) | d)
-
-
-/* === version numbers === */
-
-// Version string of linked libheif library.
-LIBHEIF_API const char* heif_get_version(void);
-// Numeric version of linked libheif library, encoded as 0xHHMMLL00 = HH.MM.LL.
-LIBHEIF_API uint32_t heif_get_version_number(void);
-
-// Numeric part "HH" from above.
-LIBHEIF_API int heif_get_version_number_major(void);
-// Numeric part "MM" from above.
-LIBHEIF_API int heif_get_version_number_minor(void);
-// Numeric part "LL" from above.
-LIBHEIF_API int heif_get_version_number_maintenance(void);
-
-// Helper macros to check for given versions of libheif at compile time.
-#define LIBHEIF_MAKE_VERSION(h, m, l) ((h) << 24 | (m) << 16 | (l) << 8)
-#define LIBHEIF_HAVE_VERSION(h, m, l) (LIBHEIF_NUMERIC_VERSION >= LIBHEIF_MAKE_VERSION(h, m, l))
-
-struct heif_context;
-struct heif_image_handle;
-struct heif_image;
-
-
-enum heif_error_code
-{
-  // Everything ok, no error occurred.
-  heif_error_Ok = 0,
-
-  // Input file does not exist.
-  heif_error_Input_does_not_exist = 1,
-
-  // Error in input file. Corrupted or invalid content.
-  heif_error_Invalid_input = 2,
-
-  // Input file type is not supported.
-  heif_error_Unsupported_filetype = 3,
-
-  // Image requires an unsupported decoder feature.
-  heif_error_Unsupported_feature = 4,
-
-  // Library API has been used in an invalid way.
-  heif_error_Usage_error = 5,
-
-  // Could not allocate enough memory.
-  heif_error_Memory_allocation_error = 6,
-
-  // The decoder plugin generated an error
-  heif_error_Decoder_plugin_error = 7,
-
-  // The encoder plugin generated an error
-  heif_error_Encoder_plugin_error = 8,
-
-  // Error during encoding or when writing to the output
-  heif_error_Encoding_error = 9,
-
-  // Application has asked for a color profile type that does not exist
-  heif_error_Color_profile_does_not_exist = 10
-};
-
-
-enum heif_suberror_code
-{
-  // no further information available
-  heif_suberror_Unspecified = 0,
-
-  // --- Invalid_input ---
-
-  // End of data reached unexpectedly.
-  heif_suberror_End_of_data = 100,
-
-  // Size of box (defined in header) is wrong
-  heif_suberror_Invalid_box_size = 101,
-
-  // Mandatory 'ftyp' box is missing
-  heif_suberror_No_ftyp_box = 102,
-
-  heif_suberror_No_idat_box = 103,
-
-  heif_suberror_No_meta_box = 104,
-
-  heif_suberror_No_hdlr_box = 105,
-
-  heif_suberror_No_hvcC_box = 106,
-
-  heif_suberror_No_pitm_box = 107,
-
-  heif_suberror_No_ipco_box = 108,
-
-  heif_suberror_No_ipma_box = 109,
-
-  heif_suberror_No_iloc_box = 110,
-
-  heif_suberror_No_iinf_box = 111,
-
-  heif_suberror_No_iprp_box = 112,
-
-  heif_suberror_No_iref_box = 113,
-
-  heif_suberror_No_pict_handler = 114,
-
-  // An item property referenced in the 'ipma' box is not existing in the 'ipco' container.
-  heif_suberror_Ipma_box_references_nonexisting_property = 115,
-
-  // No properties have been assigned to an item.
-  heif_suberror_No_properties_assigned_to_item = 116,
-
-  // Image has no (compressed) data
-  heif_suberror_No_item_data = 117,
-
-  // Invalid specification of image grid (tiled image)
-  heif_suberror_Invalid_grid_data = 118,
-
-  // Tile-images in a grid image are missing
-  heif_suberror_Missing_grid_images = 119,
-
-  heif_suberror_Invalid_clean_aperture = 120,
-
-  // Invalid specification of overlay image
-  heif_suberror_Invalid_overlay_data = 121,
-
-  // Overlay image completely outside of visible canvas area
-  heif_suberror_Overlay_image_outside_of_canvas = 122,
-
-  heif_suberror_Auxiliary_image_type_unspecified = 123,
-
-  heif_suberror_No_or_invalid_primary_item = 124,
-
-  heif_suberror_No_infe_box = 125,
-
-  heif_suberror_Unknown_color_profile_type = 126,
-
-  heif_suberror_Wrong_tile_image_chroma_format = 127,
-
-  heif_suberror_Invalid_fractional_number = 128,
-
-  heif_suberror_Invalid_image_size = 129,
-
-  heif_suberror_Invalid_pixi_box = 130,
-
-  heif_suberror_No_av1C_box = 131,
-
-  heif_suberror_Wrong_tile_image_pixel_depth = 132,
-
-
-  // --- Memory_allocation_error ---
-
-  // A security limit preventing unreasonable memory allocations was exceeded by the input file.
-  // Please check whether the file is valid. If it is, contact us so that we could increase the
-  // security limits further.
-  heif_suberror_Security_limit_exceeded = 1000,
-
-
-  // --- Usage_error ---
-
-  // An item ID was used that is not present in the file.
-  heif_suberror_Nonexisting_item_referenced = 2000, // also used for Invalid_input
-
-  // An API argument was given a NULL pointer, which is not allowed for that function.
-  heif_suberror_Null_pointer_argument = 2001,
-
-  // Image channel referenced that does not exist in the image
-  heif_suberror_Nonexisting_image_channel_referenced = 2002,
-
-  // The version of the passed plugin is not supported.
-  heif_suberror_Unsupported_plugin_version = 2003,
-
-  // The version of the passed writer is not supported.
-  heif_suberror_Unsupported_writer_version = 2004,
-
-  // The given (encoder) parameter name does not exist.
-  heif_suberror_Unsupported_parameter = 2005,
-
-  // The value for the given parameter is not in the valid range.
-  heif_suberror_Invalid_parameter_value = 2006,
-
-
-  // --- Unsupported_feature ---
-
-  // Image was coded with an unsupported compression method.
-  heif_suberror_Unsupported_codec = 3000,
-
-  // Image is specified in an unknown way, e.g. as tiled grid image (which is supported)
-  heif_suberror_Unsupported_image_type = 3001,
-
-  heif_suberror_Unsupported_data_version = 3002,
-
-  // The conversion of the source image to the requested chroma / colorspace is not supported.
-  heif_suberror_Unsupported_color_conversion = 3003,
-
-  heif_suberror_Unsupported_item_construction_method = 3004,
-
-
-  // --- Encoder_plugin_error ---
-
-  heif_suberror_Unsupported_bit_depth = 4000,
-
-
-  // --- Encoding_error ---
-
-  heif_suberror_Cannot_write_output_data = 5000,
-};
-
-
-struct heif_error
-{
-  // main error category
-  enum heif_error_code code;
-
-  // more detailed error code
-  enum heif_suberror_code subcode;
-
-  // textual error message (is always defined, you do not have to check for NULL)
-  const char* message;
-};
-
-
-typedef uint32_t heif_item_id;
-
-
-
-// ========================= file type check ======================
-
-enum heif_filetype_result
-{
-  heif_filetype_no,
-  heif_filetype_yes_supported,   // it is heif and can be read by libheif
-  heif_filetype_yes_unsupported, // it is heif, but cannot be read by libheif
-  heif_filetype_maybe // not sure whether it is an heif, try detection with more input data
-};
-
-// input data should be at least 12 bytes
-LIBHEIF_API
-enum heif_filetype_result heif_check_filetype(const uint8_t* data, int len);
-
-
-// DEPRECATED, use heif_brand2 instead
-enum heif_brand
-{
-  heif_unknown_brand,
-  heif_heic, // the usual HEIF images
-  heif_heix, // 10bit images, or anything that uses h265 with range extension
-  heif_hevc, heif_hevx, // brands for image sequences
-  heif_heim, // multiview
-  heif_heis, // scalable
-  heif_hevm, // multiview sequence
-  heif_hevs, // scalable sequence
-  heif_mif1, // image, any coding algorithm
-  heif_msf1, // sequence, any coding algorithm
-  heif_avif,
-  heif_avis
-};
-
-// input data should be at least 12 bytes
-// DEPRECATED, use heif_read_main_brand() instead
-LIBHEIF_API
-enum heif_brand heif_main_brand(const uint8_t* data, int len);
-
-
-typedef uint32_t heif_brand2;
-
-// input data should be at least 12 bytes
-LIBHEIF_API
-heif_brand2 heif_read_main_brand(const uint8_t* data, int len);
-
-// 'brand_fourcc' must be 4 character long, but need not be 0-terminated
-LIBHEIF_API
-heif_brand2 heif_fourcc_to_brand(const char* brand_fourcc);
-
-// the output buffer must be at least 4 bytes long
-LIBHEIF_API
-void heif_brand_to_fourcc(heif_brand2 brand, char* out_fourcc);
-
-// 'brand_fourcc' must be 4 character long, but need not be 0-terminated
-// returns 1 if file includes the brand, and 0 if it does not
-// returns -1 if the provided data is not sufficient
-//            (you should input at least as many bytes as indicated in the first 4 bytes of the file, usually ~50 bytes will do)
-// returns -2 on other errors
-LIBHEIF_API
-int heif_has_compatible_brand(const uint8_t* data, int len, const char* brand_fourcc);
-
-// Returns an array of compatible brands. The array is allocated by this function and has to be freed with 'heif_free_list_of_compatible_brands()'.
-// The number of entries is returned in out_size.
-LIBHEIF_API
-struct heif_error heif_list_compatible_brands(const uint8_t* data, int len, heif_brand2** out_brands, int* out_size);
-
-LIBHEIF_API
-void heif_free_list_of_compatible_brands(heif_brand2* brands_list);
-
-
-// Returns one of these MIME types:
-// - image/heic           HEIF file using h265 compression
-// - image/heif           HEIF file using any other compression
-// - image/heic-sequence  HEIF image sequence using h265 compression
-// - image/heif-sequence  HEIF image sequence using any other compression
-// - image/jpeg    JPEG image
-// - image/png     PNG image
-// If the format could not be detected, an empty string is returned.
-//
-// Provide at least 12 bytes of input. With less input, its format might not
-// be detected. You may also provide more input to increase detection accuracy.
-//
-// Note that JPEG and PNG images cannot be decoded by libheif even though the
-// formats are detected by this function.
-LIBHEIF_API
-const char* heif_get_file_mime_type(const uint8_t* data, int len);
-
-
-
-// ========================= heif_context =========================
-// A heif_context represents a HEIF file that has been read.
-// In the future, you will also be able to add pictures to a heif_context
-// and write it into a file again.
-
-
-// Allocate a new context for reading HEIF files.
-// Has to be freed again with heif_context_free().
-LIBHEIF_API
-struct heif_context* heif_context_alloc(void);
-
-// Free a previously allocated HEIF context. You should not free a context twice.
-LIBHEIF_API
-void heif_context_free(struct heif_context*);
-
-
-struct heif_reading_options;
-
-enum heif_reader_grow_status
-{
-  heif_reader_grow_status_size_reached,   // requested size has been reached, we can read until this point
-  heif_reader_grow_status_timeout,        // size has not been reached yet, but it may still grow further
-  heif_reader_grow_status_size_beyond_eof // size has not been reached and never will. The file has grown to its full size
-};
-
-struct heif_reader
-{
-  // API version supported by this reader
-  int reader_api_version;
-
-  // --- version 1 functions ---
-  int64_t (* get_position)(void* userdata);
-
-  // The functions read(), and seek() return 0 on success.
-  // Generally, libheif will make sure that we do not read past the file size.
-  int (* read)(void* data,
-               size_t size,
-               void* userdata);
-
-  int (* seek)(int64_t position,
-               void* userdata);
-
-  // When calling this function, libheif wants to make sure that it can read the file
-  // up to 'target_size'. This is useful when the file is currently downloaded and may
-  // grow with time. You may, for example, extract the image sizes even before the actual
-  // compressed image data has been completely downloaded.
-  //
-  // Even if your input files will not grow, you will have to implement at least
-  // detection whether the target_size is above the (fixed) file length
-  // (in this case, return 'size_beyond_eof').
-  enum heif_reader_grow_status (* wait_for_file_size)(int64_t target_size, void* userdata);
-};
-
-
-// Read a HEIF file from a named disk file.
-// The heif_reading_options should currently be set to NULL.
-LIBHEIF_API
-struct heif_error heif_context_read_from_file(struct heif_context*, const char* filename,
-                                              const struct heif_reading_options*);
-
-// Read a HEIF file stored completely in memory.
-// The heif_reading_options should currently be set to NULL.
-// DEPRECATED: use heif_context_read_from_memory_without_copy() instead.
-LIBHEIF_API
-struct heif_error heif_context_read_from_memory(struct heif_context*,
-                                                const void* mem, size_t size,
-                                                const struct heif_reading_options*);
-
-// Same as heif_context_read_from_memory() except that the provided memory is not copied.
-// That means, you will have to keep the memory area alive as long as you use the heif_context.
-LIBHEIF_API
-struct heif_error heif_context_read_from_memory_without_copy(struct heif_context*,
-                                                             const void* mem, size_t size,
-                                                             const struct heif_reading_options*);
-
-LIBHEIF_API
-struct heif_error heif_context_read_from_reader(struct heif_context*,
-                                                const struct heif_reader* reader,
-                                                void* userdata,
-                                                const struct heif_reading_options*);
-
-// Number of top-level images in the HEIF file. This does not include the thumbnails or the
-// tile images that are composed to an image grid. You can get access to the thumbnails via
-// the main image handle.
-LIBHEIF_API
-int heif_context_get_number_of_top_level_images(struct heif_context* ctx);
-
-LIBHEIF_API
-int heif_context_is_top_level_image_ID(struct heif_context* ctx, heif_item_id id);
-
-// Fills in image IDs into the user-supplied int-array 'ID_array', preallocated with 'count' entries.
-// Function returns the total number of IDs filled into the array.
-LIBHEIF_API
-int heif_context_get_list_of_top_level_image_IDs(struct heif_context* ctx,
-                                                 heif_item_id* ID_array,
-                                                 int count);
-
-LIBHEIF_API
-struct heif_error heif_context_get_primary_image_ID(struct heif_context* ctx, heif_item_id* id);
-
-// Get a handle to the primary image of the HEIF file.
-// This is the image that should be displayed primarily when there are several images in the file.
-LIBHEIF_API
-struct heif_error heif_context_get_primary_image_handle(struct heif_context* ctx,
-                                                        struct heif_image_handle**);
-
-// Get the handle for a specific top-level image from an image ID.
-LIBHEIF_API
-struct heif_error heif_context_get_image_handle(struct heif_context* ctx,
-                                                heif_item_id id,
-                                                struct heif_image_handle**);
-
-// Print information about the boxes of a HEIF file to file descriptor.
-// This is for debugging and informational purposes only. You should not rely on
-// the output having a specific format. At best, you should not use this at all.
-LIBHEIF_API
-void heif_context_debug_dump_boxes_to_file(struct heif_context* ctx, int fd);
-
-
-LIBHEIF_API
-void heif_context_set_maximum_image_size_limit(struct heif_context* ctx, int maximum_width);
-
-
-// ========================= heif_image_handle =========================
-
-// An heif_image_handle is a handle to a logical image in the HEIF file.
-// To get the actual pixel data, you have to decode the handle to an heif_image.
-// An heif_image_handle also gives you access to the thumbnails and Exif data
-// associated with an image.
-
-// Once you obtained an heif_image_handle, you can already release the heif_context,
-// since it is internally ref-counted.
-
-// Release image handle.
-LIBHEIF_API
-void heif_image_handle_release(const struct heif_image_handle*);
-
-// Check whether the given image_handle is the primary image of the file.
-LIBHEIF_API
-int heif_image_handle_is_primary_image(const struct heif_image_handle* handle);
-
-// Get the resolution of an image.
-LIBHEIF_API
-int heif_image_handle_get_width(const struct heif_image_handle* handle);
-
-LIBHEIF_API
-int heif_image_handle_get_height(const struct heif_image_handle* handle);
-
-LIBHEIF_API
-int heif_image_handle_has_alpha_channel(const struct heif_image_handle*);
-
-LIBHEIF_API
-int heif_image_handle_is_premultiplied_alpha(const struct heif_image_handle*);
-
-// Returns -1 on error, e.g. if this information is not present in the image.
-LIBHEIF_API
-int heif_image_handle_get_luma_bits_per_pixel(const struct heif_image_handle*);
-
-// Returns -1 on error, e.g. if this information is not present in the image.
-LIBHEIF_API
-int heif_image_handle_get_chroma_bits_per_pixel(const struct heif_image_handle*);
-
-// Get the image width from the 'ispe' box. This is the original image size without
-// any transformations applied to it. Do not use this unless you know exactly what
-// you are doing.
-LIBHEIF_API
-int heif_image_handle_get_ispe_width(const struct heif_image_handle* handle);
-
-LIBHEIF_API
-int heif_image_handle_get_ispe_height(const struct heif_image_handle* handle);
-
-
-// ------------------------- depth images -------------------------
-
-LIBHEIF_API
-int heif_image_handle_has_depth_image(const struct heif_image_handle*);
-
-LIBHEIF_API
-int heif_image_handle_get_number_of_depth_images(const struct heif_image_handle* handle);
-
-LIBHEIF_API
-int heif_image_handle_get_list_of_depth_image_IDs(const struct heif_image_handle* handle,
-                                                  heif_item_id* ids, int count);
-
-LIBHEIF_API
-struct heif_error heif_image_handle_get_depth_image_handle(const struct heif_image_handle* handle,
-                                                           heif_item_id depth_image_id,
-                                                           struct heif_image_handle** out_depth_handle);
-
-
-enum heif_depth_representation_type
-{
-  heif_depth_representation_type_uniform_inverse_Z = 0,
-  heif_depth_representation_type_uniform_disparity = 1,
-  heif_depth_representation_type_uniform_Z = 2,
-  heif_depth_representation_type_nonuniform_disparity = 3
-};
-
-struct heif_depth_representation_info
-{
-  uint8_t version;
-
-  // version 1 fields
-
-  uint8_t has_z_near;
-  uint8_t has_z_far;
-  uint8_t has_d_min;
-  uint8_t has_d_max;
-
-  double z_near;
-  double z_far;
-  double d_min;
-  double d_max;
-
-  enum heif_depth_representation_type depth_representation_type;
-  uint32_t disparity_reference_view;
-
-  uint32_t depth_nonlinear_representation_model_size;
-  uint8_t* depth_nonlinear_representation_model;
-
-  // version 2 fields below
-};
-
-
-LIBHEIF_API
-void heif_depth_representation_info_free(const struct heif_depth_representation_info* info);
-
-// Returns true when there is depth_representation_info available
-// Note 1: depth_image_id is currently unused because we support only one depth channel per image, but
-// you should still provide the correct ID for future compatibility.
-// Note 2: Because of an API bug before v1.11.0, the function also works when 'handle' is the handle of the depth image.
-// However, you should pass the handle of the main image. Please adapt your code if needed.
-LIBHEIF_API
-int heif_image_handle_get_depth_image_representation_info(const struct heif_image_handle* handle,
-                                                          heif_item_id depth_image_id,
-                                                          const struct heif_depth_representation_info** out);
-
-
-
-// ------------------------- thumbnails -------------------------
-
-// List the number of thumbnails assigned to this image handle. Usually 0 or 1.
-LIBHEIF_API
-int heif_image_handle_get_number_of_thumbnails(const struct heif_image_handle* handle);
-
-LIBHEIF_API
-int heif_image_handle_get_list_of_thumbnail_IDs(const struct heif_image_handle* handle,
-                                                heif_item_id* ids, int count);
-
-// Get the image handle of a thumbnail image.
-LIBHEIF_API
-struct heif_error heif_image_handle_get_thumbnail(const struct heif_image_handle* main_image_handle,
-                                                  heif_item_id thumbnail_id,
-                                                  struct heif_image_handle** out_thumbnail_handle);
-
-
-// ------------------------- auxiliary images -------------------------
-
-#define LIBHEIF_AUX_IMAGE_FILTER_OMIT_ALPHA (1UL<<1)
-#define LIBHEIF_AUX_IMAGE_FILTER_OMIT_DEPTH (2UL<<1)
-
-// List the number of auxiliary images assigned to this image handle.
-LIBHEIF_API
-int heif_image_handle_get_number_of_auxiliary_images(const struct heif_image_handle* handle,
-                                                     int aux_filter);
-
-LIBHEIF_API
-int heif_image_handle_get_list_of_auxiliary_image_IDs(const struct heif_image_handle* handle,
-                                                      int aux_filter,
-                                                      heif_item_id* ids, int count);
-
-// You are responsible to deallocate the returned buffer with heif_image_handle_free_auxiliary_types().
-LIBHEIF_API
-struct heif_error heif_image_handle_get_auxiliary_type(const struct heif_image_handle* handle,
-                                                       const char** out_type);
-
-LIBHEIF_API
-void heif_image_handle_free_auxiliary_types(const struct heif_image_handle* handle,
-                                            const char** out_type);
-
-// Get the image handle of an auxiliary image.
-LIBHEIF_API
-struct heif_error heif_image_handle_get_auxiliary_image_handle(const struct heif_image_handle* main_image_handle,
-                                                               heif_item_id auxiliary_id,
-                                                               struct heif_image_handle** out_auxiliary_handle);
-
-
-// ------------------------- metadata (Exif / XMP) -------------------------
-
-// How many metadata blocks are attached to an image. Usually, the only metadata is
-// an "Exif" block.
-LIBHEIF_API
-int heif_image_handle_get_number_of_metadata_blocks(const struct heif_image_handle* handle,
-                                                    const char* type_filter);
-
-// 'type_filter' can be used to get only metadata of specific types, like "Exif".
-// If 'type_filter' is NULL, it will return all types of metadata IDs.
-LIBHEIF_API
-int heif_image_handle_get_list_of_metadata_block_IDs(const struct heif_image_handle* handle,
-                                                     const char* type_filter,
-                                                     heif_item_id* ids, int count);
-
-// Return a string indicating the type of the metadata, as specified in the HEIF file.
-// Exif data will have the type string "Exif".
-// This string will be valid until the next call to a libheif function.
-// You do not have to free this string.
-LIBHEIF_API
-const char* heif_image_handle_get_metadata_type(const struct heif_image_handle* handle,
-                                                heif_item_id metadata_id);
-
-LIBHEIF_API
-const char* heif_image_handle_get_metadata_content_type(const struct heif_image_handle* handle,
-                                                        heif_item_id metadata_id);
-
-// Get the size of the raw metadata, as stored in the HEIF file.
-LIBHEIF_API
-size_t heif_image_handle_get_metadata_size(const struct heif_image_handle* handle,
-                                           heif_item_id metadata_id);
-
-// 'out_data' must point to a memory area of the size reported by heif_image_handle_get_metadata_size().
-// The data is returned exactly as stored in the HEIF file.
-// For Exif data, you probably have to skip the first four bytes of the data, since they
-// indicate the offset to the start of the TIFF header of the Exif data.
-LIBHEIF_API
-struct heif_error heif_image_handle_get_metadata(const struct heif_image_handle* handle,
-                                                 heif_item_id metadata_id,
-                                                 void* out_data);
-
-enum heif_color_profile_type
-{
-  heif_color_profile_type_not_present = 0,
-  heif_color_profile_type_nclx = heif_fourcc('n', 'c', 'l', 'x'),
-  heif_color_profile_type_rICC = heif_fourcc('r', 'I', 'C', 'C'),
-  heif_color_profile_type_prof = heif_fourcc('p', 'r', 'o', 'f')
-};
-
-
-// Returns 'heif_color_profile_type_not_present' if there is no color profile.
-// If there is an ICC profile and an NCLX profile, the ICC profile is returned.
-// TODO: we need a new API for this function as images can contain both NCLX and ICC at the same time.
-//       However, you can still use heif_image_handle_get_raw_color_profile() and
-//       heif_image_handle_get_nclx_color_profile() to access both profiles.
-LIBHEIF_API
-enum heif_color_profile_type heif_image_handle_get_color_profile_type(const struct heif_image_handle* handle);
-
-LIBHEIF_API
-size_t heif_image_handle_get_raw_color_profile_size(const struct heif_image_handle* handle);
-
-// Returns 'heif_error_Color_profile_does_not_exist' when there is no ICC profile.
-LIBHEIF_API
-struct heif_error heif_image_handle_get_raw_color_profile(const struct heif_image_handle* handle,
-                                                          void* out_data);
-
-
-enum heif_color_primaries
-{
-  heif_color_primaries_ITU_R_BT_709_5 = 1, // g=0.3;0.6, b=0.15;0.06, r=0.64;0.33, w=0.3127,0.3290
-  heif_color_primaries_unspecified = 2,
-  heif_color_primaries_ITU_R_BT_470_6_System_M = 4,
-  heif_color_primaries_ITU_R_BT_470_6_System_B_G = 5,
-  heif_color_primaries_ITU_R_BT_601_6 = 6,
-  heif_color_primaries_SMPTE_240M = 7,
-  heif_color_primaries_generic_film = 8,
-  heif_color_primaries_ITU_R_BT_2020_2_and_2100_0 = 9,
-  heif_color_primaries_SMPTE_ST_428_1 = 10,
-  heif_color_primaries_SMPTE_RP_431_2 = 11,
-  heif_color_primaries_SMPTE_EG_432_1 = 12,
-  heif_color_primaries_EBU_Tech_3213_E = 22
-};
-
-enum heif_transfer_characteristics
-{
-  heif_transfer_characteristic_ITU_R_BT_709_5 = 1,
-  heif_transfer_characteristic_unspecified = 2,
-  heif_transfer_characteristic_ITU_R_BT_470_6_System_M = 4,
-  heif_transfer_characteristic_ITU_R_BT_470_6_System_B_G = 5,
-  heif_transfer_characteristic_ITU_R_BT_601_6 = 6,
-  heif_transfer_characteristic_SMPTE_240M = 7,
-  heif_transfer_characteristic_linear = 8,
-  heif_transfer_characteristic_logarithmic_100 = 9,
-  heif_transfer_characteristic_logarithmic_100_sqrt10 = 10,
-  heif_transfer_characteristic_IEC_61966_2_4 = 11,
-  heif_transfer_characteristic_ITU_R_BT_1361 = 12,
-  heif_transfer_characteristic_IEC_61966_2_1 = 13,
-  heif_transfer_characteristic_ITU_R_BT_2020_2_10bit = 14,
-  heif_transfer_characteristic_ITU_R_BT_2020_2_12bit = 15,
-  heif_transfer_characteristic_ITU_R_BT_2100_0_PQ = 16,
-  heif_transfer_characteristic_SMPTE_ST_428_1 = 17,
-  heif_transfer_characteristic_ITU_R_BT_2100_0_HLG = 18
-};
-
-enum heif_matrix_coefficients
-{
-  heif_matrix_coefficients_RGB_GBR = 0,
-  heif_matrix_coefficients_ITU_R_BT_709_5 = 1,  // TODO: or 709-6 according to h.273
-  heif_matrix_coefficients_unspecified = 2,
-  heif_matrix_coefficients_US_FCC_T47 = 4,
-  heif_matrix_coefficients_ITU_R_BT_470_6_System_B_G = 5,
-  heif_matrix_coefficients_ITU_R_BT_601_6 = 6,  // TODO: or 601-7 according to h.273
-  heif_matrix_coefficients_SMPTE_240M = 7,
-  heif_matrix_coefficients_YCgCo = 8,
-  heif_matrix_coefficients_ITU_R_BT_2020_2_non_constant_luminance = 9,
-  heif_matrix_coefficients_ITU_R_BT_2020_2_constant_luminance = 10,
-  heif_matrix_coefficients_SMPTE_ST_2085 = 11,
-  heif_matrix_coefficients_chromaticity_derived_non_constant_luminance = 12,
-  heif_matrix_coefficients_chromaticity_derived_constant_luminance = 13,
-  heif_matrix_coefficients_ICtCp = 14
-};
-
-struct heif_color_profile_nclx
-{
-  // === version 1 fields
-
-  uint8_t version;
-
-  enum heif_color_primaries color_primaries;
-  enum heif_transfer_characteristics transfer_characteristics;
-  enum heif_matrix_coefficients matrix_coefficients;
-  uint8_t full_range_flag;
-
-  // --- decoded values (not used when saving nclx)
-
-  float color_primary_red_x, color_primary_red_y;
-  float color_primary_green_x, color_primary_green_y;
-  float color_primary_blue_x, color_primary_blue_y;
-  float color_primary_white_x, color_primary_white_y;
-};
-
-// Returns 'heif_error_Color_profile_does_not_exist' when there is no NCLX profile.
-// TODO: This function does currently not return an NCLX profile if it is stored in the image bitstream.
-//       Only NCLX profiles stored as colr boxes are returned. This may change in the future.
-LIBHEIF_API
-struct heif_error heif_image_handle_get_nclx_color_profile(const struct heif_image_handle* handle,
-                                                           struct heif_color_profile_nclx** out_data);
-
-// Returned color profile has 'version' field set to the maximum allowed.
-// Do not fill values for higher versions as these might be outside the allocated structure size.
-// May return NULL.
-LIBHEIF_API
-struct heif_color_profile_nclx* heif_nclx_color_profile_alloc();
-
-LIBHEIF_API
-void heif_nclx_color_profile_free(struct heif_color_profile_nclx* nclx_profile);
-
-
-LIBHEIF_API
-enum heif_color_profile_type heif_image_get_color_profile_type(const struct heif_image* image);
-
-LIBHEIF_API
-size_t heif_image_get_raw_color_profile_size(const struct heif_image* image);
-
-LIBHEIF_API
-struct heif_error heif_image_get_raw_color_profile(const struct heif_image* image,
-                                                   void* out_data);
-
-LIBHEIF_API
-struct heif_error heif_image_get_nclx_color_profile(const struct heif_image* image,
-                                                    struct heif_color_profile_nclx** out_data);
-
-
-
-// ========================= heif_image =========================
-
-// An heif_image contains a decoded pixel image in various colorspaces, chroma formats,
-// and bit depths.
-
-// Note: when converting images to an interleaved chroma format, the resulting
-// image contains only a single channel of type channel_interleaved with, e.g., 3 bytes per pixel,
-// containing the interleaved R,G,B values.
-
-// Planar RGB images are specified as heif_colorspace_RGB / heif_chroma_444.
-
-enum heif_compression_format
-{
-  heif_compression_undefined = 0,
-  heif_compression_HEVC = 1,
-  heif_compression_AVC = 2,
-  heif_compression_JPEG = 3,
-  heif_compression_AV1 = 4
-};
-
-enum heif_chroma
-{
-  heif_chroma_undefined = 99,
-  heif_chroma_monochrome = 0,
-  heif_chroma_420 = 1,
-  heif_chroma_422 = 2,
-  heif_chroma_444 = 3,
-  heif_chroma_interleaved_RGB = 10,
-  heif_chroma_interleaved_RGBA = 11,
-  heif_chroma_interleaved_RRGGBB_BE = 12,
-  heif_chroma_interleaved_RRGGBBAA_BE = 13,
-  heif_chroma_interleaved_RRGGBB_LE = 14,
-  heif_chroma_interleaved_RRGGBBAA_LE = 15
-};
-
-// DEPRECATED ENUM NAMES
-#define heif_chroma_interleaved_24bit  heif_chroma_interleaved_RGB
-#define heif_chroma_interleaved_32bit  heif_chroma_interleaved_RGBA
-
-
-enum heif_colorspace
-{
-  heif_colorspace_undefined = 99,
-  heif_colorspace_YCbCr = 0,
-  heif_colorspace_RGB = 1,
-  heif_colorspace_monochrome = 2
-};
-
-enum heif_channel
-{
-  heif_channel_Y = 0,
-  heif_channel_Cb = 1,
-  heif_channel_Cr = 2,
-  heif_channel_R = 3,
-  heif_channel_G = 4,
-  heif_channel_B = 5,
-  heif_channel_Alpha = 6,
-  heif_channel_interleaved = 10
-};
-
-
-enum heif_progress_step
-{
-  heif_progress_step_total = 0,
-  heif_progress_step_load_tile = 1
-};
-
-
-struct heif_decoding_options
-{
-  uint8_t version;
-
-  // version 1 options
-
-  // Ignore geometric transformations like cropping, rotation, mirroring.
-  // Default: false (do not ignore).
-  uint8_t ignore_transformations;
-
-  void (* start_progress)(enum heif_progress_step step, int max_progress, void* progress_user_data);
-
-  void (* on_progress)(enum heif_progress_step step, int progress, void* progress_user_data);
-
-  void (* end_progress)(enum heif_progress_step step, void* progress_user_data);
-
-  void* progress_user_data;
-
-  // version 2 options
-
-  uint8_t convert_hdr_to_8bit;
-};
-
-
-// Allocate decoding options and fill with default values.
-// Note: you should always get the decoding options through this function since the
-// option structure may grow in size in future versions.
-LIBHEIF_API
-struct heif_decoding_options* heif_decoding_options_alloc();
-
-LIBHEIF_API
-void heif_decoding_options_free(struct heif_decoding_options*);
-
-// Decode an heif_image_handle into the actual pixel image and also carry out
-// all geometric transformations specified in the HEIF file (rotation, cropping, mirroring).
-//
-// If colorspace or chroma is set to heif_colorspace_undefined or heif_chroma_undefined,
-// respectively, the original colorspace is taken.
-// Decoding options may be NULL. If you want to supply options, always use
-// heif_decoding_options_alloc() to get the structure.
-LIBHEIF_API
-struct heif_error heif_decode_image(const struct heif_image_handle* in_handle,
-                                    struct heif_image** out_img,
-                                    enum heif_colorspace colorspace,
-                                    enum heif_chroma chroma,
-                                    const struct heif_decoding_options* options);
-
-// Get the colorspace format of the image.
-LIBHEIF_API
-enum heif_colorspace heif_image_get_colorspace(const struct heif_image*);
-
-// Get the chroma format of the image.
-LIBHEIF_API
-enum heif_chroma heif_image_get_chroma_format(const struct heif_image*);
-
-// Get width of the given image channel in pixels. Returns -1 if a non-existing
-// channel was given.
-LIBHEIF_API
-int heif_image_get_width(const struct heif_image*, enum heif_channel channel);
-
-// Get height of the given image channel in pixels. Returns -1 if a non-existing
-// channel was given.
-LIBHEIF_API
-int heif_image_get_height(const struct heif_image*, enum heif_channel channel);
-
-// Get the width of the main channel (Y in YCbCr, or any in RGB).
-LIBHEIF_API
-int heif_image_get_primary_width(const struct heif_image*);
-
-LIBHEIF_API
-int heif_image_get_primary_height(const struct heif_image*);
-
-LIBHEIF_API
-struct heif_error heif_image_crop(struct heif_image* img,
-                                  int left, int right, int top, int bottom);
-
-// Get the number of bits per pixel in the given image channel. Returns -1 if
-// a non-existing channel was given.
-// Note that the number of bits per pixel may be different for each color channel.
-// This function returns the number of bits used for storage of each pixel.
-// Especially for HDR images, this is probably not what you want. Have a look at
-// heif_image_get_bits_per_pixel_range() instead.
-LIBHEIF_API
-int heif_image_get_bits_per_pixel(const struct heif_image*, enum heif_channel channel);
-
-
-// Get the number of bits per pixel in the given image channel. This function returns
-// the number of bits used for representing the pixel value, which might be smaller
-// than the number of bits used in memory.
-// For example, in 12bit HDR images, this function returns '12', while still 16 bits
-// are reserved for storage. For interleaved RGBA with 12 bit, this function also returns
-// '12', not '48' or '64' (heif_image_get_bits_per_pixel returns 64 in this case).
-LIBHEIF_API
-int heif_image_get_bits_per_pixel_range(const struct heif_image*, enum heif_channel channel);
-
-LIBHEIF_API
-int heif_image_has_channel(const struct heif_image*, enum heif_channel channel);
-
-// Get a pointer to the actual pixel data.
-// The 'out_stride' is returned as "bytes per line".
-// When out_stride is NULL, no value will be written.
-// Returns NULL if a non-existing channel was given.
-LIBHEIF_API
-const uint8_t* heif_image_get_plane_readonly(const struct heif_image*,
-                                             enum heif_channel channel,
-                                             int* out_stride);
-
-LIBHEIF_API
-uint8_t* heif_image_get_plane(struct heif_image*,
-                              enum heif_channel channel,
-                              int* out_stride);
-
-
-struct heif_scaling_options;
-
-// Currently, heif_scaling_options is not defined yet. Pass a NULL pointer.
-LIBHEIF_API
-struct heif_error heif_image_scale_image(const struct heif_image* input,
-                                         struct heif_image** output,
-                                         int width, int height,
-                                         const struct heif_scaling_options* options);
-
-// The color profile is not attached to the image handle because we might need it
-// for color space transform and encoding.
-LIBHEIF_API
-struct heif_error heif_image_set_raw_color_profile(struct heif_image* image,
-                                                   const char* profile_type_fourcc_string,
-                                                   const void* profile_data,
-                                                   const size_t profile_size);
-
-LIBHEIF_API
-struct heif_error heif_image_set_nclx_color_profile(struct heif_image* image,
-                                                    const struct heif_color_profile_nclx* color_profile);
-
-
-// TODO: this function does not make any sense yet, since we currently cannot modify existing HEIF files.
-//LIBHEIF_API
-//void heif_image_remove_color_profile(struct heif_image* image);
-
-// Release heif_image.
-LIBHEIF_API
-void heif_image_release(const struct heif_image*);
-
-
-// ====================================================================================================
-//  Encoding API
-
-LIBHEIF_API
-struct heif_error heif_context_write_to_file(struct heif_context*,
-                                             const char* filename);
-
-struct heif_writer
-{
-  // API version supported by this writer
-  int writer_api_version;
-
-  // --- version 1 functions ---
-  struct heif_error (* write)(struct heif_context* ctx, // TODO: why do we need this parameter?
-                              const void* data,
-                              size_t size,
-                              void* userdata);
-};
-
-LIBHEIF_API
-struct heif_error heif_context_write(struct heif_context*,
-                                     struct heif_writer* writer,
-                                     void* userdata);
-
-
-// ----- encoder -----
-
-// The encoder used for actually encoding an image.
-struct heif_encoder;
-
-// A description of the encoder's capabilities and name.
-struct heif_encoder_descriptor;
-
-// A configuration parameter of the encoder. Each encoder implementation may have a different
-// set of parameters. For the most common settings (e.q. quality), special functions to set
-// the parameters are provided.
-struct heif_encoder_parameter;
-
-
-// Get a list of available encoders. You can filter the encoders by compression format and name.
-// Use format_filter==heif_compression_undefined and name_filter==NULL as wildcards.
-// The returned list of encoders is sorted by their priority (which is a plugin property).
-// Note: to get the actual encoder from the descriptors returned here, use heif_context_get_encoder().
-LIBHEIF_API
-int heif_context_get_encoder_descriptors(struct heif_context*, // TODO: why do we need this parameter?
-                                         enum heif_compression_format format_filter,
-                                         const char* name_filter,
-                                         const struct heif_encoder_descriptor** out_encoders,
-                                         int count);
-
-// Return a long, descriptive name of the encoder (including version information).
-LIBHEIF_API
-const char* heif_encoder_descriptor_get_name(const struct heif_encoder_descriptor*);
-
-// Return a short, symbolic name for identifying the encoder.
-// This name should stay constant over different encoder versions.
-LIBHEIF_API
-const char* heif_encoder_descriptor_get_id_name(const struct heif_encoder_descriptor*);
-
-LIBHEIF_API
-enum heif_compression_format
-heif_encoder_descriptor_get_compression_format(const struct heif_encoder_descriptor*);
-
-LIBHEIF_API
-int heif_encoder_descriptor_supports_lossy_compression(const struct heif_encoder_descriptor*);
-
-LIBHEIF_API
-int heif_encoder_descriptor_supports_lossless_compression(const struct heif_encoder_descriptor*);
-
-
-// Get an encoder instance that can be used to actually encode images from a descriptor.
-LIBHEIF_API
-struct heif_error heif_context_get_encoder(struct heif_context* context,
-                                           const struct heif_encoder_descriptor*,
-                                           struct heif_encoder** out_encoder);
-
-// Quick check whether there is a decoder available for the given format.
-// Note that the decoder still may not be able to decode all variants of that format.
-// You will have to query that further (todo) or just try to decode and check the returned error.
-LIBHEIF_API
-int heif_have_decoder_for_format(enum heif_compression_format format);
-
-// Quick check whether there is an enoder available for the given format.
-// Note that the encoder may be limited to a certain subset of features (e.g. only 8 bit, only lossy).
-// You will have to query the specific capabilities further.
-LIBHEIF_API
-int heif_have_encoder_for_format(enum heif_compression_format format);
-
-// Get an encoder for the given compression format. If there are several encoder plugins
-// for this format, the encoder with the highest plugin priority will be returned.
-LIBHEIF_API
-struct heif_error heif_context_get_encoder_for_format(struct heif_context* context,
-                                                      enum heif_compression_format format,
-                                                      struct heif_encoder**);
-
-// You have to release the encoder after use.
-LIBHEIF_API
-void heif_encoder_release(struct heif_encoder*);
-
-// Get the encoder name from the encoder itself.
-LIBHEIF_API
-const char* heif_encoder_get_name(const struct heif_encoder*);
-
-
-// --- Encoder Parameters ---
-
-// Libheif supports settings parameters through specialized functions and through
-// generic functions by parameter name. Sometimes, the same parameter can be set
-// in both ways.
-// We consider it best practice to use the generic parameter functions only in
-// dynamically generated user interfaces, as no guarantees are made that some specific
-// parameter names are supported by all plugins.
-
-
-// Set a 'quality' factor (0-100). How this is mapped to actual encoding parameters is
-// encoder dependent.
-LIBHEIF_API
-struct heif_error heif_encoder_set_lossy_quality(struct heif_encoder*, int quality);
-
-LIBHEIF_API
-struct heif_error heif_encoder_set_lossless(struct heif_encoder*, int enable);
-
-// level should be between 0 (= none) to 4 (= full)
-LIBHEIF_API
-struct heif_error heif_encoder_set_logging_level(struct heif_encoder*, int level);
-
-// Get a generic list of encoder parameters.
-// Each encoder may define its own, additional set of parameters.
-// You do not have to free the returned list.
-LIBHEIF_API
-const struct heif_encoder_parameter* const* heif_encoder_list_parameters(struct heif_encoder*);
-
-// Return the parameter name.
-LIBHEIF_API
-const char* heif_encoder_parameter_get_name(const struct heif_encoder_parameter*);
-
-
-enum heif_encoder_parameter_type
-{
-  heif_encoder_parameter_type_integer = 1,
-  heif_encoder_parameter_type_boolean = 2,
-  heif_encoder_parameter_type_string = 3
-};
-
-// Return the parameter type.
-LIBHEIF_API
-enum heif_encoder_parameter_type heif_encoder_parameter_get_type(const struct heif_encoder_parameter*);
-
-// DEPRECATED. Use heif_encoder_parameter_get_valid_integer_values() instead.
-LIBHEIF_API
-struct heif_error heif_encoder_parameter_get_valid_integer_range(const struct heif_encoder_parameter*,
-                                                                 int* have_minimum_maximum,
-                                                                 int* minimum, int* maximum);
-
-// If integer is limited by a range, have_minimum and/or have_maximum will be != 0 and *minimum, *maximum is set.
-// If integer is limited by a fixed set of values, *num_valid_values will be >0 and *out_integer_array is set.
-LIBHEIF_API
-struct heif_error heif_encoder_parameter_get_valid_integer_values(const struct heif_encoder_parameter*,
-                                                                  int* have_minimum, int* have_maximum,
-                                                                  int* minimum, int* maximum,
-                                                                  int* num_valid_values,
-                                                                  const int** out_integer_array);
-
-LIBHEIF_API
-struct heif_error heif_encoder_parameter_get_valid_string_values(const struct heif_encoder_parameter*,
-                                                                 const char* const** out_stringarray);
-
-
-LIBHEIF_API
-struct heif_error heif_encoder_set_parameter_integer(struct heif_encoder*,
-                                                     const char* parameter_name,
-                                                     int value);
-
-LIBHEIF_API
-struct heif_error heif_encoder_get_parameter_integer(struct heif_encoder*,
-                                                     const char* parameter_name,
-                                                     int* value);
-
-// TODO: name should be changed to heif_encoder_get_valid_integer_parameter_range
-LIBHEIF_API // DEPRECATED.
-struct heif_error heif_encoder_parameter_integer_valid_range(struct heif_encoder*,
-                                                             const char* parameter_name,
-                                                             int* have_minimum_maximum,
-                                                             int* minimum, int* maximum);
-
-LIBHEIF_API
-struct heif_error heif_encoder_set_parameter_boolean(struct heif_encoder*,
-                                                     const char* parameter_name,
-                                                     int value);
-
-LIBHEIF_API
-struct heif_error heif_encoder_get_parameter_boolean(struct heif_encoder*,
-                                                     const char* parameter_name,
-                                                     int* value);
-
-LIBHEIF_API
-struct heif_error heif_encoder_set_parameter_string(struct heif_encoder*,
-                                                    const char* parameter_name,
-                                                    const char* value);
-
-LIBHEIF_API
-struct heif_error heif_encoder_get_parameter_string(struct heif_encoder*,
-                                                    const char* parameter_name,
-                                                    char* value, int value_size);
-
-// returns a NULL-terminated list of valid strings or NULL if all values are allowed
-LIBHEIF_API
-struct heif_error heif_encoder_parameter_string_valid_values(struct heif_encoder*,
-                                                             const char* parameter_name,
-                                                             const char* const** out_stringarray);
-
-LIBHEIF_API
-struct heif_error heif_encoder_parameter_integer_valid_values(struct heif_encoder*,
-                                                              const char* parameter_name,
-                                                              int* have_minimum, int* have_maximum,
-                                                              int* minimum, int* maximum,
-                                                              int* num_valid_values,
-                                                              const int** out_integer_array);
-
-// Set a parameter of any type to the string value.
-// Integer values are parsed from the string.
-// Boolean values can be "true"/"false"/"1"/"0"
-//
-// x265 encoder specific note:
-// When using the x265 encoder, you may pass any of its parameters by
-// prefixing the parameter name with 'x265:'. Hence, to set the 'ctu' parameter,
-// you will have to set 'x265:ctu' in libheif.
-// Note that there is no checking for valid parameters when using the prefix.
-LIBHEIF_API
-struct heif_error heif_encoder_set_parameter(struct heif_encoder*,
-                                             const char* parameter_name,
-                                             const char* value);
-
-// Get the current value of a parameter of any type as a human readable string.
-// The returned string is compatible with heif_encoder_set_parameter().
-LIBHEIF_API
-struct heif_error heif_encoder_get_parameter(struct heif_encoder*,
-                                             const char* parameter_name,
-                                             char* value_ptr, int value_size);
-
-// Query whether a specific parameter has a default value.
-LIBHEIF_API
-int heif_encoder_has_default(struct heif_encoder*,
-                             const char* parameter_name);
-
-
-struct heif_encoding_options
-{
-  uint8_t version;
-
-  // version 1 options
-
-  uint8_t save_alpha_channel; // default: true
-
-  // version 2 options
-
-  // Crops heif images with a grid wrapper instead of a 'clap' transform.
-  // Results in slightly larger file size.
-  // Default: on.
-  uint8_t macOS_compatibility_workaround;
-
-  // version 3 options
-
-  uint8_t save_two_colr_boxes_when_ICC_and_nclx_available; // default: false
-
-  // version 4 options
-
-  // Set this to the NCLX parameters to be used in the output image or set to NULL
-  // when the same parameters as in the input image should be used.
-  struct heif_color_profile_nclx* output_nclx_profile;
-
-  uint8_t macOS_compatibility_workaround_no_nclx_profile;
-};
-
-LIBHEIF_API
-struct heif_encoding_options* heif_encoding_options_alloc();
-
-LIBHEIF_API
-void heif_encoding_options_free(struct heif_encoding_options*);
-
-
-// Compress the input image.
-// Returns a handle to the coded image in 'out_image_handle' unless out_image_handle = NULL.
-// 'options' should be NULL for now.
-// The first image added to the context is also automatically set the primary image, but
-// you can change the primary image later with heif_context_set_primary_image().
-LIBHEIF_API
-struct heif_error heif_context_encode_image(struct heif_context*,
-                                            const struct heif_image* image,
-                                            struct heif_encoder* encoder,
-                                            const struct heif_encoding_options* options,
-                                            struct heif_image_handle** out_image_handle);
-
-LIBHEIF_API
-struct heif_error heif_context_set_primary_image(struct heif_context*,
-                                                 struct heif_image_handle* image_handle);
-
-// Encode the 'image' as a scaled down thumbnail image.
-// The image is scaled down to fit into a square area of width 'bbox_size'.
-// If the input image is already so small that it fits into this bounding box, no thumbnail
-// image is encoded and NULL is returned in 'out_thumb_image_handle'.
-// No error is returned in this case.
-// The encoded thumbnail is automatically assigned to the 'master_image_handle'. Hence, you
-// do not have to call heif_context_assign_thumbnail().
-LIBHEIF_API
-struct heif_error heif_context_encode_thumbnail(struct heif_context*,
-                                                const struct heif_image* image,
-                                                const struct heif_image_handle* master_image_handle,
-                                                struct heif_encoder* encoder,
-                                                const struct heif_encoding_options* options,
-                                                int bbox_size,
-                                                struct heif_image_handle** out_thumb_image_handle);
-
-// Assign 'thumbnail_image' as the thumbnail image of 'master_image'.
-LIBHEIF_API
-struct heif_error heif_context_assign_thumbnail(struct heif_context*,
-                                                const struct heif_image_handle* master_image,
-                                                const struct heif_image_handle* thumbnail_image);
-
-// Add EXIF metadata to an image.
-LIBHEIF_API
-struct heif_error heif_context_add_exif_metadata(struct heif_context*,
-                                                 const struct heif_image_handle* image_handle,
-                                                 const void* data, int size);
-
-// Add XMP metadata to an image.
-LIBHEIF_API
-struct heif_error heif_context_add_XMP_metadata(struct heif_context*,
-                                                const struct heif_image_handle* image_handle,
-                                                const void* data, int size);
-
-// Add generic, proprietary metadata to an image. You have to specify an 'item_type' that will
-// identify your metadata. 'content_type' can be an additional type, or it can be NULL.
-// For example, this function can be used to add IPTC metadata (IIM stream, not XMP) to an image.
-// Even not standard, we propose to store IPTC data with item type="iptc", content_type=NULL.
-LIBHEIF_API
-struct heif_error heif_context_add_generic_metadata(struct heif_context* ctx,
-                                                    const struct heif_image_handle* image_handle,
-                                                    const void* data, int size,
-                                                    const char* item_type, const char* content_type);
-
-// --- heif_image allocation
-
-// Create a new image of the specified resolution and colorspace.
-// Note: no memory for the actual image data is reserved yet. You have to use
-// heif_image_add_plane() to add the image planes required by your colorspace/chroma.
-LIBHEIF_API
-struct heif_error heif_image_create(int width, int height,
-                                    enum heif_colorspace colorspace,
-                                    enum heif_chroma chroma,
-                                    struct heif_image** out_image);
-
-// The indicated bit_depth corresponds to the bit depth per channel.
-// I.e. for interleaved formats like RRGGBB, the bit_depth would be, e.g., 10 bit instead
-// of 30 bits or 3*16=48 bits.
-// For backward compatibility, one can also specify 24bits for RGB and 32bits for RGBA,
-// instead of the preferred 8 bits.
-LIBHEIF_API
-struct heif_error heif_image_add_plane(struct heif_image* image,
-                                       enum heif_channel channel,
-                                       int width, int height, int bit_depth);
-
-// Signal that the image is premultiplied by the alpha pixel values.
-LIBHEIF_API
-void heif_image_set_premultiplied_alpha(struct heif_image* image,
-                                        int is_premultiplied_alpha);
-
-LIBHEIF_API
-int heif_image_is_premultiplied_alpha(struct heif_image* image);
-
-
-
-// --- register plugins
-
-struct heif_decoder_plugin;
-struct heif_encoder_plugin;
-
-// DEPRECATED. Use heif_register_decoder_plugin(const struct heif_decoder_plugin*) instead.
-LIBHEIF_API
-struct heif_error heif_register_decoder(struct heif_context* heif, const struct heif_decoder_plugin*);
-
-LIBHEIF_API
-struct heif_error heif_register_decoder_plugin(const struct heif_decoder_plugin*);
-
-LIBHEIF_API
-struct heif_error heif_register_encoder_plugin(const struct heif_encoder_plugin*);
-
-
-
-// DEPRECATED, typo in function name
-LIBHEIF_API
-int heif_encoder_descriptor_supportes_lossy_compression(const struct heif_encoder_descriptor*);
-
-// DEPRECATED, typo in function name
-LIBHEIF_API
-int heif_encoder_descriptor_supportes_lossless_compression(const struct heif_encoder_descriptor*);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/libheif/heif_api_structs.h b/libheif/heif_api_structs.h
deleted file mode 100644
index 2714177237..0000000000
--- a/libheif/heif_api_structs.h
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
- * HEIF codec.
- * Copyright (c) 2017 struktur AG, Dirk Farin <farin@struktur.de>
- *
- * This file is part of libheif.
- *
- * libheif is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as
- * published by the Free Software Foundation, either version 3 of
- * the License, or (at your option) any later version.
- *
- * libheif is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef HEIF_API_STRUCTS_H
-#define HEIF_API_STRUCTS_H
-
-#include "heif_image.h"
-#include "heif_context.h"
-
-#include <memory>
-
-struct heif_image_handle
-{
-  std::shared_ptr<heif::HeifContext::Image> image;
-
-  // store reference to keep the context alive while we are using the handle (issue #147)
-  std::shared_ptr<heif::HeifContext> context;
-};
-
-
-struct heif_image
-{
-  std::shared_ptr<heif::HeifPixelImage> image;
-};
-
-
-struct heif_context
-{
-  std::shared_ptr<heif::HeifContext> context;
-};
-
-
-struct heif_encoder
-{
-  heif_encoder(const struct heif_encoder_plugin* plugin);
-
-  ~heif_encoder();
-
-  struct heif_error alloc();
-
-  void release();
-
-
-  const struct heif_encoder_plugin* plugin;
-  void* encoder = nullptr;
-};
-
-
-#endif
diff --git a/libheif/heif_colorconversion.cc b/libheif/heif_colorconversion.cc
deleted file mode 100644
index f85bcccbe0..0000000000
--- a/libheif/heif_colorconversion.cc
+++ /dev/null
@@ -1,3316 +0,0 @@
-/*
- * HEIF codec.
- * Copyright (c) 2017 struktur AG, Dirk Farin <farin@struktur.de>
- *
- * This file is part of libheif.
- *
- * libheif is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as
- * published by the Free Software Foundation, either version 3 of
- * the License, or (at your option) any later version.
- *
- * libheif is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-
-#include "heif_colorconversion.h"
-#include "nclx.h"
-#include <typeinfo>
-#include <algorithm>
-#include <cstring>
-#include <cassert>
-#include <iostream>
-#include <set>
-#include <cmath>
-
-using namespace heif;
-
-#define DEBUG_ME 0
-#define DEBUG_PIPELINE_CREATION 0
-
-#define USE_CENTER_CHROMA_422 0
-
-
-std::ostream& operator<<(std::ostream& ostr, heif_colorspace c)
-{
-  switch (c) {
-    case heif_colorspace_RGB:
-      ostr << "RGB";
-      break;
-    case heif_colorspace_YCbCr:
-      ostr << "YCbCr";
-      break;
-    case heif_colorspace_monochrome:
-      ostr << "mono";
-      break;
-    case heif_colorspace_undefined:
-      ostr << "undefined";
-      break;
-    default:
-      assert(false);
-  }
-
-  return ostr;
-}
-
-std::ostream& operator<<(std::ostream& ostr, heif_chroma c)
-{
-  switch (c) {
-    case heif_chroma_420:
-      ostr << "420";
-      break;
-    case heif_chroma_422:
-      ostr << "422";
-      break;
-    case heif_chroma_444:
-      ostr << "444";
-      break;
-    case heif_chroma_monochrome:
-      ostr << "mono";
-      break;
-    case heif_chroma_interleaved_RGB:
-      ostr << "RGB";
-      break;
-    case heif_chroma_interleaved_RGBA:
-      ostr << "RGBA";
-      break;
-    case heif_chroma_interleaved_RRGGBB_BE:
-      ostr << "RRGGBB_BE";
-      break;
-    case heif_chroma_interleaved_RRGGBB_LE:
-      ostr << "RRGGBBB_LE";
-      break;
-    case heif_chroma_interleaved_RRGGBBAA_BE:
-      ostr << "RRGGBBAA_BE";
-      break;
-    case heif_chroma_interleaved_RRGGBBAA_LE:
-      ostr << "RRGGBBBAA_LE";
-      break;
-    case heif_chroma_undefined:
-      ostr << "undefined";
-      break;
-    default:
-      assert(false);
-  }
-
-  return ostr;
-}
-
-#if DEBUG_ME
-
-static void __attribute__ ((unused)) print_spec(std::ostream& ostr, const std::shared_ptr<HeifPixelImage>& img)
-{
-  ostr << "colorspace=" << img->get_colorspace()
-       << " chroma=" << img->get_chroma_format();
-
-  if (img->get_colorspace() == heif_colorspace_RGB) {
-    if (img->get_chroma_format() == heif_chroma_444) {
-      ostr << " bpp(R)=" << ((int) img->get_bits_per_pixel(heif_channel_R));
-    }
-    else {
-      ostr << " bpp(interleaved)=" << ((int) img->get_bits_per_pixel(heif_channel_interleaved));
-    }
-  }
-  else if (img->get_colorspace() == heif_colorspace_YCbCr ||
-           img->get_colorspace() == heif_colorspace_monochrome) {
-    ostr << " bpp(Y)=" << ((int) img->get_bits_per_pixel(heif_channel_Y));
-  }
-
-  ostr << "\n";
-}
-
-
-static void __attribute__ ((unused)) print_state(std::ostream& ostr, const ColorState& state)
-{
-  ostr << "colorspace=" << state.colorspace
-       << " chroma=" << state.chroma;
-
-  ostr << " bpp(R)=" << state.bits_per_pixel;
-  ostr << " alpha=" << (state.has_alpha ? "yes" : "no");
-  ostr << " nclx=" << (state.nclx_profile ? "yes" : "no");
-  ostr << "\n";
-}
-
-#endif
-
-
-bool ColorState::operator==(const ColorState& b) const
-{
-  return (colorspace == b.colorspace &&
-          chroma == b.chroma &&
-          has_alpha == b.has_alpha &&
-          bits_per_pixel == b.bits_per_pixel);
-}
-
-
-class Op_RGB_to_RGB24_32 : public ColorConversionOperation
-{
-public:
-  std::vector<ColorStateWithCost>
-  state_after_conversion(ColorState input_state,
-                         ColorState target_state,
-                         ColorConversionOptions options) override;
-
-  std::shared_ptr<HeifPixelImage>
-  convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
-                     ColorState target_state,
-                     ColorConversionOptions options) override;
-};
-
-
-std::vector<ColorStateWithCost>
-Op_RGB_to_RGB24_32::state_after_conversion(ColorState input_state,
-                                           ColorState target_state,
-                                           ColorConversionOptions options)
-{
-  if (input_state.colorspace != heif_colorspace_RGB ||
-      input_state.chroma != heif_chroma_444 ||
-      input_state.bits_per_pixel != 8) {
-    return {};
-  }
-
-  std::vector<ColorStateWithCost> states;
-
-  ColorState output_state;
-  ColorConversionCosts costs;
-
-  // --- convert to RGBA (with alpha)
-
-  output_state.colorspace = heif_colorspace_RGB;
-  output_state.chroma = heif_chroma_interleaved_RGBA;
-  output_state.has_alpha = true;
-  output_state.bits_per_pixel = 8;
-
-  if (input_state.has_alpha == false &&
-      target_state.has_alpha == false) {
-    costs = ColorConversionCosts(0.1f, 0.0f, 0.25f);
-  }
-  else {
-    costs = ColorConversionCosts(0.1f, 0.0f, 0.0f);
-  }
-
-  states.push_back({output_state, costs});
-
-
-  // --- convert to RGB (without alpha)
-
-  output_state.colorspace = heif_colorspace_RGB;
-  output_state.chroma = heif_chroma_interleaved_RGB;
-  output_state.has_alpha = false;
-  output_state.bits_per_pixel = 8;
-
-  if (input_state.has_alpha == true &&
-      target_state.has_alpha == true) {
-    // do not use this conversion because we would lose the alpha channel
-  }
-  else {
-    costs = ColorConversionCosts(0.2f, 0.0f, 0.0f);
-  }
-
-  states.push_back({output_state, costs});
-
-  return states;
-}
-
-
-std::shared_ptr<HeifPixelImage>
-Op_RGB_to_RGB24_32::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
-                                       ColorState target_state,
-                                       ColorConversionOptions options)
-{
-  bool has_alpha = input->has_channel(heif_channel_Alpha);
-  bool want_alpha = target_state.has_alpha;
-
-  if (input->get_bits_per_pixel(heif_channel_R) != 8 ||
-      input->get_bits_per_pixel(heif_channel_G) != 8 ||
-      input->get_bits_per_pixel(heif_channel_B) != 8) {
-    return nullptr;
-  }
-
-  if (has_alpha && input->get_bits_per_pixel(heif_channel_Alpha) != 8) {
-    return nullptr;
-  }
-
-  auto outimg = std::make_shared<HeifPixelImage>();
-
-  int width = input->get_width();
-  int height = input->get_height();
-
-  outimg->create(width, height, heif_colorspace_RGB,
-                 want_alpha ? heif_chroma_interleaved_32bit : heif_chroma_interleaved_24bit);
-
-  outimg->add_plane(heif_channel_interleaved, width, height, 8);
-
-  const uint8_t* in_r, * in_g, * in_b, * in_a = nullptr;
-  int in_r_stride = 0, in_g_stride = 0, in_b_stride = 0, in_a_stride = 0;
-
-  uint8_t* out_p;
-  int out_p_stride = 0;
-
-  in_r = input->get_plane(heif_channel_R, &in_r_stride);
-  in_g = input->get_plane(heif_channel_G, &in_g_stride);
-  in_b = input->get_plane(heif_channel_B, &in_b_stride);
-  out_p = outimg->get_plane(heif_channel_interleaved, &out_p_stride);
-
-  if (has_alpha) {
-    in_a = input->get_plane(heif_channel_Alpha, &in_a_stride);
-  }
-
-  int x, y;
-  for (y = 0; y < height; y++) {
-
-    if (has_alpha && want_alpha) {
-      for (x = 0; x < width; x++) {
-        out_p[y * out_p_stride + 4 * x + 0] = in_r[x + y * in_r_stride];
-        out_p[y * out_p_stride + 4 * x + 1] = in_g[x + y * in_g_stride];
-        out_p[y * out_p_stride + 4 * x + 2] = in_b[x + y * in_b_stride];
-        out_p[y * out_p_stride + 4 * x + 3] = in_a[x + y * in_a_stride];
-      }
-    }
-    else if (!want_alpha) {
-      for (x = 0; x < width; x++) {
-        out_p[y * out_p_stride + 3 * x + 0] = in_r[x + y * in_r_stride];
-        out_p[y * out_p_stride + 3 * x + 1] = in_g[x + y * in_g_stride];
-        out_p[y * out_p_stride + 3 * x + 2] = in_b[x + y * in_b_stride];
-      }
-    }
-    else {
-      assert(want_alpha && !has_alpha);
-
-      for (x = 0; x < width; x++) {
-        out_p[y * out_p_stride + 4 * x + 0] = in_r[x + y * in_r_stride];
-        out_p[y * out_p_stride + 4 * x + 1] = in_g[x + y * in_g_stride];
-        out_p[y * out_p_stride + 4 * x + 2] = in_b[x + y * in_b_stride];
-        out_p[y * out_p_stride + 4 * x + 3] = 0xFF;
-      }
-    }
-  }
-
-  return outimg;
-}
-
-
-static inline uint8_t clip_int_u8(int x)
-{
-  if (x < 0) return 0;
-  if (x > 255) return 255;
-  return static_cast<uint8_t>(x);
-}
-
-
-static inline uint16_t clip_f_u16(float fx, int32_t maxi)
-{
-  long x = lroundf(fx);
-  if (x < 0) return 0;
-  if (x > maxi) return (uint16_t) maxi;
-  return static_cast<uint16_t>(x);
-}
-
-
-template<class Pixel>
-class Op_YCbCr_to_RGB : public ColorConversionOperation
-{
-public:
-  std::vector<ColorStateWithCost>
-  state_after_conversion(ColorState input_state,
-                         ColorState target_state,
-                         ColorConversionOptions options) override;
-
-  std::shared_ptr<HeifPixelImage>
-  convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
-                     ColorState target_state,
-                     ColorConversionOptions options) override;
-};
-
-
-template<class Pixel>
-std::vector<ColorStateWithCost>
-Op_YCbCr_to_RGB<Pixel>::state_after_conversion(ColorState input_state,
-                                               ColorState target_state,
-                                               ColorConversionOptions options)
-{
-  bool hdr = !std::is_same<Pixel, uint8_t>::value;
-
-  if ((input_state.bits_per_pixel != 8) != hdr) {
-    return {};
-  }
-
-  if (input_state.colorspace != heif_colorspace_YCbCr) {
-    return {};
-  }
-
-  std::vector<ColorStateWithCost> states;
-
-  ColorState output_state;
-  ColorConversionCosts costs;
-
-  // --- convert to RGB
-
-  output_state.colorspace = heif_colorspace_RGB;
-  output_state.chroma = heif_chroma_444;
-  output_state.has_alpha = input_state.has_alpha;  // we simply keep the old alpha plane
-  output_state.bits_per_pixel = input_state.bits_per_pixel;
-
-  costs = {0.5f, 0.0f, 0.0f};
-
-  states.push_back({output_state, costs});
-
-  return states;
-}
-
-
-template<class Pixel>
-std::shared_ptr<HeifPixelImage>
-Op_YCbCr_to_RGB<Pixel>::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
-                                           ColorState target_state,
-                                           ColorConversionOptions options)
-{
-  bool hdr = !std::is_same<Pixel, uint8_t>::value;
-
-  heif_chroma chroma = input->get_chroma_format();
-
-  int bpp_y = input->get_bits_per_pixel(heif_channel_Y);
-  int bpp_cb = input->get_bits_per_pixel(heif_channel_Cb);
-  int bpp_cr = input->get_bits_per_pixel(heif_channel_Cr);
-  int bpp_a = 0;
-
-  bool has_alpha = input->has_channel(heif_channel_Alpha);
-
-  if (has_alpha) {
-    bpp_a = input->get_bits_per_pixel(heif_channel_Alpha);
-  }
-
-  if (!hdr) {
-    if (bpp_y != 8 ||
-        bpp_cb != 8 ||
-        bpp_cr != 8) {
-      return nullptr;
-    }
-  }
-  else {
-    if (bpp_y == 8 ||
-        bpp_cb == 8 ||
-        bpp_cr == 8) {
-      return nullptr;
-    }
-  }
-
-
-  if (bpp_y != bpp_cb ||
-      bpp_y != bpp_cr) {
-    // TODO: test with varying bit depths when we have a test image
-    return nullptr;
-  }
-
-
-  auto colorProfile = input->get_color_profile_nclx();
-
-  int width = input->get_width();
-  int height = input->get_height();
-
-  auto outimg = std::make_shared<HeifPixelImage>();
-
-  outimg->create(width, height, heif_colorspace_RGB, heif_chroma_444);
-
-  outimg->add_plane(heif_channel_R, width, height, bpp_y);
-  outimg->add_plane(heif_channel_G, width, height, bpp_y);
-  outimg->add_plane(heif_channel_B, width, height, bpp_y);
-
-  if (has_alpha) {
-    outimg->add_plane(heif_channel_Alpha, width, height, bpp_a);
-  }
-
-  const Pixel* in_y, * in_cb, * in_cr, * in_a;
-  int in_y_stride = 0, in_cb_stride = 0, in_cr_stride = 0, in_a_stride = 0;
-
-  Pixel* out_r, * out_g, * out_b, * out_a;
-  int out_r_stride = 0, out_g_stride = 0, out_b_stride = 0, out_a_stride = 0;
-
-  in_y = (const Pixel*) input->get_plane(heif_channel_Y, &in_y_stride);
-  in_cb = (const Pixel*) input->get_plane(heif_channel_Cb, &in_cb_stride);
-  in_cr = (const Pixel*) input->get_plane(heif_channel_Cr, &in_cr_stride);
-  out_r = (Pixel*) outimg->get_plane(heif_channel_R, &out_r_stride);
-  out_g = (Pixel*) outimg->get_plane(heif_channel_G, &out_g_stride);
-  out_b = (Pixel*) outimg->get_plane(heif_channel_B, &out_b_stride);
-
-  if (has_alpha) {
-    in_a = (const Pixel*) input->get_plane(heif_channel_Alpha, &in_a_stride);
-    out_a = (Pixel*) outimg->get_plane(heif_channel_Alpha, &out_a_stride);
-  }
-  else {
-    in_a = nullptr;
-    out_a = nullptr;
-  }
-
-
-  uint16_t halfRange = (uint16_t) (1 << (bpp_y - 1));
-  int32_t fullRange = (1 << bpp_y) - 1;
-
-  int shiftH = chroma_h_subsampling(chroma) - 1;
-  int shiftV = chroma_v_subsampling(chroma) - 1;
-
-  if (hdr) {
-    in_y_stride /= 2;
-    in_cb_stride /= 2;
-    in_cr_stride /= 2;
-    in_a_stride /= 2;
-    out_r_stride /= 2;
-    out_g_stride /= 2;
-    out_b_stride /= 2;
-    out_a_stride /= 2;
-  }
-
-  int matrix_coeffs = 2;
-  bool full_range_flag = true;
-  YCbCr_to_RGB_coefficients coeffs = YCbCr_to_RGB_coefficients::defaults();
-  if (colorProfile) {
-    matrix_coeffs = colorProfile->get_matrix_coefficients();
-    full_range_flag = colorProfile->get_full_range_flag();
-    coeffs = heif::get_YCbCr_to_RGB_coefficients(colorProfile->get_matrix_coefficients(),
-                                                 colorProfile->get_colour_primaries());
-  }
-
-
-  int x, y;
-  for (y = 0; y < height; y++) {
-    for (x = 0; x < width; x++) {
-      int cx = (x >> shiftH);
-      int cy = (y >> shiftV);
-
-      if (matrix_coeffs == 0) {
-        if (full_range_flag) {
-          out_r[y * out_r_stride + x] = in_cr[cy * in_cr_stride + cx];
-          out_g[y * out_g_stride + x] = in_y[y * in_y_stride + x];
-          out_b[y * out_b_stride + x] = in_cb[cy * in_cb_stride + cx];
-        }
-        else {
-          out_r[y * out_r_stride + x] = Pixel(((in_cr[cy * in_cr_stride + cx] * 219 + 128) >> 8) + 16);
-          out_g[y * out_g_stride + x] = Pixel(((in_y[y * in_y_stride + x] * 219 + 128) >> 8) + 16);
-          out_b[y * out_b_stride + x] = Pixel(((in_cb[cy * in_cb_stride + cx] * 219 + 128) >> 8) + 16);
-        }
-      }
-      else if (matrix_coeffs == 8) {
-        // TODO: check this. I have no input image yet which is known to be correct.
-        // TODO: is there a coeff=8 with full_range=false ?
-
-        int yv = in_y[y * in_y_stride + x];
-        int cb = in_cb[cy * in_cb_stride + cx] - halfRange;
-        int cr = in_cr[cy * in_cr_stride + cx] - halfRange;
-
-        out_r[y * out_r_stride + x] = (Pixel) (clip_int_u8(yv - cb + cr));
-        out_g[y * out_g_stride + x] = (Pixel) (clip_int_u8(yv + cb));
-        out_b[y * out_b_stride + x] = (Pixel) (clip_int_u8(yv - cb - cr));
-      }
-      else { // TODO: matrix_coefficients = 10,11,13,14
-        float yv, cb, cr;
-        yv = static_cast<float>(in_y[y * in_y_stride + x] );
-        cb = static_cast<float>(in_cb[cy * in_cb_stride + cx] - halfRange);
-        cr = static_cast<float>(in_cr[cy * in_cr_stride + cx] - halfRange);
-
-        if (!full_range_flag) {
-          yv = (yv - 16) * 1.1689f;
-          cb = cb * 1.1429f;
-          cr = cr * 1.1429f;
-        }
-
-        out_r[y * out_r_stride + x] = (Pixel) (clip_f_u16(yv + coeffs.r_cr * cr, fullRange));
-        out_g[y * out_g_stride + x] = (Pixel) (clip_f_u16(yv + coeffs.g_cb * cb + coeffs.g_cr * cr, fullRange));
-        out_b[y * out_b_stride + x] = (Pixel) (clip_f_u16(yv + coeffs.b_cb * cb, fullRange));
-      }
-    }
-
-    if (has_alpha) {
-      memcpy(&out_a[y * out_a_stride], &in_a[y * in_a_stride], width * 2);
-    }
-  }
-
-  return outimg;
-}
-
-
-template<class Pixel>
-class Op_RGB_to_YCbCr : public ColorConversionOperation
-{
-public:
-  std::vector<ColorStateWithCost>
-  state_after_conversion(ColorState input_state,
-                         ColorState target_state,
-                         ColorConversionOptions options) override;
-
-  std::shared_ptr<HeifPixelImage>
-  convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
-                     ColorState target_state,
-                     ColorConversionOptions options) override;
-};
-
-
-template<class Pixel>
-std::vector<ColorStateWithCost>
-Op_RGB_to_YCbCr<Pixel>::state_after_conversion(ColorState input_state,
-                                               ColorState target_state,
-                                               ColorConversionOptions options)
-{
-  bool hdr = !std::is_same<Pixel, uint8_t>::value;
-
-  if ((input_state.bits_per_pixel != 8) != hdr) {
-    return {};
-  }
-
-  if (input_state.colorspace != heif_colorspace_RGB ||
-      input_state.chroma != heif_chroma_444) {
-    return {};
-  }
-
-  std::vector<ColorStateWithCost> states;
-
-  ColorState output_state;
-  ColorConversionCosts costs;
-
-  // --- convert to YCbCr
-
-  output_state.colorspace = heif_colorspace_YCbCr;
-  output_state.chroma = target_state.chroma;
-  output_state.has_alpha = input_state.has_alpha;  // we simply keep the old alpha plane
-  output_state.bits_per_pixel = input_state.bits_per_pixel;
-
-  costs = {0.75f, 0.5f, 0.0f};
-
-  states.push_back({output_state, costs});
-
-  return states;
-}
-
-
-template<class Pixel>
-std::shared_ptr<HeifPixelImage>
-Op_RGB_to_YCbCr<Pixel>::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
-                                           ColorState target_state,
-                                           ColorConversionOptions options)
-{
-  bool hdr = !std::is_same<Pixel, uint8_t>::value;
-
-  int width = input->get_width();
-  int height = input->get_height();
-
-  heif_chroma chroma = target_state.chroma;
-  int subH = chroma_h_subsampling(chroma);
-  int subV = chroma_v_subsampling(chroma);
-
-  int bpp = input->get_bits_per_pixel(heif_channel_R);
-  if ((bpp != 8) != hdr) {
-    return nullptr;
-  }
-
-  bool has_alpha = input->has_channel(heif_channel_Alpha);
-
-  if (has_alpha && input->get_bits_per_pixel(heif_channel_Alpha) != bpp) {
-    return nullptr;
-  }
-
-  auto outimg = std::make_shared<HeifPixelImage>();
-
-  outimg->create(width, height, heif_colorspace_YCbCr, chroma);
-
-  int cwidth = (width + subH - 1) / subH;
-  int cheight = (height + subV - 1) / subV;
-
-  outimg->add_plane(heif_channel_Y, width, height, bpp);
-  outimg->add_plane(heif_channel_Cb, cwidth, cheight, bpp);
-  outimg->add_plane(heif_channel_Cr, cwidth, cheight, bpp);
-
-  if (has_alpha) {
-    outimg->add_plane(heif_channel_Alpha, width, height, bpp);
-  }
-
-  const Pixel* in_r, * in_g, * in_b, * in_a;
-  int in_r_stride = 0, in_g_stride = 0, in_b_stride = 0, in_a_stride = 0;
-
-  Pixel* out_y, * out_cb, * out_cr, * out_a;
-  int out_y_stride = 0, out_cb_stride = 0, out_cr_stride = 0, out_a_stride = 0;
-
-  in_r = (const Pixel*) input->get_plane(heif_channel_R, &in_r_stride);
-  in_g = (const Pixel*) input->get_plane(heif_channel_G, &in_g_stride);
-  in_b = (const Pixel*) input->get_plane(heif_channel_B, &in_b_stride);
-  out_y = (Pixel*) outimg->get_plane(heif_channel_Y, &out_y_stride);
-  out_cb = (Pixel*) outimg->get_plane(heif_channel_Cb, &out_cb_stride);
-  out_cr = (Pixel*) outimg->get_plane(heif_channel_Cr, &out_cr_stride);
-
-  if (has_alpha) {
-    in_a = (const Pixel*) input->get_plane(heif_channel_Alpha, &in_a_stride);
-    out_a = (Pixel*) outimg->get_plane(heif_channel_Alpha, &out_a_stride);
-  }
-  else {
-    in_a = nullptr;
-    out_a = nullptr;
-  }
-
-  if (hdr) {
-    in_r_stride /= 2;
-    in_g_stride /= 2;
-    in_b_stride /= 2;
-    in_a_stride /= 2;
-    out_y_stride /= 2;
-    out_cb_stride /= 2;
-    out_cr_stride /= 2;
-    out_a_stride /= 2;
-  }
-
-  uint16_t halfRange = (uint16_t) (1 << (bpp - 1));
-  int32_t fullRange = (1 << bpp) - 1;
-
-  int matrix_coeffs = 2;
-  RGB_to_YCbCr_coefficients coeffs = RGB_to_YCbCr_coefficients::defaults();
-  bool full_range_flag = true;
-  if (target_state.nclx_profile) {
-    full_range_flag = target_state.nclx_profile->get_full_range_flag();
-    matrix_coeffs = target_state.nclx_profile->get_matrix_coefficients();
-    coeffs = heif::get_RGB_to_YCbCr_coefficients(target_state.nclx_profile->get_matrix_coefficients(),
-                                                 target_state.nclx_profile->get_colour_primaries());
-  }
-
-  int x, y;
-
-  for (y = 0; y < height; y++) {
-    for (x = 0; x < width; x++) {
-      if (matrix_coeffs == 0) {
-        if (full_range_flag) {
-          out_y[y * out_y_stride + x] = in_g[y * in_g_stride + x];
-        }
-        else {
-          float v = (((in_g[y * in_g_stride + x] * 219.0f) / 256) + 16);
-          out_y[y * out_y_stride + x] = (Pixel) clip_f_u16(v, fullRange);
-        }
-      }
-      else {
-        float r = in_r[y * in_r_stride + x];
-        float g = in_g[y * in_g_stride + x];
-        float b = in_b[y * in_b_stride + x];
-
-        float v = r * coeffs.c[0][0] + g * coeffs.c[0][1] + b * coeffs.c[0][2];
-        if (!full_range_flag) {
-          v = (((v * 219) / 256) + 16);
-        }
-
-        Pixel pix = (Pixel) clip_f_u16(v, fullRange);
-
-        out_y[y * out_y_stride + x] = pix;
-      }
-    }
-  }
-
-  for (y = 0; y < height; y += subV) {
-    for (x = 0; x < width; x += subH) {
-      if (matrix_coeffs == 0) {
-        if (full_range_flag) {
-          out_cb[(y / subV) * out_cb_stride + (x / subH)] = in_b[y * in_b_stride + x];
-          out_cr[(y / subV) * out_cb_stride + (x / subH)] = in_r[y * in_b_stride + x];
-        }
-        else {
-          out_cb[(y / subV) * out_cb_stride + (x / subH)] = (Pixel) clip_f_u16(
-              ((in_b[y * in_b_stride + x] * 219.0f) / 256) + 16, fullRange);
-          out_cr[(y / subV) * out_cb_stride + (x / subH)] = (Pixel) clip_f_u16(
-              ((in_r[y * in_b_stride + x] * 219.0f) / 256) + 16, fullRange);
-        }
-      }
-      else {
-        float r = in_r[y * in_r_stride + x];
-        float g = in_g[y * in_g_stride + x];
-        float b = in_b[y * in_b_stride + x];
-
-        if (subH > 1 || subV > 1) {
-          int x2 = (x + 1 < width && subH == 2 && subV == 2) ? x + 1 : x;  // subV==2 -> Do not center for 4:2:2 (see comment in Op_RGB24_32_to_YCbCr, github issue #521)
-          int y2 = (y + 1 < height && subV == 2) ? y + 1 : y;
-
-          r += in_r[y * in_r_stride + x2];
-          g += in_g[y * in_g_stride + x2];
-          b += in_b[y * in_b_stride + x2];
-
-          r += in_r[y2 * in_r_stride + x];
-          g += in_g[y2 * in_g_stride + x];
-          b += in_b[y2 * in_b_stride + x];
-
-          r += in_r[y2 * in_r_stride + x2];
-          g += in_g[y2 * in_g_stride + x2];
-          b += in_b[y2 * in_b_stride + x2];
-
-          r *= 0.25f;
-          g *= 0.25f;
-          b *= 0.25f;
-        }
-
-        float cb, cr;
-
-        cb = r * coeffs.c[1][0] + g * coeffs.c[1][1] + b * coeffs.c[1][2];
-        cr = r * coeffs.c[2][0] + g * coeffs.c[2][1] + b * coeffs.c[2][2];
-
-        if (!full_range_flag) {
-          cb = (cb * 224) / 256;
-          cr = (cr * 224) / 256;
-        }
-
-        out_cb[(y / subV) * out_cb_stride + (x / subH)] = (Pixel) clip_f_u16(cb + halfRange, fullRange);
-        out_cr[(y / subV) * out_cr_stride + (x / subH)] = (Pixel) clip_f_u16(cr + halfRange, fullRange);
-      }
-    }
-  }
-
-
-  if (has_alpha) {
-    int copyWidth = (hdr ? width * 2 : width);
-    for (y = 0; y < height; y++) {
-      memcpy(&out_a[y * out_a_stride], &in_a[y * in_a_stride], copyWidth);
-    }
-  }
-
-  return outimg;
-}
-
-
-class Op_YCbCr420_to_RGB24 : public ColorConversionOperation
-{
-public:
-  std::vector<ColorStateWithCost>
-  state_after_conversion(ColorState input_state,
-                         ColorState target_state,
-                         ColorConversionOptions options) override;
-
-  std::shared_ptr<HeifPixelImage>
-  convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
-                     ColorState target_state,
-                     ColorConversionOptions options) override;
-};
-
-
-std::vector<ColorStateWithCost>
-Op_YCbCr420_to_RGB24::state_after_conversion(ColorState input_state,
-                                             ColorState target_state,
-                                             ColorConversionOptions options)
-{
-  if (input_state.colorspace != heif_colorspace_YCbCr ||
-      input_state.chroma != heif_chroma_420 ||
-      input_state.bits_per_pixel != 8 ||
-      input_state.has_alpha == true) {
-    return {};
-  }
-
-  if (input_state.nclx_profile) {
-    int matrix = input_state.nclx_profile->get_matrix_coefficients();
-    if (matrix == 0 || matrix == 8 || matrix == 11 || matrix == 14) {
-      return {};
-    }
-    if (!input_state.nclx_profile->get_full_range_flag()) {
-      return {};
-    }
-  }
-
-  std::vector<ColorStateWithCost> states;
-
-  ColorState output_state;
-  ColorConversionCosts costs;
-
-  // --- convert to RGB
-
-  output_state.colorspace = heif_colorspace_RGB;
-  output_state.chroma = heif_chroma_interleaved_RGB;
-  output_state.has_alpha = false;
-  output_state.bits_per_pixel = 8;
-
-  costs = {0.5f, 0.0f, 0.0f};
-
-  states.push_back({output_state, costs});
-
-  return states;
-}
-
-
-std::shared_ptr<HeifPixelImage>
-Op_YCbCr420_to_RGB24::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
-                                         ColorState target_state,
-                                         ColorConversionOptions options)
-{
-  if (input->get_bits_per_pixel(heif_channel_Y) != 8 ||
-      input->get_bits_per_pixel(heif_channel_Cb) != 8 ||
-      input->get_bits_per_pixel(heif_channel_Cr) != 8) {
-    return nullptr;
-  }
-
-  auto outimg = std::make_shared<HeifPixelImage>();
-
-  int width = input->get_width();
-  int height = input->get_height();
-
-  outimg->create(width, height, heif_colorspace_RGB, heif_chroma_interleaved_24bit);
-
-  outimg->add_plane(heif_channel_interleaved, width, height, 8);
-
-  auto colorProfile = input->get_color_profile_nclx();
-  YCbCr_to_RGB_coefficients coeffs = YCbCr_to_RGB_coefficients::defaults();
-  if (colorProfile) {
-    coeffs = heif::get_YCbCr_to_RGB_coefficients(colorProfile->get_matrix_coefficients(),
-                                                 colorProfile->get_colour_primaries());
-  }
-
-  int r_cr = static_cast<int>(lround(256 * coeffs.r_cr));
-  int g_cr = static_cast<int>(lround(256 * coeffs.g_cr));
-  int g_cb = static_cast<int>(lround(256 * coeffs.g_cb));
-  int b_cb = static_cast<int>(lround(256 * coeffs.b_cb));
-
-  const uint8_t* in_y, * in_cb, * in_cr;
-  int in_y_stride = 0, in_cb_stride = 0, in_cr_stride = 0;
-
-  uint8_t* out_p;
-  int out_p_stride = 0;
-
-  in_y = input->get_plane(heif_channel_Y, &in_y_stride);
-  in_cb = input->get_plane(heif_channel_Cb, &in_cb_stride);
-  in_cr = input->get_plane(heif_channel_Cr, &in_cr_stride);
-  out_p = outimg->get_plane(heif_channel_interleaved, &out_p_stride);
-
-  int x, y;
-  for (y = 0; y < height; y++) {
-    for (x = 0; x < width; x++) {
-      int yv = (in_y[y * in_y_stride + x]);
-      int cb = (in_cb[y / 2 * in_cb_stride + x / 2] - 128);
-      int cr = (in_cr[y / 2 * in_cr_stride + x / 2] - 128);
-
-      out_p[y * out_p_stride + 3 * x + 0] = clip_int_u8(yv + ((r_cr * cr + 128) >> 8));
-      out_p[y * out_p_stride + 3 * x + 1] = clip_int_u8(yv + ((g_cb * cb + g_cr * cr + 128) >> 8));
-      out_p[y * out_p_stride + 3 * x + 2] = clip_int_u8(yv + ((b_cb * cb + 128) >> 8));
-    }
-  }
-
-  return outimg;
-}
-
-
-class Op_YCbCr420_to_RGB32 : public ColorConversionOperation
-{
-public:
-  std::vector<ColorStateWithCost>
-  state_after_conversion(ColorState input_state,
-                         ColorState target_state,
-                         ColorConversionOptions options) override;
-
-  std::shared_ptr<HeifPixelImage>
-  convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
-                     ColorState target_state,
-                     ColorConversionOptions options) override;
-};
-
-
-std::vector<ColorStateWithCost>
-Op_YCbCr420_to_RGB32::state_after_conversion(ColorState input_state,
-                                             ColorState target_state,
-                                             ColorConversionOptions options)
-{
-  // Note: no input alpha channel required. It will be filled up with 0xFF.
-
-  if (input_state.colorspace != heif_colorspace_YCbCr ||
-      input_state.chroma != heif_chroma_420 ||
-      input_state.bits_per_pixel != 8) {
-    return {};
-  }
-
-  if (input_state.nclx_profile) {
-    int matrix = input_state.nclx_profile->get_matrix_coefficients();
-    if (matrix == 0 || matrix == 8 || matrix == 11 || matrix == 14) {
-      return {};
-    }
-    if (!input_state.nclx_profile->get_full_range_flag()) {
-      return {};
-    }
-  }
-
-  std::vector<ColorStateWithCost> states;
-
-  ColorState output_state;
-  ColorConversionCosts costs;
-
-  // --- convert to RGB
-
-  output_state.colorspace = heif_colorspace_RGB;
-  output_state.chroma = heif_chroma_interleaved_RGBA;
-  output_state.has_alpha = true;
-  output_state.bits_per_pixel = 8;
-
-  costs = {0.5f, 0.0f, 0.0f};
-
-  states.push_back({output_state, costs});
-
-  return states;
-}
-
-
-std::shared_ptr<HeifPixelImage>
-Op_YCbCr420_to_RGB32::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
-                                         ColorState target_state,
-                                         ColorConversionOptions options)
-{
-  if (input->get_bits_per_pixel(heif_channel_Y) != 8 ||
-      input->get_bits_per_pixel(heif_channel_Cb) != 8 ||
-      input->get_bits_per_pixel(heif_channel_Cr) != 8) {
-    return nullptr;
-  }
-
-  auto outimg = std::make_shared<HeifPixelImage>();
-
-  int width = input->get_width();
-  int height = input->get_height();
-
-  outimg->create(width, height, heif_colorspace_RGB, heif_chroma_interleaved_32bit);
-
-  outimg->add_plane(heif_channel_interleaved, width, height, 8);
-
-
-  // --- get conversion coefficients
-
-  auto colorProfile = input->get_color_profile_nclx();
-  YCbCr_to_RGB_coefficients coeffs = YCbCr_to_RGB_coefficients::defaults();
-  if (colorProfile) {
-    coeffs = heif::get_YCbCr_to_RGB_coefficients(colorProfile->get_matrix_coefficients(),
-                                                 colorProfile->get_colour_primaries());
-  }
-
-  int r_cr = static_cast<int>(lround(256 * coeffs.r_cr));
-  int g_cr = static_cast<int>(lround(256 * coeffs.g_cr));
-  int g_cb = static_cast<int>(lround(256 * coeffs.g_cb));
-  int b_cb = static_cast<int>(lround(256 * coeffs.b_cb));
-
-
-  const bool with_alpha = input->has_channel(heif_channel_Alpha);
-
-  const uint8_t* in_y, * in_cb, * in_cr, * in_a = nullptr;
-  int in_y_stride = 0, in_cb_stride = 0, in_cr_stride = 0, in_a_stride = 0;
-
-  uint8_t* out_p;
-  int out_p_stride = 0;
-
-  in_y = input->get_plane(heif_channel_Y, &in_y_stride);
-  in_cb = input->get_plane(heif_channel_Cb, &in_cb_stride);
-  in_cr = input->get_plane(heif_channel_Cr, &in_cr_stride);
-  if (with_alpha) {
-    in_a = input->get_plane(heif_channel_Alpha, &in_a_stride);
-  }
-
-  out_p = outimg->get_plane(heif_channel_interleaved, &out_p_stride);
-
-  int x, y;
-  for (y = 0; y < height; y++) {
-    for (x = 0; x < width; x++) {
-
-      int yv = (in_y[y * in_y_stride + x]);
-      int cb = (in_cb[y / 2 * in_cb_stride + x / 2] - 128);
-      int cr = (in_cr[y / 2 * in_cr_stride + x / 2] - 128);
-
-      out_p[y * out_p_stride + 4 * x + 0] = clip_int_u8(yv + ((r_cr * cr + 128) >> 8));
-      out_p[y * out_p_stride + 4 * x + 1] = clip_int_u8(yv + ((g_cb * cb + g_cr * cr + 128) >> 8));
-      out_p[y * out_p_stride + 4 * x + 2] = clip_int_u8(yv + ((b_cb * cb + 128) >> 8));
-
-
-      if (with_alpha) {
-        out_p[y * out_p_stride + 4 * x + 3] = in_a[y * in_a_stride + x];
-      }
-      else {
-        out_p[y * out_p_stride + 4 * x + 3] = 0xFF;
-      }
-    }
-  }
-
-  return outimg;
-}
-
-
-class Op_RGB_HDR_to_RRGGBBaa_BE : public ColorConversionOperation
-{
-public:
-  std::vector<ColorStateWithCost>
-  state_after_conversion(ColorState input_state,
-                         ColorState target_state,
-                         ColorConversionOptions options) override;
-
-  std::shared_ptr<HeifPixelImage>
-  convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
-                     ColorState target_state,
-                     ColorConversionOptions options) override;
-};
-
-
-std::vector<ColorStateWithCost>
-Op_RGB_HDR_to_RRGGBBaa_BE::state_after_conversion(ColorState input_state,
-                                                  ColorState target_state,
-                                                  ColorConversionOptions options)
-{
-  // Note: no input alpha channel required. It will be filled up with 0xFF.
-
-  if (input_state.colorspace != heif_colorspace_RGB ||
-      input_state.chroma != heif_chroma_444 ||
-      input_state.bits_per_pixel == 8) {
-    return {};
-  }
-
-  std::vector<ColorStateWithCost> states;
-
-  ColorState output_state;
-  ColorConversionCosts costs;
-
-  // --- convert to RRGGBB_BE
-
-  if (input_state.has_alpha == false) {
-    output_state.colorspace = heif_colorspace_RGB;
-    output_state.chroma = heif_chroma_interleaved_RRGGBB_BE;
-    output_state.has_alpha = false;
-    output_state.bits_per_pixel = input_state.bits_per_pixel;
-
-    costs = {0.5f, 0.0f, 0.0f};
-
-    states.push_back({output_state, costs});
-  }
-
-
-  // --- convert to RRGGBBAA_BE
-
-  output_state.colorspace = heif_colorspace_RGB;
-  output_state.chroma = heif_chroma_interleaved_RRGGBBAA_BE;
-  output_state.has_alpha = true;
-  output_state.bits_per_pixel = input_state.bits_per_pixel;
-
-  costs = {0.5f, 0.0f, 0.0f};
-
-  states.push_back({output_state, costs});
-
-
-  return states;
-}
-
-
-std::shared_ptr<HeifPixelImage>
-Op_RGB_HDR_to_RRGGBBaa_BE::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
-                                              ColorState target_state,
-                                              ColorConversionOptions options)
-{
-  if (input->get_bits_per_pixel(heif_channel_R) == 8 ||
-      input->get_bits_per_pixel(heif_channel_G) == 8 ||
-      input->get_bits_per_pixel(heif_channel_B) == 8) {
-    return nullptr;
-  }
-
-  //int bpp = input->get_bits_per_pixel(heif_channel_R);
-
-  bool input_has_alpha = input->has_channel(heif_channel_Alpha);
-  bool output_has_alpha = input_has_alpha || target_state.has_alpha;
-
-  if (input_has_alpha) {
-    if (input->get_bits_per_pixel(heif_channel_Alpha) == 8) {
-      return nullptr;
-    }
-
-    if (input->get_width(heif_channel_Alpha) != input->get_width(heif_channel_G) ||
-        input->get_height(heif_channel_Alpha) != input->get_height(heif_channel_G)) {
-      return nullptr;
-    }
-  }
-
-  auto outimg = std::make_shared<HeifPixelImage>();
-
-  int width = input->get_width();
-  int height = input->get_height();
-
-  outimg->create(width, height, heif_colorspace_RGB,
-                 output_has_alpha ? heif_chroma_interleaved_RRGGBBAA_BE : heif_chroma_interleaved_RRGGBB_BE);
-
-  outimg->add_plane(heif_channel_interleaved, width, height, input->get_bits_per_pixel(heif_channel_R));
-
-  const uint16_t* in_r, * in_g, * in_b, * in_a = nullptr;
-  int in_r_stride = 0, in_g_stride = 0, in_b_stride = 0, in_a_stride = 0;
-
-  uint8_t* out_p;
-  int out_p_stride = 0;
-
-  in_r = (uint16_t*) input->get_plane(heif_channel_R, &in_r_stride);
-  in_g = (uint16_t*) input->get_plane(heif_channel_G, &in_g_stride);
-  in_b = (uint16_t*) input->get_plane(heif_channel_B, &in_b_stride);
-  out_p = outimg->get_plane(heif_channel_interleaved, &out_p_stride);
-
-  if (input_has_alpha) {
-    in_a = (uint16_t*) input->get_plane(heif_channel_Alpha, &in_a_stride);
-  }
-
-  in_r_stride /= 2;
-  in_g_stride /= 2;
-  in_b_stride /= 2;
-  in_a_stride /= 2;
-
-  const int pixelsize = (output_has_alpha ? 8 : 6);
-
-  int x, y;
-  for (y = 0; y < height; y++) {
-
-    if (input_has_alpha) {
-      for (x = 0; x < width; x++) {
-        uint16_t r = in_r[x + y * in_r_stride];
-        uint16_t g = in_g[x + y * in_g_stride];
-        uint16_t b = in_b[x + y * in_b_stride];
-        uint16_t a = in_a[x + y * in_a_stride];
-        out_p[y * out_p_stride + 8 * x + 0] = (uint8_t) (r >> 8);
-        out_p[y * out_p_stride + 8 * x + 1] = (uint8_t) (r & 0xFF);
-        out_p[y * out_p_stride + 8 * x + 2] = (uint8_t) (g >> 8);
-        out_p[y * out_p_stride + 8 * x + 3] = (uint8_t) (g & 0xFF);
-        out_p[y * out_p_stride + 8 * x + 4] = (uint8_t) (b >> 8);
-        out_p[y * out_p_stride + 8 * x + 5] = (uint8_t) (b & 0xFF);
-        out_p[y * out_p_stride + 8 * x + 6] = (uint8_t) (a >> 8);
-        out_p[y * out_p_stride + 8 * x + 7] = (uint8_t) (a & 0xFF);
-      }
-    }
-    else {
-      for (x = 0; x < width; x++) {
-        uint16_t r = in_r[x + y * in_r_stride];
-        uint16_t g = in_g[x + y * in_g_stride];
-        uint16_t b = in_b[x + y * in_b_stride];
-        out_p[y * out_p_stride + pixelsize * x + 0] = (uint8_t) (r >> 8);
-        out_p[y * out_p_stride + pixelsize * x + 1] = (uint8_t) (r & 0xFF);
-        out_p[y * out_p_stride + pixelsize * x + 2] = (uint8_t) (g >> 8);
-        out_p[y * out_p_stride + pixelsize * x + 3] = (uint8_t) (g & 0xFF);
-        out_p[y * out_p_stride + pixelsize * x + 4] = (uint8_t) (b >> 8);
-        out_p[y * out_p_stride + pixelsize * x + 5] = (uint8_t) (b & 0xFF);
-
-        if (output_has_alpha) {
-          out_p[y * out_p_stride + pixelsize * x + 6] = 0xFF;
-          out_p[y * out_p_stride + pixelsize * x + 7] = 0xFF;
-        }
-      }
-    }
-  }
-
-  return outimg;
-}
-
-
-class Op_RGB_to_RRGGBBaa_BE : public ColorConversionOperation
-{
-public:
-  std::vector<ColorStateWithCost>
-  state_after_conversion(ColorState input_state,
-                         ColorState target_state,
-                         ColorConversionOptions options) override;
-
-  std::shared_ptr<HeifPixelImage>
-  convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
-                     ColorState target_state,
-                     ColorConversionOptions options) override;
-};
-
-
-std::vector<ColorStateWithCost>
-Op_RGB_to_RRGGBBaa_BE::state_after_conversion(ColorState input_state,
-                                              ColorState target_state,
-                                              ColorConversionOptions options)
-{
-  // Note: no input alpha channel required. It will be filled up with 0xFF.
-
-  if (input_state.colorspace != heif_colorspace_RGB ||
-      input_state.chroma != heif_chroma_444 ||
-      input_state.bits_per_pixel != 8) {
-    return {};
-  }
-
-  std::vector<ColorStateWithCost> states;
-
-  ColorState output_state;
-  ColorConversionCosts costs;
-
-  // --- convert to RRGGBB_BE
-
-  if (input_state.has_alpha == false) {
-    output_state.colorspace = heif_colorspace_RGB;
-    output_state.chroma = heif_chroma_interleaved_RRGGBB_BE;
-    output_state.has_alpha = false;
-    output_state.bits_per_pixel = input_state.bits_per_pixel;
-
-    costs = {0.5f, 0.0f, 0.0f};
-
-    states.push_back({output_state, costs});
-  }
-
-
-  // --- convert to RRGGBBAA_BE
-
-  output_state.colorspace = heif_colorspace_RGB;
-  output_state.chroma = heif_chroma_interleaved_RRGGBBAA_BE;
-  output_state.has_alpha = true;
-  output_state.bits_per_pixel = input_state.bits_per_pixel;
-
-  costs = {0.5f, 0.0f, 0.0f};
-
-  states.push_back({output_state, costs});
-
-
-  return states;
-}
-
-
-std::shared_ptr<HeifPixelImage>
-Op_RGB_to_RRGGBBaa_BE::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
-                                          ColorState target_state,
-                                          ColorConversionOptions options)
-{
-  if (input->get_bits_per_pixel(heif_channel_R) != 8 ||
-      input->get_bits_per_pixel(heif_channel_G) != 8 ||
-      input->get_bits_per_pixel(heif_channel_B) != 8) {
-    return nullptr;
-  }
-
-  //int bpp = input->get_bits_per_pixel(heif_channel_R);
-
-  bool input_has_alpha = input->has_channel(heif_channel_Alpha);
-  bool output_has_alpha = input_has_alpha || target_state.has_alpha;
-
-  if (input_has_alpha && input->get_bits_per_pixel(heif_channel_Alpha) != 8) {
-    return nullptr;
-  }
-
-  auto outimg = std::make_shared<HeifPixelImage>();
-
-  int width = input->get_width();
-  int height = input->get_height();
-
-  outimg->create(width, height, heif_colorspace_RGB,
-                 output_has_alpha ? heif_chroma_interleaved_RRGGBBAA_BE : heif_chroma_interleaved_RRGGBB_BE);
-
-  outimg->add_plane(heif_channel_interleaved, width, height, input->get_bits_per_pixel(heif_channel_R));
-
-  const uint8_t* in_r, * in_g, * in_b, * in_a = nullptr;
-  int in_r_stride = 0, in_g_stride = 0, in_b_stride = 0, in_a_stride = 0;
-
-  uint8_t* out_p;
-  int out_p_stride = 0;
-
-  in_r = input->get_plane(heif_channel_R, &in_r_stride);
-  in_g = input->get_plane(heif_channel_G, &in_g_stride);
-  in_b = input->get_plane(heif_channel_B, &in_b_stride);
-  out_p = outimg->get_plane(heif_channel_interleaved, &out_p_stride);
-
-  if (input_has_alpha) {
-    in_a = input->get_plane(heif_channel_Alpha, &in_a_stride);
-  }
-
-  const int pixelsize = (output_has_alpha ? 8 : 6);
-
-  int x, y;
-  for (y = 0; y < height; y++) {
-
-    if (input_has_alpha) {
-      for (x = 0; x < width; x++) {
-        out_p[y * out_p_stride + 8 * x + 0] = 0;
-        out_p[y * out_p_stride + 8 * x + 1] = in_r[x + y * in_r_stride];
-        out_p[y * out_p_stride + 8 * x + 2] = 0;
-        out_p[y * out_p_stride + 8 * x + 3] = in_g[x + y * in_g_stride];
-        out_p[y * out_p_stride + 8 * x + 4] = 0;
-        out_p[y * out_p_stride + 8 * x + 5] = in_b[x + y * in_b_stride];
-        out_p[y * out_p_stride + 8 * x + 6] = 0;
-        out_p[y * out_p_stride + 8 * x + 7] = in_a[x + y * in_a_stride];
-      }
-    }
-    else {
-      for (x = 0; x < width; x++) {
-        out_p[y * out_p_stride + pixelsize * x + 0] = 0;
-        out_p[y * out_p_stride + pixelsize * x + 1] = in_r[x + y * in_r_stride];
-        out_p[y * out_p_stride + pixelsize * x + 2] = 0;
-        out_p[y * out_p_stride + pixelsize * x + 3] = in_g[x + y * in_g_stride];
-        out_p[y * out_p_stride + pixelsize * x + 4] = 0;
-        out_p[y * out_p_stride + pixelsize * x + 5] = in_b[x + y * in_b_stride];
-
-        if (output_has_alpha) {
-          out_p[y * out_p_stride + pixelsize * x + 6] = 0;
-          out_p[y * out_p_stride + pixelsize * x + 7] = 0xFF;
-        }
-      }
-    }
-  }
-
-  return outimg;
-}
-
-
-class Op_RRGGBBaa_BE_to_RGB_HDR : public ColorConversionOperation
-{
-public:
-  std::vector<ColorStateWithCost>
-  state_after_conversion(ColorState input_state,
-                         ColorState target_state,
-                         ColorConversionOptions options) override;
-
-  std::shared_ptr<HeifPixelImage>
-  convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
-                     ColorState target_state,
-                     ColorConversionOptions options) override;
-};
-
-
-std::vector<ColorStateWithCost>
-Op_RRGGBBaa_BE_to_RGB_HDR::state_after_conversion(ColorState input_state,
-                                                  ColorState target_state,
-                                                  ColorConversionOptions options)
-{
-  // Note: no input alpha channel required. It will be filled up with 0xFF.
-
-  if (input_state.colorspace != heif_colorspace_RGB ||
-      (input_state.chroma != heif_chroma_interleaved_RRGGBB_BE &&
-       input_state.chroma != heif_chroma_interleaved_RRGGBBAA_BE) ||
-      input_state.bits_per_pixel == 8) {
-    return {};
-  }
-
-  std::vector<ColorStateWithCost> states;
-
-  ColorState output_state;
-  ColorConversionCosts costs;
-
-  // --- convert to RRGGBB_BE
-
-  output_state.colorspace = heif_colorspace_RGB;
-  output_state.chroma = heif_chroma_444;
-  output_state.has_alpha = (input_state.chroma == heif_chroma_interleaved_RRGGBBAA_LE ||
-                            input_state.chroma == heif_chroma_interleaved_RRGGBBAA_BE);
-  output_state.bits_per_pixel = input_state.bits_per_pixel;
-
-  costs = {0.2f, 0.0f, 0.0f};
-
-  states.push_back({output_state, costs});
-
-
-  return states;
-}
-
-
-std::shared_ptr<HeifPixelImage>
-Op_RRGGBBaa_BE_to_RGB_HDR::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
-                                              ColorState target_state,
-                                              ColorConversionOptions options)
-{
-  bool has_alpha = (input->get_chroma_format() == heif_chroma_interleaved_RRGGBBAA_LE ||
-                    input->get_chroma_format() == heif_chroma_interleaved_RRGGBBAA_BE);
-
-  auto outimg = std::make_shared<HeifPixelImage>();
-
-  int width = input->get_width();
-  int height = input->get_height();
-
-  outimg->create(width, height, heif_colorspace_RGB, heif_chroma_444);
-
-  outimg->add_plane(heif_channel_R, width, height, input->get_bits_per_pixel(heif_channel_interleaved));
-  outimg->add_plane(heif_channel_G, width, height, input->get_bits_per_pixel(heif_channel_interleaved));
-  outimg->add_plane(heif_channel_B, width, height, input->get_bits_per_pixel(heif_channel_interleaved));
-
-  if (has_alpha) {
-    outimg->add_plane(heif_channel_Alpha, width, height, input->get_bits_per_pixel(heif_channel_interleaved));
-  }
-
-  const uint8_t* in_p;
-  int in_p_stride = 0;
-  int in_pix_size = has_alpha ? 8 : 6;
-
-  uint16_t* out_r, * out_g, * out_b, * out_a = nullptr;
-  int out_r_stride = 0, out_g_stride = 0, out_b_stride = 0, out_a_stride = 0;
-
-  in_p = input->get_plane(heif_channel_interleaved, &in_p_stride);
-
-  out_r = (uint16_t*) outimg->get_plane(heif_channel_R, &out_r_stride);
-  out_g = (uint16_t*) outimg->get_plane(heif_channel_G, &out_g_stride);
-  out_b = (uint16_t*) outimg->get_plane(heif_channel_B, &out_b_stride);
-
-  if (has_alpha) {
-    out_a = (uint16_t*) outimg->get_plane(heif_channel_Alpha, &out_a_stride);
-  }
-
-  out_r_stride /= 2;
-  out_g_stride /= 2;
-  out_b_stride /= 2;
-  out_a_stride /= 2;
-
-  int x, y;
-  for (y = 0; y < height; y++) {
-
-    for (x = 0; x < width; x++) {
-      uint16_t r = (uint16_t) ((in_p[y * in_p_stride + in_pix_size * x + 0] << 8) |
-                               in_p[y * in_p_stride + in_pix_size * x + 1]);
-      uint16_t g = (uint16_t) ((in_p[y * in_p_stride + in_pix_size * x + 2] << 8) |
-                               in_p[y * in_p_stride + in_pix_size * x + 3]);
-      uint16_t b = (uint16_t) ((in_p[y * in_p_stride + in_pix_size * x + 4] << 8) |
-                               in_p[y * in_p_stride + in_pix_size * x + 5]);
-
-      out_r[x + y * out_r_stride] = r;
-      out_g[x + y * out_g_stride] = g;
-      out_b[x + y * out_b_stride] = b;
-
-      if (has_alpha) {
-        // in_pix_size is always 8 when we have alpha channel
-        uint16_t a = (uint16_t) ((in_p[y * in_p_stride + 8 * x + 6] << 8) |
-                                 in_p[y * in_p_stride + 8 * x + 7]);
-
-        out_a[x + y * out_a_stride] = a;
-      }
-    }
-  }
-
-  return outimg;
-}
-
-
-class Op_RRGGBBaa_swap_endianness : public ColorConversionOperation
-{
-public:
-  std::vector<ColorStateWithCost>
-  state_after_conversion(ColorState input_state,
-                         ColorState target_state,
-                         ColorConversionOptions options) override;
-
-  std::shared_ptr<HeifPixelImage>
-  convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
-                     ColorState target_state,
-                     ColorConversionOptions options) override;
-};
-
-
-std::vector<ColorStateWithCost>
-Op_RRGGBBaa_swap_endianness::state_after_conversion(ColorState input_state,
-                                                    ColorState target_state,
-                                                    ColorConversionOptions options)
-{
-  // Note: no input alpha channel required. It will be filled up with 0xFF.
-
-  if (input_state.colorspace != heif_colorspace_RGB ||
-      (input_state.chroma != heif_chroma_interleaved_RRGGBB_LE &&
-       input_state.chroma != heif_chroma_interleaved_RRGGBB_BE &&
-       input_state.chroma != heif_chroma_interleaved_RRGGBBAA_LE &&
-       input_state.chroma != heif_chroma_interleaved_RRGGBBAA_BE)) {
-    return {};
-  }
-
-  std::vector<ColorStateWithCost> states;
-
-  ColorState output_state;
-  ColorConversionCosts costs;
-
-  // --- swap RRGGBB
-
-  if (input_state.chroma == heif_chroma_interleaved_RRGGBB_LE ||
-      input_state.chroma == heif_chroma_interleaved_RRGGBB_BE) {
-    output_state.colorspace = heif_colorspace_RGB;
-
-    if (input_state.chroma == heif_chroma_interleaved_RRGGBB_LE) {
-      output_state.chroma = heif_chroma_interleaved_RRGGBB_BE;
-    }
-    else {
-      output_state.chroma = heif_chroma_interleaved_RRGGBB_LE;
-    }
-
-    output_state.has_alpha = false;
-    output_state.bits_per_pixel = input_state.bits_per_pixel;
-
-    costs = {0.1f, 0.0f, 0.0f};
-
-    states.push_back({output_state, costs});
-  }
-
-
-  // --- swap RRGGBBAA
-
-  if (input_state.chroma == heif_chroma_interleaved_RRGGBBAA_LE ||
-      input_state.chroma == heif_chroma_interleaved_RRGGBBAA_BE) {
-    output_state.colorspace = heif_colorspace_RGB;
-
-    if (input_state.chroma == heif_chroma_interleaved_RRGGBBAA_LE) {
-      output_state.chroma = heif_chroma_interleaved_RRGGBBAA_BE;
-    }
-    else {
-      output_state.chroma = heif_chroma_interleaved_RRGGBBAA_LE;
-    }
-
-    output_state.has_alpha = true;
-    output_state.bits_per_pixel = input_state.bits_per_pixel;
-
-    costs = {0.1f, 0.0f, 0.0f};
-
-    states.push_back({output_state, costs});
-  }
-
-
-  return states;
-}
-
-
-std::shared_ptr<HeifPixelImage>
-Op_RRGGBBaa_swap_endianness::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
-                                                ColorState target_state,
-                                                ColorConversionOptions options)
-{
-  auto outimg = std::make_shared<HeifPixelImage>();
-
-  int width = input->get_width();
-  int height = input->get_height();
-
-  switch (input->get_chroma_format()) {
-    case heif_chroma_interleaved_RRGGBB_LE:
-      outimg->create(width, height, heif_colorspace_RGB, heif_chroma_interleaved_RRGGBB_BE);
-      break;
-    case heif_chroma_interleaved_RRGGBB_BE:
-      outimg->create(width, height, heif_colorspace_RGB, heif_chroma_interleaved_RRGGBB_LE);
-      break;
-    case heif_chroma_interleaved_RRGGBBAA_LE:
-      outimg->create(width, height, heif_colorspace_RGB, heif_chroma_interleaved_RRGGBBAA_BE);
-      break;
-    case heif_chroma_interleaved_RRGGBBAA_BE:
-      outimg->create(width, height, heif_colorspace_RGB, heif_chroma_interleaved_RRGGBBAA_LE);
-      break;
-    default:
-      return nullptr;
-  }
-
-  outimg->add_plane(heif_channel_interleaved, width, height,
-                    input->get_bits_per_pixel(heif_channel_interleaved));
-
-  const uint8_t* in_p = nullptr;
-  int in_p_stride = 0;
-
-  uint8_t* out_p;
-  int out_p_stride = 0;
-
-  in_p = input->get_plane(heif_channel_interleaved, &in_p_stride);
-  out_p = outimg->get_plane(heif_channel_interleaved, &out_p_stride);
-
-  int n_bytes = std::min(in_p_stride, out_p_stride);
-
-  int x, y;
-  for (y = 0; y < height; y++) {
-    for (x = 0; x < n_bytes; x += 2) {
-      out_p[y * out_p_stride + x + 0] = in_p[y * in_p_stride + x + 1];
-      out_p[y * out_p_stride + x + 1] = in_p[y * in_p_stride + x + 0];
-    }
-  }
-
-  return outimg;
-}
-
-
-class Op_mono_to_YCbCr420 : public ColorConversionOperation
-{
-public:
-  std::vector<ColorStateWithCost>
-  state_after_conversion(ColorState input_state,
-                         ColorState target_state,
-                         ColorConversionOptions options) override;
-
-  std::shared_ptr<HeifPixelImage>
-  convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
-                     ColorState target_state,
-                     ColorConversionOptions options) override;
-};
-
-
-std::vector<ColorStateWithCost>
-Op_mono_to_YCbCr420::state_after_conversion(ColorState input_state,
-                                            ColorState target_state,
-                                            ColorConversionOptions options)
-{
-  // Note: no input alpha channel required. It will be filled up with 0xFF.
-
-  if (input_state.colorspace != heif_colorspace_monochrome ||
-      input_state.chroma != heif_chroma_monochrome) {
-    return {};
-  }
-
-  std::vector<ColorStateWithCost> states;
-
-  ColorState output_state;
-  ColorConversionCosts costs;
-
-  // --- convert to YCbCr420
-
-  output_state.colorspace = heif_colorspace_YCbCr;
-  output_state.chroma = heif_chroma_420;
-  output_state.has_alpha = input_state.has_alpha;
-  output_state.bits_per_pixel = input_state.bits_per_pixel;
-
-  costs = {0.1f, 0.0f, 0.0f};
-
-  states.push_back({output_state, costs});
-
-  return states;
-}
-
-
-std::shared_ptr<HeifPixelImage>
-Op_mono_to_YCbCr420::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
-                                        ColorState target_state,
-                                        ColorConversionOptions options)
-{
-  auto outimg = std::make_shared<HeifPixelImage>();
-
-  int width = input->get_width();
-  int height = input->get_height();
-
-  outimg->create(width, height, heif_colorspace_YCbCr, heif_chroma_420);
-
-  int input_bpp = input->get_bits_per_pixel(heif_channel_Y);
-
-  int chroma_width = (width + 1) / 2;
-  int chroma_height = (height + 1) / 2;
-
-  outimg->add_plane(heif_channel_Y, width, height, input_bpp);
-  outimg->add_plane(heif_channel_Cb, chroma_width, chroma_height, input_bpp);
-  outimg->add_plane(heif_channel_Cr, chroma_width, chroma_height, input_bpp);
-
-  int alpha_bpp = 0;
-  bool has_alpha = input->has_channel(heif_channel_Alpha);
-  if (has_alpha) {
-    alpha_bpp = input->get_bits_per_pixel(heif_channel_Alpha);
-    outimg->add_plane(heif_channel_Alpha, width, height, alpha_bpp);
-  }
-
-
-  if (input_bpp == 8) {
-    uint8_t* out_cb, * out_cr, * out_y;
-    int out_cb_stride = 0, out_cr_stride = 0, out_y_stride = 0;
-
-    const uint8_t* in_y;
-    int in_y_stride = 0;
-
-    in_y = input->get_plane(heif_channel_Y, &in_y_stride);
-
-    out_y = outimg->get_plane(heif_channel_Y, &out_y_stride);
-    out_cb = outimg->get_plane(heif_channel_Cb, &out_cb_stride);
-    out_cr = outimg->get_plane(heif_channel_Cr, &out_cr_stride);
-
-    memset(out_cb, 128, out_cb_stride * chroma_height);
-    memset(out_cr, 128, out_cr_stride * chroma_height);
-
-    for (int y = 0; y < height; y++) {
-      memcpy(out_y + y * out_y_stride,
-             in_y + y * in_y_stride,
-             width);
-    }
-  }
-  else {
-    uint16_t* out_cb, * out_cr, * out_y;
-    int out_cb_stride = 0, out_cr_stride = 0, out_y_stride = 0;
-
-    const uint16_t* in_y;
-    int in_y_stride = 0;
-
-    in_y = (const uint16_t*) input->get_plane(heif_channel_Y, &in_y_stride);
-
-    out_y = (uint16_t*) outimg->get_plane(heif_channel_Y, &out_y_stride);
-    out_cb = (uint16_t*) outimg->get_plane(heif_channel_Cb, &out_cb_stride);
-    out_cr = (uint16_t*) outimg->get_plane(heif_channel_Cr, &out_cr_stride);
-
-    in_y_stride /= 2;
-    out_y_stride /= 2;
-    out_cb_stride /= 2;
-    out_cr_stride /= 2;
-
-    for (int y = 0; y < chroma_height; y++)
-      for (int x = 0; x < chroma_width; x++) {
-        out_cb[x + y * out_cb_stride] = (uint16_t) (128 << (input_bpp - 8));
-        out_cr[x + y * out_cr_stride] = (uint16_t) (128 << (input_bpp - 8));
-      }
-
-    for (int y = 0; y < height; y++) {
-      memcpy(out_y + y * out_y_stride,
-             in_y + y * in_y_stride,
-             width * 2);
-    }
-  }
-
-  if (has_alpha) {
-    const uint8_t* in_a;
-    uint8_t* out_a;
-    int in_a_stride = 0;
-    int out_a_stride = 0;
-
-    in_a = input->get_plane(heif_channel_Alpha, &in_a_stride);
-    out_a = outimg->get_plane(heif_channel_Alpha, &out_a_stride);
-
-    int memory_width = (alpha_bpp > 8 ? width * 2 : width);
-
-    for (int y = 0; y < height; y++) {
-      memcpy(&out_a[y * out_a_stride], &in_a[y * in_a_stride], memory_width);
-    }
-  }
-
-  return outimg;
-}
-
-
-class Op_mono_to_RGB24_32 : public ColorConversionOperation
-{
-public:
-  std::vector<ColorStateWithCost>
-  state_after_conversion(ColorState input_state,
-                         ColorState target_state,
-                         ColorConversionOptions options) override;
-
-  std::shared_ptr<HeifPixelImage>
-  convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
-                     ColorState target_state,
-                     ColorConversionOptions options) override;
-};
-
-
-std::vector<ColorStateWithCost>
-Op_mono_to_RGB24_32::state_after_conversion(ColorState input_state,
-                                            ColorState target_state,
-                                            ColorConversionOptions options)
-{
-  // Note: no input alpha channel required. It will be filled up with 0xFF.
-
-  if ((input_state.colorspace != heif_colorspace_monochrome &&
-       input_state.colorspace != heif_colorspace_YCbCr) ||
-      input_state.chroma != heif_chroma_monochrome ||
-      input_state.bits_per_pixel != 8) {
-    return {};
-  }
-
-  std::vector<ColorStateWithCost> states;
-
-  ColorState output_state;
-  ColorConversionCosts costs;
-
-  // --- convert to RGB24
-
-  if (input_state.has_alpha == false) {
-    output_state.colorspace = heif_colorspace_RGB;
-    output_state.chroma = heif_chroma_interleaved_RGB;
-    output_state.has_alpha = false;
-    output_state.bits_per_pixel = 8;
-
-    costs = {0.1f, 0.0f, 0.0f};
-
-    states.push_back({output_state, costs});
-  }
-
-
-  // --- convert to RGB32
-
-  output_state.colorspace = heif_colorspace_RGB;
-  output_state.chroma = heif_chroma_interleaved_RGBA;
-  output_state.has_alpha = true;
-  output_state.bits_per_pixel = 8;
-
-  costs = {0.15f, 0.0f, 0.0f};
-
-  states.push_back({output_state, costs});
-
-  return states;
-}
-
-
-std::shared_ptr<HeifPixelImage>
-Op_mono_to_RGB24_32::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
-                                        ColorState target_state,
-                                        ColorConversionOptions options)
-{
-  int width = input->get_width();
-  int height = input->get_height();
-
-  if (input->get_bits_per_pixel(heif_channel_Y) != 8) {
-    return nullptr;
-  }
-
-  auto outimg = std::make_shared<HeifPixelImage>();
-
-  bool has_alpha = input->has_channel(heif_channel_Alpha);
-
-  if (target_state.has_alpha) {
-    outimg->create(width, height, heif_colorspace_RGB, heif_chroma_interleaved_32bit);
-  }
-  else {
-    outimg->create(width, height, heif_colorspace_RGB, heif_chroma_interleaved_24bit);
-  }
-
-  outimg->add_plane(heif_channel_interleaved, width, height, 8);
-
-  const uint8_t* in_y, * in_a;
-  int in_y_stride = 0, in_a_stride;
-
-  uint8_t* out_p;
-  int out_p_stride = 0;
-
-  in_y = input->get_plane(heif_channel_Y, &in_y_stride);
-  if (has_alpha) {
-    in_a = input->get_plane(heif_channel_Alpha, &in_a_stride);
-  }
-
-  out_p = outimg->get_plane(heif_channel_interleaved, &out_p_stride);
-
-  int x, y;
-  for (y = 0; y < height; y++) {
-    if (target_state.has_alpha == false) {
-      for (x = 0; x < width; x++) {
-        uint8_t v = in_y[x + y * in_y_stride];
-        out_p[y * out_p_stride + 3 * x + 0] = v;
-        out_p[y * out_p_stride + 3 * x + 1] = v;
-        out_p[y * out_p_stride + 3 * x + 2] = v;
-      }
-    }
-    else if (has_alpha) {
-      for (x = 0; x < width; x++) {
-        uint8_t v = in_y[x + y * in_y_stride];
-        out_p[y * out_p_stride + 4 * x + 0] = v;
-        out_p[y * out_p_stride + 4 * x + 1] = v;
-        out_p[y * out_p_stride + 4 * x + 2] = v;
-        out_p[y * out_p_stride + 4 * x + 3] = in_a[x + y * in_a_stride];
-      }
-    }
-    else {
-      for (x = 0; x < width; x++) {
-        uint8_t v = in_y[x + y * in_y_stride];
-        out_p[y * out_p_stride + 4 * x + 0] = v;
-        out_p[y * out_p_stride + 4 * x + 1] = v;
-        out_p[y * out_p_stride + 4 * x + 2] = v;
-        out_p[y * out_p_stride + 4 * x + 3] = 0xFF;
-      }
-    }
-  }
-
-  return outimg;
-}
-
-
-class Op_RGB24_32_to_YCbCr : public ColorConversionOperation
-{
-public:
-  std::vector<ColorStateWithCost>
-  state_after_conversion(ColorState input_state,
-                         ColorState target_state,
-                         ColorConversionOptions options) override;
-
-  std::shared_ptr<HeifPixelImage>
-  convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
-                     ColorState target_state,
-                     ColorConversionOptions options) override;
-};
-
-
-std::vector<ColorStateWithCost>
-Op_RGB24_32_to_YCbCr::state_after_conversion(ColorState input_state,
-                                             ColorState target_state,
-                                             ColorConversionOptions options)
-{
-  // Note: no input alpha channel required. It will be filled up with 0xFF.
-
-  if (input_state.colorspace != heif_colorspace_RGB ||
-      (input_state.chroma != heif_chroma_interleaved_RGB &&
-       input_state.chroma != heif_chroma_interleaved_RGBA)) {
-    return {};
-  }
-
-  if (target_state.chroma != heif_chroma_420 &&
-      target_state.chroma != heif_chroma_422 &&
-      target_state.chroma != heif_chroma_444) {
-    return {};
-  }
-
-  if (target_state.nclx_profile) {
-    if (target_state.nclx_profile->get_matrix_coefficients() == 0) {
-      return {};
-    }
-  }
-
-  std::vector<ColorStateWithCost> states;
-
-  ColorState output_state;
-  ColorConversionCosts costs;
-
-
-  // --- convert RGB24
-
-  if (input_state.chroma == heif_chroma_interleaved_RGB) {
-    output_state.colorspace = heif_colorspace_YCbCr;
-    output_state.chroma = target_state.chroma;
-    output_state.has_alpha = false;
-    output_state.bits_per_pixel = 8;
-
-    costs = {0.75f, 0.5f, 0.0f};  // quality not good since we subsample chroma without filtering
-
-    states.push_back({output_state, costs});
-  }
-
-
-  // --- convert RGB32
-
-  if (input_state.chroma == heif_chroma_interleaved_RGBA) {
-    output_state.colorspace = heif_colorspace_YCbCr;
-    output_state.chroma = target_state.chroma;
-    output_state.has_alpha = true;
-    output_state.bits_per_pixel = 8;
-
-    costs = {0.75f, 0.5f, 0.0f};  // quality not good since we subsample chroma without filtering
-
-    states.push_back({output_state, costs});
-  }
-
-  return states;
-}
-
-
-static inline uint8_t clip_f_u8(float fx)
-{
-  long x = lroundf(fx);
-  if (x < 0) return 0;
-  if (x > 255) return 255;
-  return static_cast<uint8_t>(x);
-}
-
-
-inline void set_chroma_pixels(uint8_t* out_cb, uint8_t* out_cr,
-                              uint8_t r, uint8_t g, uint8_t b,
-                              const RGB_to_YCbCr_coefficients& coeffs,
-                              bool full_range_flag)
-{
-  float cb = r * coeffs.c[1][0] + g * coeffs.c[1][1] + b * coeffs.c[1][2];
-  float cr = r * coeffs.c[2][0] + g * coeffs.c[2][1] + b * coeffs.c[2][2];
-
-  if (full_range_flag) {
-    *out_cb = clip_f_u8(cb + 128);
-    *out_cr = clip_f_u8(cr + 128);
-  }
-  else {
-    *out_cb = (uint8_t) clip_f_u8(cb * 0.875f + 128.0f);
-    *out_cr = (uint8_t) clip_f_u8(cr * 0.875f + 128.0f);
-  }
-}
-
-
-std::shared_ptr<HeifPixelImage>
-Op_RGB24_32_to_YCbCr::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
-                                         ColorState target_state,
-                                         ColorConversionOptions options)
-{
-  int width = input->get_width();
-  int height = input->get_height();
-
-  auto outimg = std::make_shared<HeifPixelImage>();
-
-  auto chroma = target_state.chroma;
-  uint8_t chromaSubH = chroma_h_subsampling(chroma);
-  uint8_t chromaSubV = chroma_v_subsampling(chroma);
-
-  outimg->create(width, height, heif_colorspace_YCbCr, chroma);
-
-  int chroma_width = (width + chromaSubH - 1) / chromaSubH;
-  int chroma_height = (height + chromaSubV - 1) / chromaSubV;
-
-  const bool has_alpha = (input->get_chroma_format() == heif_chroma_interleaved_32bit);
-
-  outimg->add_plane(heif_channel_Y, width, height, 8);
-  outimg->add_plane(heif_channel_Cb, chroma_width, chroma_height, 8);
-  outimg->add_plane(heif_channel_Cr, chroma_width, chroma_height, 8);
-
-  if (has_alpha) {
-    outimg->add_plane(heif_channel_Alpha, width, height, 8);
-  }
-
-  uint8_t* out_cb, * out_cr, * out_y, * out_a;
-  int out_cb_stride = 0, out_cr_stride = 0, out_y_stride = 0, out_a_stride = 0;
-
-  const uint8_t* in_p;
-  int in_stride = 0;
-
-  in_p = input->get_plane(heif_channel_interleaved, &in_stride);
-
-  out_y = outimg->get_plane(heif_channel_Y, &out_y_stride);
-  out_cb = outimg->get_plane(heif_channel_Cb, &out_cb_stride);
-  out_cr = outimg->get_plane(heif_channel_Cr, &out_cr_stride);
-
-  if (has_alpha) {
-    out_a = outimg->get_plane(heif_channel_Alpha, &out_a_stride);
-  }
-  else {
-    out_a = nullptr;
-  }
-
-
-  RGB_to_YCbCr_coefficients coeffs = RGB_to_YCbCr_coefficients::defaults();
-  bool full_range_flag = true;
-  if (target_state.nclx_profile) {
-    full_range_flag = target_state.nclx_profile->get_full_range_flag();
-    coeffs = heif::get_RGB_to_YCbCr_coefficients(target_state.nclx_profile->get_matrix_coefficients(),
-                                                 target_state.nclx_profile->get_colour_primaries());
-  }
-
-
-  int bytes_per_pixel = (has_alpha ? 4 : 3);
-
-  for (int y = 0; y < height; y++) {
-    const uint8_t* p = &in_p[y * in_stride];
-
-    for (int x = 0; x < width; x++) {
-      uint8_t r = p[0];
-      uint8_t g = p[1];
-      uint8_t b = p[2];
-      p += bytes_per_pixel;
-
-      float yv = r * coeffs.c[0][0] + g * coeffs.c[0][1] + b * coeffs.c[0][2];
-
-      if (full_range_flag) {
-        out_y[y * out_y_stride + x] = clip_f_u8(yv);
-      }
-      else {
-        out_y[y * out_y_stride + x] = (uint8_t) (clip_f_u16(yv * 0.85547f, 219) + 16);
-      }
-    }
-  }
-
-  if (chromaSubH == 1 && chromaSubV == 1) {
-    // chroma 4:4:4
-
-    for (int y = 0; y < height; y++) {
-      const uint8_t* p = &in_p[y * in_stride];
-
-      for (int x = 0; x < width; x++) {
-        uint8_t r = p[0];
-        uint8_t g = p[1];
-        uint8_t b = p[2];
-        p += bytes_per_pixel;
-
-        set_chroma_pixels(out_cb + y * out_cb_stride + x,
-                          out_cr + y * out_cr_stride + x,
-                          r, g, b,
-                          coeffs, full_range_flag);
-      }
-    }
-  }
-  else if (chromaSubH == 2 && chromaSubV == 2) {
-    // chroma 4:2:0
-
-    for (int y = 0; y < (height & ~1); y += 2) {
-      const uint8_t* p = &in_p[y * in_stride];
-
-      for (int x = 0; x < (width & ~1); x += 2) {
-        uint8_t r = uint8_t((p[0] + p[bytes_per_pixel + 0] + p[in_stride + 0] + p[bytes_per_pixel + in_stride + 0]) / 4);
-        uint8_t g = uint8_t((p[1] + p[bytes_per_pixel + 1] + p[in_stride + 1] + p[bytes_per_pixel + in_stride + 1]) / 4);
-        uint8_t b = uint8_t((p[2] + p[bytes_per_pixel + 2] + p[in_stride + 2] + p[bytes_per_pixel + in_stride + 2]) / 4);
-
-        p += bytes_per_pixel * 2;
-
-        set_chroma_pixels(out_cb + (y / 2) * out_cb_stride + (x / 2),
-                          out_cr + (y / 2) * out_cr_stride + (x / 2),
-                          r, g, b,
-                          coeffs, full_range_flag);
-      }
-    }
-
-    // 4:2:0 right column (if odd width)
-    if (width & 1) {
-      int x = width - 1;
-      const uint8_t* p = &in_p[x * bytes_per_pixel];
-
-      for (int y = 0; y < height; y += 2) {
-        uint8_t r, g, b;
-        if (y + 1 < height) {
-          r = uint8_t((p[0] + p[in_stride + 0]) / 2);
-          g = uint8_t((p[1] + p[in_stride + 1]) / 2);
-          b = uint8_t((p[2] + p[in_stride + 2]) / 2);
-        }
-        else {
-          r = p[0];
-          g = p[1];
-          b = p[2];
-        }
-
-        set_chroma_pixels(out_cb + (y / 2) * out_cb_stride + (x / 2),
-                          out_cr + (y / 2) * out_cr_stride + (x / 2),
-                          r, g, b,
-                          coeffs, full_range_flag);
-
-        p += in_stride * 2;
-      }
-    }
-
-    // 4:2:0 bottom row (if odd height)
-    if (height & 1) {
-      int y = height - 1;
-      const uint8_t* p = &in_p[y * in_stride];
-
-      for (int x = 0; x < width; x += 2) {
-        uint8_t r, g, b;
-        if (x + 1 < width) {
-          r = uint8_t((p[0] + p[bytes_per_pixel + 0]) / 2);
-          g = uint8_t((p[1] + p[bytes_per_pixel + 1]) / 2);
-          b = uint8_t((p[2] + p[bytes_per_pixel + 2]) / 2);
-        }
-        else {
-          r = p[0];
-          g = p[1];
-          b = p[2];
-        }
-
-        set_chroma_pixels(out_cb + (y / 2) * out_cb_stride + (x / 2),
-                          out_cr + (y / 2) * out_cr_stride + (x / 2),
-                          r, g, b,
-                          coeffs, full_range_flag);
-
-        p += bytes_per_pixel * 2;
-      }
-    }
-  }
-  else if (chromaSubH == 2 && chromaSubV == 1) {
-    // chroma 4:2:2
-
-    for (int y = 0; y < height; y++) {
-      const uint8_t* p = &in_p[y * in_stride];
-
-      for (int x = 0; x < width; x += 2) {
-        uint8_t r, g, b;
-
-        // TODO: it still is an open question where the 'correct' chroma sample positions are for 4:2:2
-        // Since 4:2:2 is primarily used for video content and as there is no way to signal center position for h.265,
-        // we currently use left-aligned sampling. See the discussion here: https://github.com/strukturag/libheif/issues/521
-#if USE_CENTER_CHROMA_422
-        if (x + 1 < width) {
-          r = uint8_t((p[0] + p[bytes_per_pixel + 0]) / 2);
-          g = uint8_t((p[1] + p[bytes_per_pixel + 1]) / 2);
-          b = uint8_t((p[2] + p[bytes_per_pixel + 2]) / 2);
-        }
-        else {
-          r = p[0];
-          g = p[1];
-          b = p[2];
-        }
-#else
-        r = p[0];
-        g = p[1];
-        b = p[2];
-#endif
-
-        p += bytes_per_pixel * 2;
-
-        set_chroma_pixels(out_cb + y * out_cb_stride + (x / 2),
-                          out_cr + y * out_cr_stride + (x / 2),
-                          r, g, b,
-                          coeffs, full_range_flag);
-      }
-    }
-  }
-
-
-  if (has_alpha) {
-    assert(bytes_per_pixel == 4);
-
-    for (int y = 0; y < height; y++) {
-      for (int x = 0; x < width; x++) {
-        uint8_t a = in_p[y * in_stride + x * 4 + 3];
-
-        // alpha
-        out_a[y * out_a_stride + x] = a;
-      }
-    }
-  }
-
-  return outimg;
-}
-
-
-class Op_RGB24_32_to_YCbCr444_GBR : public ColorConversionOperation
-{
-public:
-  std::vector<ColorStateWithCost>
-  state_after_conversion(ColorState input_state,
-                         ColorState target_state,
-                         ColorConversionOptions options) override;
-
-  std::shared_ptr<HeifPixelImage>
-  convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
-                     ColorState target_state,
-                     ColorConversionOptions options) override;
-};
-
-
-std::vector<ColorStateWithCost>
-Op_RGB24_32_to_YCbCr444_GBR::state_after_conversion(ColorState input_state,
-                                                    ColorState target_state,
-                                                    ColorConversionOptions options)
-{
-  // Note: no input alpha channel required. It will be filled up with 0xFF.
-
-  if (input_state.colorspace != heif_colorspace_RGB ||
-      (input_state.chroma != heif_chroma_interleaved_RGB &&
-       input_state.chroma != heif_chroma_interleaved_RGBA)) {
-    return {};
-  }
-
-  if (!target_state.nclx_profile) {
-    return {};
-  }
-
-  if (target_state.nclx_profile->get_matrix_coefficients() != 0) {
-    return {};
-  }
-
-  if (input_state.nclx_profile && !input_state.nclx_profile->get_full_range_flag()) {
-    return {};
-  }
-
-  std::vector<ColorStateWithCost> states;
-
-  ColorState output_state;
-  ColorConversionCosts costs;
-
-  // --- convert RGB24
-
-  if (input_state.chroma == heif_chroma_interleaved_RGB) {
-    output_state.colorspace = heif_colorspace_YCbCr;
-    output_state.chroma = heif_chroma_444;
-    output_state.has_alpha = false;
-    output_state.bits_per_pixel = 8;
-
-    costs = {0.75f, 0.5f, 0.0f};  // quality not good since we subsample chroma without filtering
-
-    states.push_back({output_state, costs});
-  }
-
-
-  // --- convert RGB32
-
-  if (input_state.chroma == heif_chroma_interleaved_RGBA) {
-    output_state.colorspace = heif_colorspace_YCbCr;
-    output_state.chroma = heif_chroma_444;
-    output_state.has_alpha = true;
-    output_state.bits_per_pixel = 8;
-
-    costs = {0.75f, 0.5f, 0.0f};  // quality not good since we subsample chroma without filtering
-
-    states.push_back({output_state, costs});
-  }
-
-  return states;
-}
-
-
-std::shared_ptr<HeifPixelImage>
-Op_RGB24_32_to_YCbCr444_GBR::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
-                                                ColorState target_state,
-                                                ColorConversionOptions options)
-{
-  int width = input->get_width();
-  int height = input->get_height();
-
-  auto outimg = std::make_shared<HeifPixelImage>();
-
-  outimg->create(width, height, heif_colorspace_YCbCr, heif_chroma_444);
-
-  const bool has_alpha = (input->get_chroma_format() == heif_chroma_interleaved_32bit);
-
-  outimg->add_plane(heif_channel_Y, width, height, 8);
-  outimg->add_plane(heif_channel_Cb, width, height, 8);
-  outimg->add_plane(heif_channel_Cr, width, height, 8);
-
-  if (has_alpha) {
-    outimg->add_plane(heif_channel_Alpha, width, height, 8);
-  }
-
-  uint8_t* out_cb, * out_cr, * out_y, * out_a;
-  int out_cb_stride = 0, out_cr_stride = 0, out_y_stride = 0, out_a_stride = 0;
-
-  const uint8_t* in_p;
-  int in_stride = 0;
-
-  in_p = input->get_plane(heif_channel_interleaved, &in_stride);
-
-  out_y = outimg->get_plane(heif_channel_Y, &out_y_stride);
-  out_cb = outimg->get_plane(heif_channel_Cb, &out_cb_stride);
-  out_cr = outimg->get_plane(heif_channel_Cr, &out_cr_stride);
-
-  if (has_alpha) {
-    out_a = outimg->get_plane(heif_channel_Alpha, &out_a_stride);
-  }
-
-
-  assert(target_state.nclx_profile);
-  assert(target_state.nclx_profile->get_matrix_coefficients() == 0);
-
-
-  if (!has_alpha) {
-    for (int y = 0; y < height; y++) {
-      for (int x = 0; x < width; x++) {
-        uint8_t r = in_p[y * in_stride + x * 3 + 0];
-        uint8_t g = in_p[y * in_stride + x * 3 + 1];
-        uint8_t b = in_p[y * in_stride + x * 3 + 2];
-
-        out_y[y * out_y_stride + x] = g;
-        out_cb[y * out_cb_stride + x] = b;
-        out_cr[y * out_cr_stride + x] = r;
-      }
-    }
-  }
-  else {
-    for (int y = 0; y < height; y++) {
-      for (int x = 0; x < width; x++) {
-        uint8_t r = in_p[y * in_stride + x * 4 + 0];
-        uint8_t g = in_p[y * in_stride + x * 4 + 1];
-        uint8_t b = in_p[y * in_stride + x * 4 + 2];
-        uint8_t a = in_p[y * in_stride + x * 4 + 3];
-
-        out_y[y * out_y_stride + x] = g;
-        out_cb[y * out_cb_stride + x] = b;
-        out_cr[y * out_cr_stride + x] = r;
-
-        // alpha
-        out_a[y * out_a_stride + x] = a;
-      }
-    }
-  }
-
-  return outimg;
-}
-
-
-class Op_drop_alpha_plane : public ColorConversionOperation
-{
-public:
-  std::vector<ColorStateWithCost>
-  state_after_conversion(ColorState input_state,
-                         ColorState target_state,
-                         ColorConversionOptions options) override;
-
-  std::shared_ptr<HeifPixelImage>
-  convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
-                     ColorState target_state,
-                     ColorConversionOptions options) override;
-};
-
-
-std::vector<ColorStateWithCost>
-Op_drop_alpha_plane::state_after_conversion(ColorState input_state,
-                                            ColorState target_state,
-                                            ColorConversionOptions options)
-{
-  // only drop alpha plane if it is not needed in output
-
-  if ((input_state.chroma != heif_chroma_monochrome &&
-       input_state.chroma != heif_chroma_420 &&
-       input_state.chroma != heif_chroma_422 &&
-       input_state.chroma != heif_chroma_444) ||
-      input_state.has_alpha == false ||
-      target_state.has_alpha == true) {
-    return {};
-  }
-
-  std::vector<ColorStateWithCost> states;
-
-  ColorState output_state;
-  ColorConversionCosts costs;
-
-  // --- drop alpha plane
-
-  output_state = input_state;
-  output_state.has_alpha = false;
-
-  costs = {0.1f, 0.0f, 0.0f};
-
-  states.push_back({output_state, costs});
-
-  return states;
-}
-
-
-std::shared_ptr<HeifPixelImage>
-Op_drop_alpha_plane::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
-                                        ColorState target_state,
-                                        ColorConversionOptions options)
-{
-  int width = input->get_width();
-  int height = input->get_height();
-
-  auto outimg = std::make_shared<HeifPixelImage>();
-
-  outimg->create(width, height,
-                 input->get_colorspace(),
-                 input->get_chroma_format());
-
-  for (heif_channel channel : {heif_channel_Y,
-                               heif_channel_Cb,
-                               heif_channel_Cr,
-                               heif_channel_R,
-                               heif_channel_G,
-                               heif_channel_B}) {
-    if (input->has_channel(channel)) {
-      outimg->copy_new_plane_from(input, channel, channel);
-    }
-  }
-
-  return outimg;
-}
-
-
-class Op_to_hdr_planes : public ColorConversionOperation
-{
-public:
-  std::vector<ColorStateWithCost>
-  state_after_conversion(ColorState input_state,
-                         ColorState target_state,
-                         ColorConversionOptions options) override;
-
-  std::shared_ptr<HeifPixelImage>
-  convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
-                     ColorState target_state,
-                     ColorConversionOptions options) override;
-};
-
-
-std::vector<ColorStateWithCost>
-Op_to_hdr_planes::state_after_conversion(ColorState input_state,
-                                         ColorState target_state,
-                                         ColorConversionOptions options)
-{
-  if ((input_state.chroma != heif_chroma_monochrome &&
-       input_state.chroma != heif_chroma_420 &&
-       input_state.chroma != heif_chroma_422 &&
-       input_state.chroma != heif_chroma_444) ||
-      input_state.bits_per_pixel != 8) {
-    return {};
-  }
-
-  std::vector<ColorStateWithCost> states;
-
-  ColorState output_state;
-  ColorConversionCosts costs;
-
-  // --- increase bit depth
-
-  output_state = input_state;
-  output_state.bits_per_pixel = target_state.bits_per_pixel;
-
-  costs = {0.2f, 0.0f, 0.5f};
-
-  states.push_back({output_state, costs});
-
-  return states;
-}
-
-
-std::shared_ptr<HeifPixelImage>
-Op_to_hdr_planes::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
-                                     ColorState target_state,
-                                     ColorConversionOptions options)
-{
-  auto outimg = std::make_shared<HeifPixelImage>();
-
-  outimg->create(input->get_width(),
-                 input->get_height(),
-                 input->get_colorspace(),
-                 input->get_chroma_format());
-
-  for (heif_channel channel : {heif_channel_Y,
-                               heif_channel_Cb,
-                               heif_channel_Cr,
-                               heif_channel_R,
-                               heif_channel_G,
-                               heif_channel_B,
-                               heif_channel_Alpha}) {
-    if (input->has_channel(channel)) {
-      int width = input->get_width(channel);
-      int height = input->get_height(channel);
-      outimg->add_plane(channel, width, height, target_state.bits_per_pixel);
-
-      int input_bits = input->get_bits_per_pixel(channel);
-      int output_bits = target_state.bits_per_pixel;
-
-      int shift1 = output_bits - input_bits;
-      int shift2 = 8 - shift1;
-
-      const uint8_t* p_in;
-      int stride_in;
-      p_in = input->get_plane(channel, &stride_in);
-
-      uint16_t* p_out;
-      int stride_out;
-      p_out = (uint16_t*) outimg->get_plane(channel, &stride_out);
-      stride_out /= 2;
-
-      for (int y = 0; y < height; y++)
-        for (int x = 0; x < width; x++) {
-          int in = p_in[y * stride_in + x];
-          p_out[y * stride_out + x] = (uint16_t) ((in << shift1) | (in >> shift2));
-        }
-    }
-  }
-
-  return outimg;
-}
-
-
-class Op_to_sdr_planes : public ColorConversionOperation
-{
-public:
-  std::vector<ColorStateWithCost>
-  state_after_conversion(ColorState input_state,
-                         ColorState target_state,
-                         ColorConversionOptions options) override;
-
-  std::shared_ptr<HeifPixelImage>
-  convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
-                     ColorState target_state,
-                     ColorConversionOptions options) override;
-};
-
-
-std::vector<ColorStateWithCost>
-Op_to_sdr_planes::state_after_conversion(ColorState input_state,
-                                         ColorState target_state,
-                                         ColorConversionOptions options)
-{
-  if ((input_state.chroma != heif_chroma_monochrome &&
-       input_state.chroma != heif_chroma_420 &&
-       input_state.chroma != heif_chroma_422 &&
-       input_state.chroma != heif_chroma_444) ||
-      input_state.bits_per_pixel == 8) {
-    return {};
-  }
-
-  std::vector<ColorStateWithCost> states;
-
-  ColorState output_state;
-  ColorConversionCosts costs;
-
-  // --- decrease bit depth
-
-  output_state = input_state;
-  output_state.bits_per_pixel = 8;
-
-  costs = {0.2f, 0.0f, 0.5f};
-
-  states.push_back({output_state, costs});
-
-  return states;
-}
-
-
-std::shared_ptr<HeifPixelImage>
-Op_to_sdr_planes::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
-                                     ColorState target_state,
-                                     ColorConversionOptions options)
-{
-
-  auto outimg = std::make_shared<HeifPixelImage>();
-
-  outimg->create(input->get_width(),
-                 input->get_height(),
-                 input->get_colorspace(),
-                 input->get_chroma_format());
-
-  for (heif_channel channel : {heif_channel_Y,
-                               heif_channel_Cb,
-                               heif_channel_Cr,
-                               heif_channel_R,
-                               heif_channel_G,
-                               heif_channel_B,
-                               heif_channel_Alpha}) {
-    if (input->has_channel(channel)) {
-      int input_bits = input->get_bits_per_pixel(channel);
-
-      if (input_bits > 8) {
-        int width = input->get_width(channel);
-        int height = input->get_height(channel);
-        outimg->add_plane(channel, width, height, 8);
-
-        int shift = input_bits - 8;
-
-        const uint16_t* p_in;
-        int stride_in;
-        p_in = (uint16_t*) input->get_plane(channel, &stride_in);
-        stride_in /= 2;
-
-        uint8_t* p_out;
-        int stride_out;
-        p_out = outimg->get_plane(channel, &stride_out);
-
-        for (int y = 0; y < height; y++)
-          for (int x = 0; x < width; x++) {
-            int in = p_in[y * stride_in + x];
-            p_out[y * stride_out + x] = (uint8_t) (in >> shift); // TODO: I think no rounding here, but am not sure.
-          }
-      }
-      else {
-        outimg->copy_new_plane_from(input, channel, channel);
-      }
-    }
-  }
-
-  return outimg;
-}
-
-
-class Op_RRGGBBxx_HDR_to_YCbCr420 : public ColorConversionOperation
-{
-public:
-  std::vector<ColorStateWithCost>
-  state_after_conversion(ColorState input_state,
-                         ColorState target_state,
-                         ColorConversionOptions options) override;
-
-  std::shared_ptr<HeifPixelImage>
-  convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
-                     ColorState target_state,
-                     ColorConversionOptions options) override;
-};
-
-
-std::vector<ColorStateWithCost>
-Op_RRGGBBxx_HDR_to_YCbCr420::state_after_conversion(ColorState input_state,
-                                                    ColorState target_state,
-                                                    ColorConversionOptions options)
-{
-  if (input_state.colorspace != heif_colorspace_RGB ||
-      !(input_state.chroma == heif_chroma_interleaved_RRGGBB_BE ||
-        input_state.chroma == heif_chroma_interleaved_RRGGBB_LE ||
-        input_state.chroma == heif_chroma_interleaved_RRGGBBAA_BE ||
-        input_state.chroma == heif_chroma_interleaved_RRGGBBAA_LE) ||
-      input_state.bits_per_pixel == 8) {
-    return {};
-  }
-
-  if (input_state.nclx_profile) {
-    int matrix = input_state.nclx_profile->get_matrix_coefficients();
-    if (matrix == 0 || matrix == 8 || matrix == 11 || matrix == 14) {
-      return {};
-    }
-    if (!input_state.nclx_profile->get_full_range_flag()) {
-      return {};
-    }
-  }
-
-
-  std::vector<ColorStateWithCost> states;
-
-  ColorState output_state;
-  ColorConversionCosts costs;
-
-  // --- convert to YCbCr
-
-  output_state.colorspace = heif_colorspace_YCbCr;
-  output_state.chroma = heif_chroma_420;
-  output_state.has_alpha = input_state.has_alpha;  // we generate an alpha plane if the source contains data
-  output_state.bits_per_pixel = input_state.bits_per_pixel;
-
-  costs = {0.5f, 0.0f, 0.0f};
-
-  states.push_back({output_state, costs});
-
-  return states;
-}
-
-
-std::shared_ptr<HeifPixelImage>
-Op_RRGGBBxx_HDR_to_YCbCr420::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
-                                                ColorState target_state,
-                                                ColorConversionOptions options)
-{
-  int width = input->get_width();
-  int height = input->get_height();
-
-  int bpp = input->get_bits_per_pixel(heif_channel_interleaved);
-
-  bool has_alpha = (input->get_chroma_format() == heif_chroma_interleaved_RRGGBBAA_BE ||
-                    input->get_chroma_format() == heif_chroma_interleaved_RRGGBBAA_LE);
-
-  auto outimg = std::make_shared<HeifPixelImage>();
-
-  outimg->create(width, height, heif_colorspace_YCbCr, heif_chroma_420);
-
-  int bytesPerPixel = has_alpha ? 8 : 6;
-
-  int cwidth = (width + 1) / 2;
-  int cheight = (height + 1) / 2;
-
-  outimg->add_plane(heif_channel_Y, width, height, bpp);
-  outimg->add_plane(heif_channel_Cb, cwidth, cheight, bpp);
-  outimg->add_plane(heif_channel_Cr, cwidth, cheight, bpp);
-
-  if (has_alpha) {
-    outimg->add_plane(heif_channel_Alpha, width, height, bpp);
-  }
-
-  const uint8_t* in_p;
-  int in_p_stride = 0;
-
-  uint16_t* out_y, * out_cb, * out_cr, * out_a = nullptr;
-  int out_y_stride = 0, out_cb_stride = 0, out_cr_stride = 0, out_a_stride = 0;
-
-  in_p = input->get_plane(heif_channel_interleaved, &in_p_stride);
-  out_y = (uint16_t*) outimg->get_plane(heif_channel_Y, &out_y_stride);
-  out_cb = (uint16_t*) outimg->get_plane(heif_channel_Cb, &out_cb_stride);
-  out_cr = (uint16_t*) outimg->get_plane(heif_channel_Cr, &out_cr_stride);
-
-  if (has_alpha) {
-    out_a = (uint16_t*) outimg->get_plane(heif_channel_Alpha, &out_a_stride);
-  }
-
-
-  // adapt stride as we are pointing to 16bit integers
-  out_y_stride /= 2;
-  out_cb_stride /= 2;
-  out_cr_stride /= 2;
-  out_a_stride /= 2;
-
-  uint16_t halfRange = (uint16_t) (1 << (bpp - 1));
-  int32_t fullRange = (1 << bpp) - 1;
-
-  // le=1 for little endian, le=0 for big endian
-  int le = (input->get_chroma_format() == heif_chroma_interleaved_RRGGBBAA_LE ||
-            input->get_chroma_format() == heif_chroma_interleaved_RRGGBB_LE) ? 1 : 0;
-
-  auto colorProfile = input->get_color_profile_nclx();
-  RGB_to_YCbCr_coefficients coeffs = RGB_to_YCbCr_coefficients::defaults();
-  bool full_range_flag = true;
-  if (colorProfile) {
-    full_range_flag = target_state.nclx_profile->get_full_range_flag();
-    coeffs = heif::get_RGB_to_YCbCr_coefficients(colorProfile->get_matrix_coefficients(),
-                                                 colorProfile->get_colour_primaries());
-  }
-
-  for (int y = 0; y < height; y++) {
-    for (int x = 0; x < width; x++) {
-
-      const uint8_t* in = &in_p[y * in_p_stride + bytesPerPixel * x];
-
-      float r = static_cast<float>((in[0 + le] << 8) | in[1 - le]);
-      float g = static_cast<float>((in[2 + le] << 8) | in[3 - le]);
-      float b = static_cast<float>((in[4 + le] << 8) | in[5 - le]);
-
-      float v = r * coeffs.c[0][0] + g * coeffs.c[0][1] + b * coeffs.c[0][2];
-
-      if (!full_range_flag) {
-        v = v * 0.85547f + 16;  // 0.85547 = 219/256
-      }
-
-      out_y[y * out_y_stride + x] = clip_f_u16(v, fullRange);
-
-      if (has_alpha) {
-        uint16_t a = (uint16_t) ((in[6 + le] << 8) | in[7 - le]);
-        out_a[y * out_a_stride + x] = a;
-      }
-    }
-  }
-
-  for (int y = 0; y < height; y += 2) {
-    for (int x = 0; x < width; x += 2) {
-      const uint8_t* in = &in_p[y * in_p_stride + bytesPerPixel * x];
-
-      float r = static_cast<float>((in[0 + le] << 8) | in[1 - le]);
-      float g = static_cast<float>((in[2 + le] << 8) | in[3 - le]);
-      float b = static_cast<float>((in[4 + le] << 8) | in[5 - le]);
-
-      int dx = (x + 1 < width) ? bytesPerPixel : 0;
-      int dy = (y + 1 < height) ? in_p_stride : 0;
-
-      r += static_cast<float>((in[0 + le + dx] << 8) | in[1 - le + dx]);
-      g += static_cast<float>((in[2 + le + dx] << 8) | in[3 - le + dx]);
-      b += static_cast<float>((in[4 + le + dx] << 8) | in[5 - le + dx]);
-
-      r += static_cast<float>((in[0 + le + dy] << 8) | in[1 - le + dy]);
-      g += static_cast<float>((in[2 + le + dy] << 8) | in[3 - le + dy]);
-      b += static_cast<float>((in[4 + le + dy] << 8) | in[5 - le + dy]);
-
-      r += static_cast<float>((in[0 + le + dx + dy] << 8) | in[1 - le + dx + dy]);
-      g += static_cast<float>((in[2 + le + dx + dy] << 8) | in[3 - le + dx + dy]);
-      b += static_cast<float>((in[4 + le + dx + dy] << 8) | in[5 - le + dx + dy]);
-
-      r *= 0.25f;
-      g *= 0.25f;
-      b *= 0.25f;
-
-      float cb = r * coeffs.c[1][0] + g * coeffs.c[1][1] + b * coeffs.c[1][2];
-      float cr = r * coeffs.c[2][0] + g * coeffs.c[2][1] + b * coeffs.c[2][2];
-
-      if (!full_range_flag) {
-        cb = cb * 0.85547f;  // 0.85547 = 219/256
-        cr = cr * 0.85547f;  // 0.85547 = 219/256
-      }
-
-      out_cb[(y / 2) * out_cb_stride + (x / 2)] = clip_f_u16(halfRange + cb, fullRange);
-      out_cr[(y / 2) * out_cr_stride + (x / 2)] = clip_f_u16(halfRange + cr, fullRange);
-    }
-  }
-
-
-  return outimg;
-}
-
-
-class Op_YCbCr420_to_RRGGBBaa : public ColorConversionOperation
-{
-public:
-  std::vector<ColorStateWithCost>
-  state_after_conversion(ColorState input_state,
-                         ColorState target_state,
-                         ColorConversionOptions options) override;
-
-  std::shared_ptr<HeifPixelImage>
-  convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
-                     ColorState target_state,
-                     ColorConversionOptions options) override;
-};
-
-
-std::vector<ColorStateWithCost>
-Op_YCbCr420_to_RRGGBBaa::state_after_conversion(ColorState input_state,
-                                                ColorState target_state,
-                                                ColorConversionOptions options)
-{
-  if (input_state.colorspace != heif_colorspace_YCbCr ||
-      input_state.chroma != heif_chroma_420 ||
-      input_state.bits_per_pixel == 8) {
-    return {};
-  }
-
-  if (input_state.nclx_profile) {
-    int matrix = input_state.nclx_profile->get_matrix_coefficients();
-    if (matrix == 0 || matrix == 8 || matrix == 11 || matrix == 14) {
-      return {};
-    }
-  }
-
-  std::vector<ColorStateWithCost> states;
-
-  ColorState output_state;
-  ColorConversionCosts costs;
-
-  // --- convert to YCbCr
-
-  output_state.colorspace = heif_colorspace_RGB;
-  output_state.chroma = (input_state.has_alpha ?
-                         heif_chroma_interleaved_RRGGBBAA_LE : heif_chroma_interleaved_RRGGBB_LE);
-  output_state.has_alpha = input_state.has_alpha;
-  output_state.bits_per_pixel = input_state.bits_per_pixel;
-
-  costs = {0.5f, 0.0f, 0.0f};
-
-  states.push_back({output_state, costs});
-
-
-  output_state.colorspace = heif_colorspace_RGB;
-  output_state.chroma = (input_state.has_alpha ?
-                         heif_chroma_interleaved_RRGGBBAA_BE : heif_chroma_interleaved_RRGGBB_BE);
-  output_state.has_alpha = input_state.has_alpha;
-  output_state.bits_per_pixel = input_state.bits_per_pixel;
-
-  costs = {0.5f, 0.0f, 0.0f};
-
-  states.push_back({output_state, costs});
-
-  return states;
-}
-
-
-std::shared_ptr<HeifPixelImage>
-Op_YCbCr420_to_RRGGBBaa::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
-                                            ColorState target_state,
-                                            ColorConversionOptions options)
-{
-  int width = input->get_width();
-  int height = input->get_height();
-
-  int bpp = input->get_bits_per_pixel(heif_channel_Y);
-  bool has_alpha = input->has_channel(heif_channel_Alpha);
-
-  int le = (target_state.chroma == heif_chroma_interleaved_RRGGBB_LE ||
-            target_state.chroma == heif_chroma_interleaved_RRGGBBAA_LE) ? 1 : 0;
-
-  auto outimg = std::make_shared<HeifPixelImage>();
-  outimg->create(width, height, heif_colorspace_RGB, target_state.chroma);
-
-  int bytesPerPixel = has_alpha ? 8 : 6;
-
-  outimg->add_plane(heif_channel_interleaved, width, height, bpp);
-
-  if (has_alpha) {
-    outimg->add_plane(heif_channel_Alpha, width, height, bpp);
-  }
-
-  uint8_t* out_p;
-  int out_p_stride = 0;
-
-  const uint16_t* in_y, * in_cb, * in_cr, * in_a = nullptr;
-  int in_y_stride = 0, in_cb_stride = 0, in_cr_stride = 0, in_a_stride = 0;
-
-  out_p = outimg->get_plane(heif_channel_interleaved, &out_p_stride);
-  in_y = (uint16_t*) input->get_plane(heif_channel_Y, &in_y_stride);
-  in_cb = (uint16_t*) input->get_plane(heif_channel_Cb, &in_cb_stride);
-  in_cr = (uint16_t*) input->get_plane(heif_channel_Cr, &in_cr_stride);
-
-  if (has_alpha) {
-    in_a = (uint16_t*) input->get_plane(heif_channel_Alpha, &in_a_stride);
-  }
-
-  int maxval = (1 << bpp) - 1;
-
-  bool full_range_flag = true;
-  YCbCr_to_RGB_coefficients coeffs = YCbCr_to_RGB_coefficients::defaults();
-
-  auto colorProfile = input->get_color_profile_nclx();
-  if (colorProfile) {
-    full_range_flag = colorProfile->get_full_range_flag();
-    coeffs = heif::get_YCbCr_to_RGB_coefficients(colorProfile->get_matrix_coefficients(),
-                                                 colorProfile->get_colour_primaries());
-  }
-
-  for (int y = 0; y < height; y++) {
-    for (int x = 0; x < width; x++) {
-
-      float y_ = in_y[y * in_y_stride / 2 + x];
-      float cb = static_cast<float>(in_cb[y / 2 * in_cb_stride / 2 + x / 2] - (1 << (bpp - 1)));
-      float cr = static_cast<float>(in_cr[y / 2 * in_cr_stride / 2 + x / 2] - (1 << (bpp - 1)));
-
-      if (!full_range_flag) {
-        y_ = (y_ - 16) * 1.1689f;
-        cb = cb * 1.1429f;
-        cr = cr * 1.1429f;
-      }
-
-      int r = clip_f_u16(y_ + coeffs.r_cr * cr, maxval);
-      int g = clip_f_u16(y_ + coeffs.g_cb * cb - coeffs.g_cr * cr, maxval);
-      int b = clip_f_u16(y_ + coeffs.b_cb * cb, maxval);
-
-      out_p[y * out_p_stride + bytesPerPixel * x + 0 + le] = (uint8_t) (r >> 8);
-      out_p[y * out_p_stride + bytesPerPixel * x + 2 + le] = (uint8_t) (g >> 8);
-      out_p[y * out_p_stride + bytesPerPixel * x + 4 + le] = (uint8_t) (b >> 8);
-
-      out_p[y * out_p_stride + bytesPerPixel * x + 1 - le] = (uint8_t) (r & 0xff);
-      out_p[y * out_p_stride + bytesPerPixel * x + 3 - le] = (uint8_t) (g & 0xff);
-      out_p[y * out_p_stride + bytesPerPixel * x + 5 - le] = (uint8_t) (b & 0xff);
-
-      if (has_alpha) {
-        out_p[y * out_p_stride + 8 * x + 6 + le] = (uint8_t) (in_a[y * in_a_stride / 2 + x] >> 8);
-        out_p[y * out_p_stride + 8 * x + 7 - le] = (uint8_t) (in_a[y * in_a_stride / 2 + x] & 0xff);
-      }
-    }
-  }
-
-
-  return outimg;
-}
-
-
-struct Node
-{
-  Node() = default;
-
-  Node(int prev, const std::shared_ptr<ColorConversionOperation>& _op, ColorStateWithCost state)
-  {
-    prev_processed_idx = prev;
-    op = _op;
-    color_state = state;
-  }
-
-  int prev_processed_idx = -1;
-  std::shared_ptr<ColorConversionOperation> op;
-  ColorStateWithCost color_state;
-};
-
-
-bool ColorConversionPipeline::construct_pipeline(ColorState input_state,
-                                                 ColorState target_state,
-                                                 ColorConversionOptions options)
-{
-  m_operations.clear();
-
-  m_target_state = target_state;
-  m_options = options;
-
-  if (input_state == target_state) {
-    return true;
-  }
-
-#if DEBUG_ME
-  std::cerr << "--- construct_pipeline\n";
-  std::cerr << "from: ";
-  print_state(std::cerr, input_state);
-  std::cerr << "to: ";
-  print_state(std::cerr, target_state);
-#endif
-
-  std::vector<std::shared_ptr<ColorConversionOperation>> ops;
-  ops.push_back(std::make_shared<Op_RGB_to_RGB24_32>());
-  ops.push_back(std::make_shared<Op_YCbCr_to_RGB<uint16_t>>());
-  ops.push_back(std::make_shared<Op_YCbCr_to_RGB<uint8_t>>());
-  ops.push_back(std::make_shared<Op_YCbCr420_to_RGB24>());
-  ops.push_back(std::make_shared<Op_YCbCr420_to_RGB32>());
-  ops.push_back(std::make_shared<Op_YCbCr420_to_RRGGBBaa>());
-  ops.push_back(std::make_shared<Op_RGB_HDR_to_RRGGBBaa_BE>());
-  ops.push_back(std::make_shared<Op_RGB_to_RRGGBBaa_BE>());
-  ops.push_back(std::make_shared<Op_mono_to_YCbCr420>());
-  ops.push_back(std::make_shared<Op_mono_to_RGB24_32>());
-  ops.push_back(std::make_shared<Op_RRGGBBaa_swap_endianness>());
-  ops.push_back(std::make_shared<Op_RRGGBBaa_BE_to_RGB_HDR>());
-  ops.push_back(std::make_shared<Op_RGB24_32_to_YCbCr>());
-  ops.push_back(std::make_shared<Op_RGB24_32_to_YCbCr444_GBR>());
-  ops.push_back(std::make_shared<Op_RGB_to_YCbCr<uint8_t>>());
-  ops.push_back(std::make_shared<Op_RGB_to_YCbCr<uint16_t>>());
-  ops.push_back(std::make_shared<Op_drop_alpha_plane>());
-  ops.push_back(std::make_shared<Op_to_hdr_planes>());
-  ops.push_back(std::make_shared<Op_to_sdr_planes>());
-  ops.push_back(std::make_shared<Op_RRGGBBxx_HDR_to_YCbCr420>());
-
-
-  // --- Dijkstra search for the minimum-cost conversion pipeline
-
-  std::vector<Node> processed_states;
-  std::vector<Node> border_states;
-  border_states.push_back({-1, nullptr, {input_state, ColorConversionCosts()}});
-
-  while (!border_states.empty()) {
-    size_t minIdx = -1;
-    float minCost;
-    for (size_t i = 0; i < border_states.size(); i++) {
-      float cost = border_states[i].color_state.costs.total(options.criterion);
-      if (i == 0 || cost < minCost) {
-        minIdx = i;
-        minCost = cost;
-      }
-    }
-
-    assert(minIdx >= 0);
-
-
-    // move minimum-cost border_state into processed_states
-
-    processed_states.push_back(border_states[minIdx]);
-
-    border_states[minIdx] = border_states.back();
-    border_states.pop_back();
-
-#if DEBUG_PIPELINE_CREATION
-    std::cerr << "- expand node: ";
-    print_state(std::cerr, processed_states.back().color_state.color_state);
-#endif
-
-    if (processed_states.back().color_state.color_state == target_state) {
-      // end-state found, backtrack path to find conversion pipeline
-
-      size_t idx = processed_states.size() - 1;
-      int len = 0;
-      while (idx > 0) {
-        idx = processed_states[idx].prev_processed_idx;
-        len++;
-      }
-
-      m_operations.resize(len);
-
-      idx = processed_states.size() - 1;
-      int step = 0;
-      while (idx > 0) {
-        m_operations[len - 1 - step] = processed_states[idx].op;
-        //printf("cost: %f\n",processed_states[idx].color_state.costs.total(options.criterion));
-        idx = processed_states[idx].prev_processed_idx;
-        step++;
-      }
-
-#if DEBUG_ME
-      debug_dump_pipeline();
-#endif
-
-      return true;
-    }
-
-
-    // expand the node with minimum cost
-
-    for (const auto& op_ptr : ops) {
-
-#if DEBUG_PIPELINE_CREATION
-      auto& op = *op_ptr;
-      std::cerr << "-- apply op: " << typeid(op).name() << "\n";
-#endif
-
-      auto out_states = op_ptr->state_after_conversion(processed_states.back().color_state.color_state,
-                                                       target_state,
-                                                       options);
-      for (const auto& out_state : out_states) {
-#if DEBUG_PIPELINE_CREATION
-        std::cerr << "--- ";
-        print_state(std::cerr, out_state.color_state);
-#endif
-
-        bool state_exists = false;
-        for (const auto& s : processed_states) {
-          if (s.color_state.color_state == out_state.color_state) {
-            state_exists = true;
-            break;
-          }
-        }
-
-        if (!state_exists) {
-          for (auto& s : border_states) {
-            if (s.color_state.color_state == out_state.color_state) {
-              state_exists = true;
-
-              // if we reached the same border node with a lower cost, replace the border node
-
-              ColorConversionCosts new_op_costs = out_state.costs + processed_states.back().color_state.costs;
-
-              if (s.color_state.costs.total(options.criterion) > new_op_costs.total(options.criterion)) {
-                s = {(int) (processed_states.size() - 1),
-                     op_ptr,
-                     out_state};
-
-                s.color_state.costs = new_op_costs;
-              }
-              break;
-            }
-          }
-        }
-
-
-        // enter the new output state into the list of border states
-
-        if (!state_exists) {
-          ColorStateWithCost s = out_state;
-          s.costs = s.costs + processed_states.back().color_state.costs;
-
-          border_states.push_back({(int) (processed_states.size() - 1), op_ptr, s});
-        }
-      }
-    }
-  }
-
-  return false;
-}
-
-
-void ColorConversionPipeline::debug_dump_pipeline() const
-{
-  for (const auto& op_ptr : m_operations) {
-    auto& op = *op_ptr;
-    std::cerr << "> " << typeid(op).name() << "\n";
-  }
-}
-
-
-std::shared_ptr<HeifPixelImage> ColorConversionPipeline::convert_image(const std::shared_ptr<HeifPixelImage>& input)
-{
-  std::shared_ptr<HeifPixelImage> in = input;
-  std::shared_ptr<HeifPixelImage> out = in;
-
-  for (const auto& op_ptr : m_operations) {
-
-#if DEBUG_ME
-    std::cerr << "input spec: ";
-    print_spec(std::cerr, in);
-#endif
-
-    out = op_ptr->convert_colorspace(in, m_target_state, m_options);
-    if (!out) {
-      return nullptr; // TODO: we should return a proper error
-    }
-
-    // --- pass the color profiles to the new image
-
-    out->set_color_profile_nclx(m_target_state.nclx_profile);
-    out->set_color_profile_icc(in->get_color_profile_icc());
-
-    out->set_premultiplied_alpha(in->is_premultiplied_alpha());
-
-    in = out;
-  }
-
-  return out;
-}
-
-
-std::shared_ptr<HeifPixelImage> heif::convert_colorspace(const std::shared_ptr<HeifPixelImage>& input,
-                                                         heif_colorspace target_colorspace,
-                                                         heif_chroma target_chroma,
-                                                         std::shared_ptr<const color_profile_nclx> target_profile,
-                                                         int output_bpp)
-{
-  // --- check that input image is valid
-
-  int width = input->get_width();
-  int height = input->get_height();
-
-  // alpha image should have full image resolution
-
-  if (input->has_channel(heif_channel_Alpha)) {
-    if (input->get_width(heif_channel_Alpha) != width ||
-        input->get_height(heif_channel_Alpha) != height) {
-      return nullptr;
-    }
-  }
-
-  // check for valid target YCbCr chroma formats
-
-  if (target_colorspace == heif_colorspace_YCbCr) {
-    if (target_chroma != heif_chroma_monochrome &&
-        target_chroma != heif_chroma_420 &&
-        target_chroma != heif_chroma_422 &&
-        target_chroma != heif_chroma_444) {
-      return nullptr;
-    }
-  }
-
-  // --- prepare conversion
-
-  ColorState input_state;
-  input_state.colorspace = input->get_colorspace();
-  input_state.chroma = input->get_chroma_format();
-  input_state.has_alpha = input->has_channel(heif_channel_Alpha) || is_chroma_with_alpha(input->get_chroma_format());
-  input_state.nclx_profile = input->get_color_profile_nclx();
-
-  std::set<enum heif_channel> channels = input->get_channel_set();
-  assert(!channels.empty());
-  input_state.bits_per_pixel = input->get_bits_per_pixel(*(channels.begin()));
-
-  ColorState output_state = input_state;
-  output_state.colorspace = target_colorspace;
-  output_state.chroma = target_chroma;
-  output_state.nclx_profile = target_profile;
-
-  // If we convert to an interleaved format, we want alpha only if present in the
-  // interleaved output format.
-  // For planar formats, we include an alpha plane when included in the input.
-
-  if (num_interleaved_pixels_per_plane(target_chroma) > 1) {
-    output_state.has_alpha = is_chroma_with_alpha(target_chroma);
-  }
-  else {
-    output_state.has_alpha = input_state.has_alpha;
-  }
-
-  if (output_bpp) {
-    output_state.bits_per_pixel = output_bpp;
-  }
-
-
-  // interleaved RGB formats always have to be 8-bit
-
-  if (target_chroma == heif_chroma_interleaved_RGB ||
-      target_chroma == heif_chroma_interleaved_RGBA) {
-    output_state.bits_per_pixel = 8;
-  }
-
-  // interleaved RRGGBB formats have to be >8-bit.
-  // If we don't know a target bit-depth, use 10 bit.
-
-  if ((target_chroma == heif_chroma_interleaved_RRGGBB_LE ||
-       target_chroma == heif_chroma_interleaved_RRGGBB_BE ||
-       target_chroma == heif_chroma_interleaved_RRGGBBAA_LE ||
-       target_chroma == heif_chroma_interleaved_RRGGBBAA_BE) &&
-      output_state.bits_per_pixel <= 8) {
-    output_state.bits_per_pixel = 10;
-  }
-
-  ColorConversionPipeline pipeline;
-  bool success = pipeline.construct_pipeline(input_state, output_state);
-  if (!success) {
-    return nullptr;
-  }
-
-  return pipeline.convert_image(input);
-}
diff --git a/libheif/heif_colorconversion.h b/libheif/heif_colorconversion.h
deleted file mode 100644
index ff714e8cc6..0000000000
--- a/libheif/heif_colorconversion.h
+++ /dev/null
@@ -1,143 +0,0 @@
-/*
- * HEIF codec.
- * Copyright (c) 2017 struktur AG, Dirk Farin <farin@struktur.de>
- *
- * This file is part of libheif.
- *
- * libheif is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as
- * published by the Free Software Foundation, either version 3 of
- * the License, or (at your option) any later version.
- *
- * libheif is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-
-#include "heif_image.h"
-#include <memory>
-#include <vector>
-
-
-namespace heif {
-
-  struct ColorState
-  {
-    heif_colorspace colorspace = heif_colorspace_undefined;
-    heif_chroma chroma = heif_chroma_undefined;
-    bool has_alpha = false;
-    int bits_per_pixel = 8;
-    std::shared_ptr<const color_profile_nclx> nclx_profile;
-
-    ColorState() = default;
-
-    ColorState(heif_colorspace colorspace, heif_chroma chroma, bool has_alpha, int bits_per_pixel)
-        : colorspace(colorspace), chroma(chroma), has_alpha(has_alpha), bits_per_pixel(bits_per_pixel)
-    {}
-
-    bool operator==(const ColorState&) const;
-  };
-
-
-  enum class ColorConversionCriterion
-  {
-    Speed,
-    Quality,
-    Memory,
-    Balanced
-  };
-
-
-  struct ColorConversionCosts
-  {
-    ColorConversionCosts() = default;
-
-    ColorConversionCosts(float _speed, float _quality, float _memory)
-    {
-      speed = _speed;
-      quality = _quality;
-      memory = _memory;
-    }
-
-    float speed = 0;
-    float quality = 0;
-    float memory = 0;
-
-    ColorConversionCosts operator+(const ColorConversionCosts& b) const
-    {
-      return {speed + b.speed,
-              quality + b.quality,
-              memory + b.memory};
-    }
-
-    float total(ColorConversionCriterion) const
-    {
-      return speed * 0.3f + quality * 0.6f + memory * 0.1f;
-    }
-  };
-
-
-  struct ColorConversionOptions
-  {
-    ColorConversionCriterion criterion = ColorConversionCriterion::Balanced;
-  };
-
-
-  struct ColorStateWithCost
-  {
-    ColorState color_state;
-    ColorConversionCosts costs;
-  };
-
-
-  class ColorConversionOperation
-  {
-  public:
-    virtual ~ColorConversionOperation() = default;
-
-    // We specify the target state to control the conversion into a direction that is most
-    // suitable for reaching the target state. That allows one conversion operation to
-    // provide a range of conversion options.
-    // Also returns the cost for this conversion.
-    virtual std::vector<ColorStateWithCost>
-    state_after_conversion(ColorState input_state,
-                           ColorState target_state,
-                           ColorConversionOptions options = ColorConversionOptions()) = 0;
-
-    virtual std::shared_ptr<HeifPixelImage>
-    convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
-                       ColorState target_state,
-                       ColorConversionOptions options = ColorConversionOptions()) = 0;
-  };
-
-
-  class ColorConversionPipeline
-  {
-  public:
-    bool construct_pipeline(ColorState input_state,
-                            ColorState target_state,
-                            ColorConversionOptions options = ColorConversionOptions());
-
-    std::shared_ptr<HeifPixelImage>
-    convert_image(const std::shared_ptr<HeifPixelImage>& input);
-
-    void debug_dump_pipeline() const;
-
-  private:
-    std::vector<std::shared_ptr<ColorConversionOperation>> m_operations;
-    ColorState m_target_state;
-    ColorConversionOptions m_options;
-  };
-
-
-  std::shared_ptr<HeifPixelImage> convert_colorspace(const std::shared_ptr<HeifPixelImage>& input,
-                                                     heif_colorspace colorspace,
-                                                     heif_chroma chroma,
-                                                     std::shared_ptr<const color_profile_nclx> target_profile,
-                                                     int output_bpp = 0);
-}
diff --git a/libheif/heif_context.cc b/libheif/heif_context.cc
deleted file mode 100644
index d536c0f9c0..0000000000
--- a/libheif/heif_context.cc
+++ /dev/null
@@ -1,2493 +0,0 @@
-/*
- * HEIF codec.
- * Copyright (c) 2017 struktur AG, Dirk Farin <farin@struktur.de>
- *
- * This file is part of libheif.
- *
- * libheif is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as
- * published by the Free Software Foundation, either version 3 of
- * the License, or (at your option) any later version.
- *
- * libheif is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#if defined(HAVE_CONFIG_H)
-#include "config.h"
-#endif
-
-#include <cassert>
-#include <cstring>
-#include <algorithm>
-#include <iostream>
-#include <limits>
-#include <cmath>
-#include <deque>
-
-#if ENABLE_PARALLEL_TILE_DECODING
-#include <future>
-#endif
-
-#include "heif_context.h"
-#include "heif_file.h"
-#include "heif_image.h"
-#include "heif_api_structs.h"
-#include "heif_limits.h"
-#include "heif_hevc.h"
-#include "heif_avif.h"
-#include "heif_plugin_registry.h"
-#include "heif_colorconversion.h"
-
-using namespace heif;
-
-heif_encoder::heif_encoder(const struct heif_encoder_plugin* _plugin)
-    : plugin(_plugin)
-{
-
-}
-
-heif_encoder::~heif_encoder()
-{
-  release();
-}
-
-void heif_encoder::release()
-{
-  if (encoder) {
-    plugin->free_encoder(encoder);
-    encoder = nullptr;
-  }
-}
-
-
-struct heif_error heif_encoder::alloc()
-{
-  if (encoder == nullptr) {
-    struct heif_error error = plugin->new_encoder(&encoder);
-    // TODO: error handling
-    return error;
-  }
-
-  struct heif_error err = {heif_error_Ok, heif_suberror_Unspecified, kSuccess};
-  return err;
-}
-
-
-static int32_t readvec_signed(const std::vector<uint8_t>& data, int& ptr, int len)
-{
-  const uint32_t high_bit = 0x80 << ((len - 1) * 8);
-
-  uint32_t val = 0;
-  while (len--) {
-    val <<= 8;
-    val |= data[ptr++];
-  }
-
-  bool negative = (val & high_bit) != 0;
-  val &= ~high_bit;
-
-  if (negative) {
-    return -(high_bit - val);
-  }
-  else {
-    return val;
-  }
-
-  return val;
-}
-
-
-static uint32_t readvec(const std::vector<uint8_t>& data, int& ptr, int len)
-{
-  uint32_t val = 0;
-  while (len--) {
-    val <<= 8;
-    val |= data[ptr++];
-  }
-
-  return val;
-}
-
-
-class ImageGrid
-{
-public:
-  Error parse(const std::vector<uint8_t>& data);
-
-  std::vector<uint8_t> write() const;
-
-  std::string dump() const;
-
-  uint32_t get_width() const { return m_output_width; }
-
-  uint32_t get_height() const { return m_output_height; }
-
-  uint16_t get_rows() const
-  {
-    assert(m_rows <= 256);
-    return m_rows;
-  }
-
-  uint16_t get_columns() const
-  {
-    assert(m_columns <= 256);
-    return m_columns;
-  }
-
-  void set_num_tiles(uint16_t columns, uint16_t rows)
-  {
-    m_rows = rows;
-    m_columns = columns;
-  }
-
-  void set_output_size(uint32_t width, uint32_t height)
-  {
-    m_output_width = width;
-    m_output_height = height;
-  }
-
-private:
-  uint16_t m_rows = 0;
-  uint16_t m_columns = 0;
-  uint32_t m_output_width = 0;
-  uint32_t m_output_height = 0;
-};
-
-
-Error ImageGrid::parse(const std::vector<uint8_t>& data)
-{
-  if (data.size() < 8) {
-    return Error(heif_error_Invalid_input,
-                 heif_suberror_Invalid_grid_data,
-                 "Less than 8 bytes of data");
-  }
-
-  uint8_t version = data[0];
-  (void) version; // version is unused
-
-  uint8_t flags = data[1];
-  int field_size = ((flags & 1) ? 32 : 16);
-
-  m_rows = static_cast<uint16_t>(data[2] + 1);
-  m_columns = static_cast<uint16_t>(data[3] + 1);
-
-  if (field_size == 32) {
-    if (data.size() < 12) {
-      return Error(heif_error_Invalid_input,
-                   heif_suberror_Invalid_grid_data,
-                   "Grid image data incomplete");
-    }
-
-    m_output_width = ((data[4] << 24) |
-                      (data[5] << 16) |
-                      (data[6] << 8) |
-                      (data[7]));
-
-    m_output_height = ((data[8] << 24) |
-                       (data[9] << 16) |
-                       (data[10] << 8) |
-                       (data[11]));
-  }
-  else {
-    m_output_width = ((data[4] << 8) |
-                      (data[5]));
-
-    m_output_height = ((data[6] << 8) |
-                       (data[7]));
-  }
-
-  return Error::Ok;
-}
-
-
-std::vector<uint8_t> ImageGrid::write() const
-{
-  int field_size;
-
-  if (m_output_width > 0xFFFF ||
-      m_output_height > 0xFFFF) {
-    field_size = 32;
-  }
-  else {
-    field_size = 16;
-  }
-
-  std::vector<uint8_t> data(field_size == 16 ? 8 : 12);
-
-  data[0] = 0; // version
-
-  uint8_t flags = 0;
-  if (field_size == 32) {
-    flags |= 1;
-  }
-
-  data[1] = flags;
-  data[2] = (uint8_t) (m_rows - 1);
-  data[3] = (uint8_t) (m_columns - 1);
-
-  if (field_size == 32) {
-    data[4] = (uint8_t) ((m_output_width >> 24) & 0xFF);
-    data[5] = (uint8_t) ((m_output_width >> 16) & 0xFF);
-    data[6] = (uint8_t) ((m_output_width >> 8) & 0xFF);
-    data[7] = (uint8_t) ((m_output_width) & 0xFF);
-
-    data[8] = (uint8_t) ((m_output_height >> 24) & 0xFF);
-    data[9] = (uint8_t) ((m_output_height >> 16) & 0xFF);
-    data[10] = (uint8_t) ((m_output_height >> 8) & 0xFF);
-    data[11] = (uint8_t) ((m_output_height) & 0xFF);
-  }
-  else {
-    data[4] = (uint8_t) ((m_output_width >> 8) & 0xFF);
-    data[5] = (uint8_t) ((m_output_width) & 0xFF);
-
-    data[6] = (uint8_t) ((m_output_height >> 8) & 0xFF);
-    data[7] = (uint8_t) ((m_output_height) & 0xFF);
-  }
-
-  return data;
-}
-
-
-std::string ImageGrid::dump() const
-{
-  std::ostringstream sstr;
-
-  sstr << "rows: " << m_rows << "\n"
-       << "columns: " << m_columns << "\n"
-       << "output width: " << m_output_width << "\n"
-       << "output height: " << m_output_height << "\n";
-
-  return sstr.str();
-}
-
-
-class ImageOverlay
-{
-public:
-  Error parse(size_t num_images, const std::vector<uint8_t>& data);
-
-  std::string dump() const;
-
-  void get_background_color(uint16_t col[4]) const;
-
-  uint32_t get_canvas_width() const { return m_width; }
-
-  uint32_t get_canvas_height() const { return m_height; }
-
-  size_t get_num_offsets() const { return m_offsets.size(); }
-
-  void get_offset(size_t image_index, int32_t* x, int32_t* y) const;
-
-private:
-  uint8_t m_version;
-  uint8_t m_flags;
-  uint16_t m_background_color[4];
-  uint32_t m_width;
-  uint32_t m_height;
-
-  struct Offset
-  {
-    int32_t x, y;
-  };
-
-  std::vector<Offset> m_offsets;
-};
-
-
-Error ImageOverlay::parse(size_t num_images, const std::vector<uint8_t>& data)
-{
-  Error eofError(heif_error_Invalid_input,
-                 heif_suberror_Invalid_grid_data,
-                 "Overlay image data incomplete");
-
-  if (data.size() < 2 + 4 * 2) {
-    return eofError;
-  }
-
-  m_version = data[0];
-  m_flags = data[1];
-
-  if (m_version != 0) {
-    std::stringstream sstr;
-    sstr << "Overlay image data version " << ((int) m_version) << " is not implemented yet";
-
-    return Error(heif_error_Unsupported_feature,
-                 heif_suberror_Unsupported_data_version,
-                 sstr.str());
-  }
-
-  int field_len = ((m_flags & 1) ? 4 : 2);
-  int ptr = 2;
-
-  if (ptr + 4 * 2 + 2 * field_len + num_images * 2 * field_len > data.size()) {
-    return eofError;
-  }
-
-  for (int i = 0; i < 4; i++) {
-    uint16_t color = static_cast<uint16_t>(readvec(data, ptr, 2));
-    m_background_color[i] = color;
-  }
-
-  m_width = readvec(data, ptr, field_len);
-  m_height = readvec(data, ptr, field_len);
-
-  m_offsets.resize(num_images);
-
-  for (size_t i = 0; i < num_images; i++) {
-    m_offsets[i].x = readvec_signed(data, ptr, field_len);
-    m_offsets[i].y = readvec_signed(data, ptr, field_len);
-  }
-
-  return Error::Ok;
-}
-
-
-std::string ImageOverlay::dump() const
-{
-  std::stringstream sstr;
-
-  sstr << "version: " << ((int) m_version) << "\n"
-       << "flags: " << ((int) m_flags) << "\n"
-       << "background color: " << m_background_color[0]
-       << ";" << m_background_color[1]
-       << ";" << m_background_color[2]
-       << ";" << m_background_color[3] << "\n"
-       << "canvas size: " << m_width << "x" << m_height << "\n"
-       << "offsets: ";
-
-  for (const Offset& offset : m_offsets) {
-    sstr << offset.x << ";" << offset.y << " ";
-  }
-  sstr << "\n";
-
-  return sstr.str();
-}
-
-
-void ImageOverlay::get_background_color(uint16_t col[4]) const
-{
-  for (int i = 0; i < 4; i++) {
-    col[i] = m_background_color[i];
-  }
-}
-
-
-void ImageOverlay::get_offset(size_t image_index, int32_t* x, int32_t* y) const
-{
-  assert(image_index < m_offsets.size());
-  assert(x && y);
-
-  *x = m_offsets[image_index].x;
-  *y = m_offsets[image_index].y;
-}
-
-
-HeifContext::HeifContext()
-{
-  m_maximum_image_width_limit = MAX_IMAGE_WIDTH;
-  m_maximum_image_height_limit = MAX_IMAGE_HEIGHT;
-
-  reset_to_empty_heif();
-}
-
-HeifContext::~HeifContext()
-{
-  // Break circular references between Images (when a faulty input image has circular image references)
-  for (auto& it : m_all_images) {
-    std::shared_ptr<Image> image = it.second;
-    image->clear();
-  }
-}
-
-Error HeifContext::read(std::shared_ptr<StreamReader> reader)
-{
-  m_heif_file = std::make_shared<HeifFile>();
-  Error err = m_heif_file->read(reader);
-  if (err) {
-    return err;
-  }
-
-  return interpret_heif_file();
-}
-
-Error HeifContext::read_from_file(const char* input_filename)
-{
-  m_heif_file = std::make_shared<HeifFile>();
-  Error err = m_heif_file->read_from_file(input_filename);
-  if (err) {
-    return err;
-  }
-
-  return interpret_heif_file();
-}
-
-Error HeifContext::read_from_memory(const void* data, size_t size, bool copy)
-{
-  m_heif_file = std::make_shared<HeifFile>();
-  Error err = m_heif_file->read_from_memory(data, size, copy);
-  if (err) {
-    return err;
-  }
-
-  return interpret_heif_file();
-}
-
-void HeifContext::reset_to_empty_heif()
-{
-  m_heif_file = std::make_shared<HeifFile>();
-  m_heif_file->new_empty_file();
-
-  m_all_images.clear();
-  m_top_level_images.clear();
-  m_primary_image.reset();
-}
-
-void HeifContext::write(StreamWriter& writer)
-{
-  m_heif_file->write(writer);
-}
-
-std::string HeifContext::debug_dump_boxes() const
-{
-  return m_heif_file->debug_dump_boxes();
-}
-
-void HeifContext::register_decoder(const heif_decoder_plugin* decoder_plugin)
-{
-  if (decoder_plugin->init_plugin) {
-    (*decoder_plugin->init_plugin)();
-  }
-
-  m_decoder_plugins.insert(decoder_plugin);
-}
-
-
-const struct heif_decoder_plugin* HeifContext::get_decoder(enum heif_compression_format type) const
-{
-  int highest_priority = 0;
-  const struct heif_decoder_plugin* best_plugin = nullptr;
-
-
-  // search global plugins
-
-  best_plugin = heif::get_decoder(type);
-  if (best_plugin != nullptr) {
-    highest_priority = best_plugin->does_support_format(type);
-  }
-
-
-  // search context-local plugins (DEPRECATED)
-
-  for (const auto* plugin : m_decoder_plugins) {
-    int priority = plugin->does_support_format(type);
-    if (priority > highest_priority) {
-      highest_priority = priority;
-      best_plugin = plugin;
-    }
-  }
-
-  return best_plugin;
-}
-
-
-static bool item_type_is_image(const std::string& item_type)
-{
-  return (item_type == "hvc1" ||
-          item_type == "grid" ||
-          item_type == "iden" ||
-          item_type == "iovl" ||
-          item_type == "av01");
-}
-
-
-void HeifContext::remove_top_level_image(std::shared_ptr<Image> image)
-{
-  std::vector<std::shared_ptr<Image>> new_list;
-
-  for (auto img : m_top_level_images) {
-    if (img != image) {
-      new_list.push_back(img);
-    }
-  }
-
-  m_top_level_images = new_list;
-}
-
-
-Error HeifContext::interpret_heif_file()
-{
-  m_all_images.clear();
-  m_top_level_images.clear();
-  m_primary_image.reset();
-
-
-  // --- reference all non-hidden images
-
-  std::vector<heif_item_id> image_IDs = m_heif_file->get_item_IDs();
-
-  for (heif_item_id id : image_IDs) {
-    auto infe_box = m_heif_file->get_infe_box(id);
-    if (!infe_box) {
-      // TODO(farindk): Should we return an error instead of skipping the invalid id?
-      continue;
-    }
-
-    if (item_type_is_image(infe_box->get_item_type())) {
-      auto image = std::make_shared<Image>(this, id);
-      m_all_images.insert(std::make_pair(id, image));
-
-      if (!infe_box->is_hidden_item()) {
-        if (id == m_heif_file->get_primary_image_ID()) {
-          image->set_primary(true);
-          m_primary_image = image;
-        }
-
-        m_top_level_images.push_back(image);
-      }
-    }
-  }
-
-  if (!m_primary_image) {
-    return Error(heif_error_Invalid_input,
-                 heif_suberror_Nonexisting_item_referenced,
-                 "'pitm' box references a non-existing image");
-  }
-
-
-  // --- read through properties for each image and extract image resolutions
-  // Note: this has to be executed before assigning the auxiliary images below because we will only
-  // merge the alpha image with the main image when their resolutions are the same.
-
-  for (auto& pair : m_all_images) {
-    auto& image = pair.second;
-
-    std::vector<Box_ipco::Property> properties;
-
-    Error err = m_heif_file->get_properties(pair.first, properties);
-    if (err) {
-      return err;
-    }
-
-    bool ispe_read = false;
-    for (const auto& prop : properties) {
-      auto ispe = std::dynamic_pointer_cast<Box_ispe>(prop.property);
-      if (ispe) {
-        uint32_t width = ispe->get_width();
-        uint32_t height = ispe->get_height();
-
-
-        // --- check whether the image size is "too large"
-
-        if (width > m_maximum_image_width_limit ||
-            height > m_maximum_image_height_limit) {
-          std::stringstream sstr;
-          sstr << "Image size " << width << "x" << height << " exceeds the maximum image size "
-               << m_maximum_image_width_limit << "x" << m_maximum_image_height_limit << "\n";
-
-          return Error(heif_error_Memory_allocation_error,
-                       heif_suberror_Security_limit_exceeded,
-                       sstr.str());
-        }
-
-        image->set_resolution(width, height);
-        image->set_ispe_resolution(width, height);
-        ispe_read = true;
-      }
-
-      if (ispe_read) {
-        auto clap = std::dynamic_pointer_cast<Box_clap>(prop.property);
-        if (clap) {
-          image->set_resolution(clap->get_width_rounded(),
-                                clap->get_height_rounded());
-        }
-
-        auto irot = std::dynamic_pointer_cast<Box_irot>(prop.property);
-        if (irot) {
-          if (irot->get_rotation() == 90 ||
-              irot->get_rotation() == 270) {
-            // swap width and height
-            image->set_resolution(image->get_height(),
-                                  image->get_width());
-          }
-        }
-      }
-
-      auto colr = std::dynamic_pointer_cast<Box_colr>(prop.property);
-      if (colr) {
-        auto profile = colr->get_color_profile();
-        image->set_color_profile(profile);
-      }
-    }
-  }
-
-
-  // --- remove auxiliary from top-level images and assign to their respective image
-
-  auto iref_box = m_heif_file->get_iref_box();
-  if (iref_box) {
-    // m_top_level_images.clear();
-
-    for (auto& pair : m_all_images) {
-      auto& image = pair.second;
-
-      std::vector<Box_iref::Reference> references = iref_box->get_references_from(image->get_id());
-
-      for (const Box_iref::Reference& ref : references) {
-        uint32_t type = ref.header.get_short_type();
-
-        if (type == fourcc("thmb")) {
-          // --- this is a thumbnail image, attach to the main image
-
-          std::vector<heif_item_id> refs = ref.to_item_ID;
-          if (refs.size() != 1) {
-            return Error(heif_error_Invalid_input,
-                         heif_suberror_Unspecified,
-                         "Too many thumbnail references");
-          }
-
-          image->set_is_thumbnail_of(refs[0]);
-
-          auto master_iter = m_all_images.find(refs[0]);
-          if (master_iter == m_all_images.end()) {
-            return Error(heif_error_Invalid_input,
-                         heif_suberror_Nonexisting_item_referenced,
-                         "Thumbnail references a non-existing image");
-          }
-
-          if (master_iter->second->is_thumbnail()) {
-            return Error(heif_error_Invalid_input,
-                         heif_suberror_Nonexisting_item_referenced,
-                         "Thumbnail references another thumbnail");
-          }
-
-          if (image.get() == master_iter->second.get()) {
-            return Error(heif_error_Invalid_input,
-                         heif_suberror_Nonexisting_item_referenced,
-                         "Recursive thumbnail image detected");
-          }
-          master_iter->second->add_thumbnail(image);
-
-          remove_top_level_image(image);
-        }
-        else if (type == fourcc("auxl")) {
-
-          // --- this is an auxiliary image
-          //     check whether it is an alpha channel and attach to the main image if yes
-
-          std::vector<Box_ipco::Property> properties;
-          Error err = m_heif_file->get_properties(image->get_id(), properties);
-          if (err) {
-            return err;
-          }
-
-          std::shared_ptr<Box_auxC> auxC_property;
-          for (const auto& property : properties) {
-            auto auxC = std::dynamic_pointer_cast<Box_auxC>(property.property);
-            if (auxC) {
-              auxC_property = auxC;
-            }
-          }
-
-          if (!auxC_property) {
-            std::stringstream sstr;
-            sstr << "No auxC property for image " << image->get_id();
-            return Error(heif_error_Invalid_input,
-                         heif_suberror_Auxiliary_image_type_unspecified,
-                         sstr.str());
-          }
-
-          std::vector<heif_item_id> refs = ref.to_item_ID;
-          if (refs.size() != 1) {
-            return Error(heif_error_Invalid_input,
-                         heif_suberror_Unspecified,
-                         "Too many auxiliary image references");
-          }
-
-
-          // alpha channel
-
-          if (auxC_property->get_aux_type() == "urn:mpeg:avc:2015:auxid:1" ||   // HEIF (avc)
-              auxC_property->get_aux_type() == "urn:mpeg:hevc:2015:auxid:1" ||  // HEIF (h265)
-              auxC_property->get_aux_type() == "urn:mpeg:mpegB:cicp:systems:auxiliary:alpha") { // MIAF
-
-            auto master_iter = m_all_images.find(refs[0]);
-            if (master_iter == m_all_images.end()) {
-              return Error(heif_error_Invalid_input,
-                           heif_suberror_Nonexisting_item_referenced,
-                           "Non-existing alpha image referenced");
-            }
-
-            auto master_img = master_iter->second;
-
-            if (image.get() == master_img.get()) {
-              return Error(heif_error_Invalid_input,
-                           heif_suberror_Nonexisting_item_referenced,
-                           "Recursive alpha image detected");
-            }
-
-
-            if (image->get_width() == master_img->get_width() &&
-                image->get_height() == master_img->get_height()) {
-
-              image->set_is_alpha_channel_of(refs[0], true);
-              master_img->set_alpha_channel(image);
-            }
-          }
-
-
-          // depth channel
-
-          if (auxC_property->get_aux_type() == "urn:mpeg:hevc:2015:auxid:2" || // HEIF
-              auxC_property->get_aux_type() == "urn:mpeg:mpegB:cicp:systems:auxiliary:depth") { // AVIF
-            image->set_is_depth_channel_of(refs[0]);
-
-            auto master_iter = m_all_images.find(refs[0]);
-            if (master_iter == m_all_images.end()) {
-              return Error(heif_error_Invalid_input,
-                           heif_suberror_Nonexisting_item_referenced,
-                           "Non-existing depth image referenced");
-            }
-            if (image.get() == master_iter->second.get()) {
-              return Error(heif_error_Invalid_input,
-                           heif_suberror_Nonexisting_item_referenced,
-                           "Recursive depth image detected");
-            }
-            master_iter->second->set_depth_channel(image);
-
-            auto subtypes = auxC_property->get_subtypes();
-
-            std::vector<std::shared_ptr<SEIMessage>> sei_messages;
-            err = decode_hevc_aux_sei_messages(subtypes, sei_messages);
-
-            for (auto& msg : sei_messages) {
-              auto depth_msg = std::dynamic_pointer_cast<SEIMessage_depth_representation_info>(msg);
-              if (depth_msg) {
-                image->set_depth_representation_info(*depth_msg);
-              }
-            }
-          }
-
-
-          // --- generic aux image
-
-          image->set_is_aux_image_of(refs[0], auxC_property->get_aux_type());
-
-          auto master_iter = m_all_images.find(refs[0]);
-          if (master_iter == m_all_images.end()) {
-            return Error(heif_error_Invalid_input,
-                         heif_suberror_Nonexisting_item_referenced,
-                         "Non-existing aux image referenced");
-          }
-          if (image.get() == master_iter->second.get()) {
-            return Error(heif_error_Invalid_input,
-                         heif_suberror_Nonexisting_item_referenced,
-                         "Recursive aux image detected");
-          }
-
-          master_iter->second->add_aux_image(image);
-
-          remove_top_level_image(image);
-        }
-        else {
-          // 'image' is a normal image, keep it as a top-level image
-        }
-      }
-    }
-  }
-
-
-  // --- check that HEVC images have an hvcC property
-
-  for (auto& pair : m_all_images) {
-    auto& image = pair.second;
-
-    std::shared_ptr<Box_infe> infe = m_heif_file->get_infe_box(image->get_id());
-    if (infe->get_item_type() == "hvc1") {
-
-      auto ipma = m_heif_file->get_ipma_box();
-      auto ipco = m_heif_file->get_ipco_box();
-
-      if (!ipco->get_property_for_item_ID(image->get_id(), ipma, fourcc("hvcC"))) {
-        return Error(heif_error_Invalid_input,
-                     heif_suberror_No_hvcC_box,
-                     "No hvcC property in hvc1 type image");
-      }
-    }
-  }
-
-
-  // --- assign color profile from grid tiles to main image when main image has no profile assigned
-
-  for (auto& pair : m_all_images) {
-    auto& image = pair.second;
-    auto id = pair.first;
-
-    auto infe_box = m_heif_file->get_infe_box(id);
-    if (!infe_box) {
-      continue;
-    }
-
-    if (!iref_box) {
-      break;
-    }
-
-    if (infe_box->get_item_type() == "grid") {
-      std::vector<heif_item_id> image_references = iref_box->get_references(id, fourcc("dimg"));
-
-      if (image_references.empty()) {
-        continue; // TODO: can this every happen?
-      }
-
-      auto tileId = image_references.front();
-
-      auto iter = m_all_images.find(tileId);
-      if (iter == m_all_images.end()) {
-        continue; // invalid grid entry
-      }
-
-      auto tile_img = iter->second;
-      if (image->get_color_profile_icc() == nullptr && tile_img->get_color_profile_icc()) {
-        image->set_color_profile(tile_img->get_color_profile_icc());
-      }
-
-      if (image->get_color_profile_nclx() == nullptr && tile_img->get_color_profile_nclx()) {
-        image->set_color_profile(tile_img->get_color_profile_nclx());
-      }
-    }
-  }
-
-
-  // --- read metadata and assign to image
-
-  for (heif_item_id id : image_IDs) {
-    std::string item_type = m_heif_file->get_item_type(id);
-    std::string content_type = m_heif_file->get_content_type(id);
-
-    // we now assign all kinds of metadata to the image, not only 'Exif' and 'XMP'
-
-    std::shared_ptr<ImageMetadata> metadata = std::make_shared<ImageMetadata>();
-    metadata->item_id = id;
-    metadata->item_type = item_type;
-    metadata->content_type = content_type;
-
-    Error err = m_heif_file->get_compressed_image_data(id, &(metadata->m_data));
-    if (err) {
-      return err;
-    }
-
-    //std::cerr.write((const char*)data.data(), data.size());
-
-
-    // --- assign metadata to the image
-
-    if (iref_box) {
-      std::vector<Box_iref::Reference> references = iref_box->get_references_from(id);
-      for (const auto& ref : references) {
-        if (ref.header.get_short_type() == fourcc("cdsc")) {
-          std::vector<uint32_t> refs = ref.to_item_ID;
-          if (refs.size() != 1) {
-            return Error(heif_error_Invalid_input,
-                         heif_suberror_Unspecified,
-                         "Metadata not correctly assigned to image");
-          }
-
-          uint32_t exif_image_id = refs[0];
-          auto img_iter = m_all_images.find(exif_image_id);
-          if (img_iter == m_all_images.end()) {
-            return Error(heif_error_Invalid_input,
-                         heif_suberror_Nonexisting_item_referenced,
-                         "Metadata assigned to non-existing image");
-          }
-
-          img_iter->second->add_metadata(metadata);
-        }
-        else if (ref.header.get_short_type() == fourcc("prem")) {
-          uint32_t color_image_id = ref.from_item_ID;
-          auto img_iter = m_all_images.find(color_image_id);
-          if (img_iter == m_all_images.end()) {
-            return Error(heif_error_Invalid_input,
-                         heif_suberror_Nonexisting_item_referenced,
-                         "`prem` link assigned to non-existing image");
-          }
-
-          img_iter->second->set_is_premultiplied_alpha(true);;
-        }
-      }
-    }
-  }
-
-  return Error::Ok;
-}
-
-
-HeifContext::Image::Image(HeifContext* context, heif_item_id id)
-    : m_heif_context(context),
-      m_id(id)
-{
-  memset(&m_depth_representation_info, 0, sizeof(m_depth_representation_info));
-}
-
-HeifContext::Image::~Image()
-{
-}
-
-bool HeifContext::is_image(heif_item_id ID) const
-{
-  for (const auto& img : m_all_images) {
-    if (img.first == ID)
-      return true;
-  }
-
-  return false;
-}
-
-
-Error HeifContext::get_id_of_non_virtual_child_image(heif_item_id id, heif_item_id& out) const
-{
-  std::string image_type = m_heif_file->get_item_type(id);
-  if (image_type == "grid" ||
-      image_type == "iden" ||
-      image_type == "iovl") {
-    auto iref_box = m_heif_file->get_iref_box();
-    if (!iref_box) {
-      return Error(heif_error_Invalid_input,
-                   heif_suberror_No_item_data,
-                   "Derived image does not reference any other image items");
-    }
-
-    std::vector<heif_item_id> image_references = iref_box->get_references(id, fourcc("dimg"));
-
-    // TODO: check whether this really can be recursive (e.g. overlay of grid images)
-
-    if (image_references.empty()) {
-      return Error(heif_error_Invalid_input,
-                   heif_suberror_No_item_data,
-                   "Derived image does not reference any other image items");
-    }
-    else {
-      return get_id_of_non_virtual_child_image(image_references[0], out);
-    }
-  }
-  else {
-    out = id;
-    return Error::Ok;
-  }
-}
-
-
-int HeifContext::Image::get_luma_bits_per_pixel() const
-{
-  heif_item_id id;
-  Error err = m_heif_context->get_id_of_non_virtual_child_image(m_id, id);
-  if (err) {
-    return -1;
-  }
-
-  return m_heif_context->m_heif_file->get_luma_bits_per_pixel_from_configuration(id);
-}
-
-
-int HeifContext::Image::get_chroma_bits_per_pixel() const
-{
-  heif_item_id id;
-  Error err = m_heif_context->get_id_of_non_virtual_child_image(m_id, id);
-  if (err) {
-    return -1;
-  }
-
-  return m_heif_context->m_heif_file->get_chroma_bits_per_pixel_from_configuration(id);
-}
-
-
-Error HeifContext::decode_image_user(heif_item_id ID,
-                                     std::shared_ptr<HeifPixelImage>& img,
-                                     heif_colorspace out_colorspace,
-                                     heif_chroma out_chroma,
-                                     const struct heif_decoding_options* options) const
-{
-  Error err = decode_image_planar(ID, img, out_colorspace, options, false);
-  if (err) {
-    return err;
-  }
-
-  // --- convert to output chroma format
-
-  heif_colorspace target_colorspace = (out_colorspace == heif_colorspace_undefined ?
-                                       img->get_colorspace() :
-                                       out_colorspace);
-
-  heif_chroma target_chroma = (out_chroma == heif_chroma_undefined ?
-                               img->get_chroma_format() : out_chroma);
-
-  bool different_chroma = (target_chroma != img->get_chroma_format());
-  bool different_colorspace = (target_colorspace != img->get_colorspace());
-
-  int bpp = (options && options->convert_hdr_to_8bit) ? 8 : 0;
-// TODO: check BPP changed
-  if (different_chroma || different_colorspace) {
-    img = convert_colorspace(img, target_colorspace, target_chroma, nullptr, bpp);
-    if (!img) {
-      return Error(heif_error_Unsupported_feature, heif_suberror_Unsupported_color_conversion);
-    }
-  }
-
-  return Error::Ok;
-}
-
-
-Error HeifContext::decode_image_planar(heif_item_id ID,
-                                       std::shared_ptr<HeifPixelImage>& img,
-                                       heif_colorspace out_colorspace,
-                                       const struct heif_decoding_options* options, bool alphaImage) const
-{
-  std::string image_type = m_heif_file->get_item_type(ID);
-
-  std::shared_ptr<Image> imginfo;
-  if (m_all_images.find(ID) != m_all_images.end()) {
-    imginfo = m_all_images.find(ID)->second;
-  }
-
-  assert(imginfo);
-
-  Error error;
-
-
-  // --- decode image, depending on its type
-
-  if (image_type == "hvc1" ||
-      image_type == "av01") {
-
-    heif_compression_format compression = heif_compression_undefined;
-    if (image_type == "hvc1") {
-      compression = heif_compression_HEVC;
-    }
-    else if (image_type == "av01") {
-      compression = heif_compression_AV1;
-    }
-
-    const struct heif_decoder_plugin* decoder_plugin = get_decoder(compression);
-    if (!decoder_plugin) {
-      return Error(heif_error_Unsupported_feature, heif_suberror_Unsupported_codec);
-    }
-
-    std::vector<uint8_t> data;
-    error = m_heif_file->get_compressed_image_data(ID, &data);
-    if (error) {
-      return error;
-    }
-
-    void* decoder;
-    struct heif_error err = decoder_plugin->new_decoder(&decoder);
-    if (err.code != heif_error_Ok) {
-      return Error(err.code, err.subcode, err.message);
-    }
-
-    err = decoder_plugin->push_data(decoder, data.data(), data.size());
-    if (err.code != heif_error_Ok) {
-      decoder_plugin->free_decoder(decoder);
-      return Error(err.code, err.subcode, err.message);
-    }
-
-    //std::shared_ptr<HeifPixelImage>* decoded_img;
-
-    heif_image* decoded_img = nullptr;
-
-    err = decoder_plugin->decode_image(decoder, &decoded_img);
-    if (err.code != heif_error_Ok) {
-      decoder_plugin->free_decoder(decoder);
-      return Error(err.code, err.subcode, err.message);
-    }
-
-    if (!decoded_img) {
-      // TODO(farindk): The plugin should return an error in this case.
-      decoder_plugin->free_decoder(decoder);
-      return Error(heif_error_Decoder_plugin_error, heif_suberror_Unspecified);
-    }
-
-    img = std::move(decoded_img->image);
-    heif_image_release(decoded_img);
-
-    decoder_plugin->free_decoder(decoder);
-
-
-
-    // --- convert to output chroma format
-
-    // If there is an NCLX profile in the HEIF/AVIF metadata, use this for the color conversion.
-    // Otherwise, use the profile that is stored in the image stream itself and then set the
-    // (non-NCLX) profile later.
-    auto nclx = imginfo->get_color_profile_nclx();
-    if (nclx) {
-      img->set_color_profile_nclx(nclx);
-    }
-
-    auto icc = imginfo->get_color_profile_icc();
-    if (icc) {
-      img->set_color_profile_icc(icc);
-    }
-
-    if (alphaImage) {
-      // no color conversion required
-    }
-    else {
-      heif_colorspace target_colorspace = (out_colorspace == heif_colorspace_undefined ?
-                                           img->get_colorspace() :
-                                           out_colorspace);
-
-      if (!alphaImage && target_colorspace == heif_colorspace_YCbCr) {
-        target_colorspace = heif_colorspace_RGB;
-      }
-
-      heif_chroma target_chroma = (target_colorspace == heif_colorspace_monochrome ?
-                                   heif_chroma_monochrome : heif_chroma_444);
-
-      bool different_chroma = (target_chroma != img->get_chroma_format());
-      bool different_colorspace = (target_colorspace != img->get_colorspace());
-
-      if (different_chroma || different_colorspace) {
-        img = convert_colorspace(img, target_colorspace, target_chroma, nullptr);
-        if (!img) {
-          return Error(heif_error_Unsupported_feature, heif_suberror_Unsupported_color_conversion);
-        }
-      }
-    }
-  }
-  else if (image_type == "grid") {
-    std::vector<uint8_t> data;
-    error = m_heif_file->get_compressed_image_data(ID, &data);
-    if (error) {
-      return error;
-    }
-
-    error = decode_full_grid_image(ID, img, data);
-    if (error) {
-      return error;
-    }
-  }
-  else if (image_type == "iden") {
-    error = decode_derived_image(ID, img);
-    if (error) {
-      return error;
-    }
-  }
-  else if (image_type == "iovl") {
-    std::vector<uint8_t> data;
-    error = m_heif_file->get_compressed_image_data(ID, &data);
-    if (error) {
-      return error;
-    }
-
-    error = decode_overlay_image(ID, img, data);
-    if (error) {
-      return error;
-    }
-  }
-  else {
-    // Should not reach this, was already rejected by "get_image_data".
-    return Error(heif_error_Unsupported_feature,
-                 heif_suberror_Unsupported_image_type);
-  }
-
-
-
-  // --- apply image transformations
-
-  if (!options || options->ignore_transformations == false) {
-    std::vector<Box_ipco::Property> properties;
-    auto ipco_box = m_heif_file->get_ipco_box();
-    auto ipma_box = m_heif_file->get_ipma_box();
-    error = ipco_box->get_properties_for_item_ID(ID, ipma_box, properties);
-
-    for (const auto& property : properties) {
-      auto rot = std::dynamic_pointer_cast<Box_irot>(property.property);
-      if (rot) {
-        std::shared_ptr<HeifPixelImage> rotated_img;
-        error = img->rotate_ccw(rot->get_rotation(), rotated_img);
-        if (error) {
-          return error;
-        }
-
-        img = rotated_img;
-      }
-
-
-      auto mirror = std::dynamic_pointer_cast<Box_imir>(property.property);
-      if (mirror) {
-        error = img->mirror_inplace(mirror->get_mirror_direction() == Box_imir::MirrorDirection::Horizontal);
-        if (error) {
-          return error;
-        }
-      }
-
-
-      auto clap = std::dynamic_pointer_cast<Box_clap>(property.property);
-      if (clap) {
-        std::shared_ptr<HeifPixelImage> clap_img;
-
-        int img_width = img->get_width();
-        int img_height = img->get_height();
-        assert(img_width >= 0);
-        assert(img_height >= 0);
-
-        int left = clap->left_rounded(img_width);
-        int right = clap->right_rounded(img_width);
-        int top = clap->top_rounded(img_height);
-        int bottom = clap->bottom_rounded(img_height);
-
-        if (left < 0) { left = 0; }
-        if (top < 0) { top = 0; }
-
-        if (right >= img_width) { right = img_width - 1; }
-        if (bottom >= img_height) { bottom = img_height - 1; }
-
-        if (left > right ||
-            top > bottom) {
-          return Error(heif_error_Invalid_input,
-                       heif_suberror_Invalid_clean_aperture);
-        }
-
-        std::shared_ptr<HeifPixelImage> cropped_img;
-        error = img->crop(left, right, top, bottom, cropped_img);
-        if (error) {
-          return error;
-        }
-
-        img = cropped_img;
-      }
-    }
-  }
-
-
-  // --- add alpha channel, if available
-
-  // TODO: this if statement is probably wrong. When we have a tiled image with alpha
-  // channel, then the alpha images should be associated with their respective tiles.
-  // However, the tile images are not part of the m_all_images list.
-  // Fix this, when we have a test image available.
-  if (m_all_images.find(ID) != m_all_images.end()) {
-    const auto imginfo = m_all_images.find(ID)->second;
-
-    std::shared_ptr<Image> alpha_image = imginfo->get_alpha_channel();
-    if (alpha_image) {
-      std::shared_ptr<HeifPixelImage> alpha;
-      Error err = decode_image_planar(alpha_image->get_id(), alpha,
-                                      heif_colorspace_undefined, nullptr, true);
-      if (err) {
-        return err;
-      }
-
-      // TODO: check that sizes are the same and that we have an Y channel
-      // BUT: is there any indication in the standard that the alpha channel should have the same size?
-
-      heif_channel channel;
-      switch (alpha->get_colorspace()) {
-        case heif_colorspace_YCbCr:
-        case heif_colorspace_monochrome:
-          channel = heif_channel_Y;
-          break;
-        case heif_colorspace_RGB:
-          channel = heif_channel_R;
-          break;
-        case heif_colorspace_undefined:
-        default:
-          return Error(heif_error_Invalid_input,
-                       heif_suberror_Unsupported_color_conversion);
-      }
-
-      img->transfer_plane_from_image_as(alpha, channel, heif_channel_Alpha);
-
-      if (imginfo->is_premultiplied_alpha()) {
-        img->set_premultiplied_alpha(true);
-      }
-    }
-  }
-
-
-  return Error::Ok;
-}
-
-
-// This function only works with RGB images.
-Error HeifContext::decode_full_grid_image(heif_item_id ID,
-                                          std::shared_ptr<HeifPixelImage>& img,
-                                          const std::vector<uint8_t>& grid_data) const
-{
-  ImageGrid grid;
-  Error err = grid.parse(grid_data);
-  if (err) {
-    return err;
-  }
-
-  //std::cout << grid.dump();
-
-
-  auto iref_box = m_heif_file->get_iref_box();
-
-  if (!iref_box) {
-    return Error(heif_error_Invalid_input,
-                 heif_suberror_No_iref_box,
-                 "No iref box available, but needed for grid image");
-  }
-
-  std::vector<heif_item_id> image_references = iref_box->get_references(ID, fourcc("dimg"));
-
-  if ((int) image_references.size() != grid.get_rows() * grid.get_columns()) {
-    std::stringstream sstr;
-    sstr << "Tiled image with " << grid.get_rows() << "x" << grid.get_columns() << "="
-         << (grid.get_rows() * grid.get_columns()) << " tiles, but only "
-         << image_references.size() << " tile images in file";
-
-    return Error(heif_error_Invalid_input,
-                 heif_suberror_Missing_grid_images,
-                 sstr.str());
-  }
-
-
-  // --- check that all image IDs are valid images
-
-  for (heif_item_id tile_id : image_references) {
-    if (!is_image(tile_id)) {
-      std::stringstream sstr;
-      sstr << "Tile image ID=" << tile_id << " is not a proper image.";
-
-      return Error(heif_error_Invalid_input,
-                   heif_suberror_Missing_grid_images,
-                   sstr.str());
-    }
-  }
-
-
-  auto ipma = m_heif_file->get_ipma_box();
-  auto ipco = m_heif_file->get_ipco_box();
-  auto pixi_box = ipco->get_property_for_item_ID(ID, ipma, fourcc("pixi"));
-  auto pixi = std::dynamic_pointer_cast<Box_pixi>(pixi_box);
-
-  const uint32_t w = grid.get_width();
-  const uint32_t h = grid.get_height();
-
-
-  // --- determine output image chroma size and make sure all tiles have same chroma
-
-  assert(!image_references.empty());
-
-  heif_chroma tile_chroma = heif_chroma_444;
-  /* TODO: in the future, we might support RGB and mono as intermediate formats
-  heif_chroma tile_chroma = m_heif_file->get_image_chroma_from_configuration(some_tile_id);
-  if (tile_chroma != heif_chroma_monochrome) {
-    tile_chroma = heif_chroma_RGB;
-  }
-  */
-
-  // --- generate image of full output size
-
-  if (w >= m_maximum_image_width_limit || h >= m_maximum_image_height_limit) {
-    std::stringstream sstr;
-    sstr << "Image size " << w << "x" << h << " exceeds the maximum image size "
-         << m_maximum_image_width_limit << "x" << m_maximum_image_height_limit << "\n";
-
-    return Error(heif_error_Memory_allocation_error,
-                 heif_suberror_Security_limit_exceeded,
-                 sstr.str());
-  }
-
-
-  img = std::make_shared<HeifPixelImage>();
-  img->create(w, h,
-              heif_colorspace_RGB,
-              heif_chroma_444);
-
-  int bpp = 0;
-
-  if (pixi) {
-    if (pixi->get_num_channels() < 1) {
-      return Error(heif_error_Invalid_input,
-                   heif_suberror_Invalid_pixi_box,
-                   "No pixi information for luma channel.");
-    }
-
-    bpp = pixi->get_bits_per_channel(0);
-
-    if (tile_chroma != heif_chroma_monochrome) {
-
-      // there are broken files that save only a one-channel pixi for an RGB image (issue #283)
-      if (pixi->get_num_channels() == 3) {
-
-        int bpp_c1 = pixi->get_bits_per_channel(1);
-        int bpp_c2 = pixi->get_bits_per_channel(2);
-
-        if (bpp_c1 != bpp || bpp_c2 != bpp) {
-          // TODO: is this really an error? Does the pixi depths refer to RGB or YCbCr?
-          return Error(heif_error_Invalid_input,
-                       heif_suberror_Invalid_pixi_box,
-                       "Different number of bits per pixel in each channel.");
-        }
-      }
-    }
-  }
-  else {
-    // When there is no pixi-box, get the pixel-depth from one of the tile images
-
-    heif_item_id tileID = image_references[0];
-
-    auto iter = m_all_images.find(tileID);
-    if (iter == m_all_images.end()) {
-      return Error(heif_error_Invalid_input,
-                   heif_suberror_Missing_grid_images,
-                   "Nonexistent grid image referenced");
-    }
-
-    const std::shared_ptr<Image> tileImg = iter->second;
-    bpp = tileImg->get_luma_bits_per_pixel();
-  }
-
-
-  if (tile_chroma == heif_chroma_monochrome) {
-    img->add_plane(heif_channel_Y, w, h, bpp);
-  }
-  else {
-    img->add_plane(heif_channel_R, w, h, bpp);
-    img->add_plane(heif_channel_G, w, h, bpp);
-    img->add_plane(heif_channel_B, w, h, bpp);
-  }
-
-  int y0 = 0;
-  int reference_idx = 0;
-
-#if ENABLE_PARALLEL_TILE_DECODING
-  // remember which tile to put where into the image
-  struct tile_data {
-    heif_item_id tileID;
-    int x_origin,y_origin;
-  };
-
-  std::deque<tile_data> tiles;
-  tiles.resize(grid.get_rows() * grid.get_columns() );
-
-  std::deque<std::future<Error> > errs;
-#endif
-
-  for (int y = 0; y < grid.get_rows(); y++) {
-    int x0 = 0;
-    int tile_height = 0;
-
-    for (int x = 0; x < grid.get_columns(); x++) {
-
-      heif_item_id tileID = image_references[reference_idx];
-
-      auto iter = m_all_images.find(tileID);
-      if (iter == m_all_images.end()) {
-        return Error(heif_error_Invalid_input,
-                     heif_suberror_Missing_grid_images,
-                     "Nonexistent grid image referenced");
-      }
-
-      const std::shared_ptr<Image> tileImg = iter->second;
-      int src_width = tileImg->get_width();
-      int src_height = tileImg->get_height();
-
-#if ENABLE_PARALLEL_TILE_DECODING
-      tiles[x+y*grid.get_columns()] = tile_data { tileID, x0,y0 };
-#else
-      Error err = decode_and_paste_tile_image(tileID, img, x0, y0);
-      if (err) {
-        return err;
-      }
-#endif
-
-      x0 += src_width;
-      tile_height = src_height; // TODO: check that all tiles have the same height
-
-      reference_idx++;
-    }
-
-    y0 += tile_height;
-  }
-
-#if ENABLE_PARALLEL_TILE_DECODING
-  // Process all tiles in a set of background threads.
-  // Do not start more than the maximum number of threads.
-
-  while (tiles.empty()==false) {
-
-    // If maximum number of threads running, wait until first thread finishes
-
-    if (errs.size() >= (size_t)m_max_decoding_threads) {
-      Error e = errs.front().get();
-      if (e) {
-        return e;
-      }
-
-      errs.pop_front();
-    }
-
-
-    // Start a new decoding thread
-
-    tile_data data = tiles.front();
-    tiles.pop_front();
-
-    errs.push_back( std::async(std::launch::async,
-                               &HeifContext::decode_and_paste_tile_image, this,
-                               data.tileID, img, data.x_origin,data.y_origin) );
-  }
-
-  // check for decoding errors in remaining tiles
-
-  while (errs.empty() == false) {
-    Error e = errs.front().get();
-    if (e) {
-      return e;
-    }
-
-    errs.pop_front();
-  }
-#endif
-
-  return Error::Ok;
-}
-
-
-Error HeifContext::decode_and_paste_tile_image(heif_item_id tileID,
-                                               std::shared_ptr<HeifPixelImage> img,
-                                               int x0, int y0) const
-{
-  std::shared_ptr<HeifPixelImage> tile_img;
-
-  Error err = decode_image_planar(tileID, tile_img, img->get_colorspace(), nullptr, false);
-  if (err != Error::Ok) {
-    return err;
-  }
-
-  const int w = img->get_width();
-  const int h = img->get_height();
-
-
-  // --- copy tile into output image
-
-  int src_width = tile_img->get_width();
-  int src_height = tile_img->get_height();
-  assert(src_width >= 0);
-  assert(src_height >= 0);
-
-  heif_chroma chroma = img->get_chroma_format();
-  std::set<enum heif_channel> channels = img->get_channel_set();
-
-  if (chroma != tile_img->get_chroma_format()) {
-    return Error(heif_error_Invalid_input,
-                 heif_suberror_Wrong_tile_image_chroma_format,
-                 "Image tile has different chroma format than combined image");
-  }
-
-  for (heif_channel channel : channels) {
-
-    int tile_stride;
-    uint8_t* tile_data = tile_img->get_plane(channel, &tile_stride);
-
-    int out_stride;
-    uint8_t* out_data = img->get_plane(channel, &out_stride);
-
-    if (w <= x0 || h <= y0) {
-      return Error(heif_error_Invalid_input,
-                   heif_suberror_Invalid_grid_data);
-    }
-
-    if (img->get_bits_per_pixel(channel) != tile_img->get_bits_per_pixel(channel)) {
-      return Error(heif_error_Invalid_input,
-                   heif_suberror_Wrong_tile_image_pixel_depth);
-    }
-
-    int copy_width = std::min(src_width, w - x0);
-    int copy_height = std::min(src_height, h - y0);
-
-    copy_width *= tile_img->get_storage_bits_per_pixel(heif_channel_R) / 8;
-
-    int xs = x0, ys = y0;
-    xs *= tile_img->get_storage_bits_per_pixel(heif_channel_R) / 8;
-
-    for (int py = 0; py < copy_height; py++) {
-      memcpy(out_data + xs + (ys + py) * out_stride,
-             tile_data + py * tile_stride,
-             copy_width);
-    }
-  }
-
-  return Error::Ok;
-}
-
-
-Error HeifContext::decode_derived_image(heif_item_id ID,
-                                        std::shared_ptr<HeifPixelImage>& img) const
-{
-  // find the ID of the image this image is derived from
-
-  auto iref_box = m_heif_file->get_iref_box();
-
-  if (!iref_box) {
-    return Error(heif_error_Invalid_input,
-                 heif_suberror_No_iref_box,
-                 "No iref box available, but needed for iden image");
-  }
-
-  std::vector<heif_item_id> image_references = iref_box->get_references(ID, fourcc("dimg"));
-
-  if ((int) image_references.size() != 1) {
-    return Error(heif_error_Invalid_input,
-                 heif_suberror_Missing_grid_images,
-                 "'iden' image with more than one reference image");
-  }
-
-
-  heif_item_id reference_image_id = image_references[0];
-
-
-  Error error = decode_image_planar(reference_image_id, img,
-                                    heif_colorspace_RGB, nullptr, false); // TODO: always RGB ?
-  return error;
-}
-
-
-Error HeifContext::decode_overlay_image(heif_item_id ID,
-                                        std::shared_ptr<HeifPixelImage>& img,
-                                        const std::vector<uint8_t>& overlay_data) const
-{
-  // find the IDs this image is composed of
-
-  auto iref_box = m_heif_file->get_iref_box();
-
-  if (!iref_box) {
-    return Error(heif_error_Invalid_input,
-                 heif_suberror_No_iref_box,
-                 "No iref box available, but needed for iovl image");
-  }
-
-  std::vector<heif_item_id> image_references = iref_box->get_references(ID, fourcc("dimg"));
-
-  /* TODO: probably, it is valid that an iovl image has no references ?
-
-  if (image_references.empty()) {
-    return Error(heif_error_Invalid_input,
-                 heif_suberror_Missing_grid_images,
-                 "'iovl' image with more than one reference image");
-  }
-  */
-
-
-  ImageOverlay overlay;
-  Error err = overlay.parse(image_references.size(), overlay_data);
-  if (err) {
-    return err;
-  }
-
-  if (image_references.size() != overlay.get_num_offsets()) {
-    return Error(heif_error_Invalid_input,
-                 heif_suberror_Invalid_overlay_data,
-                 "Number of image offsets does not match the number of image references");
-  }
-
-  uint32_t w = overlay.get_canvas_width();
-  uint32_t h = overlay.get_canvas_height();
-
-  if (w >= m_maximum_image_width_limit || h >= m_maximum_image_height_limit) {
-    std::stringstream sstr;
-    sstr << "Image size " << w << "x" << h << " exceeds the maximum image size "
-         << m_maximum_image_width_limit << "x" << m_maximum_image_height_limit << "\n";
-
-    return Error(heif_error_Memory_allocation_error,
-                 heif_suberror_Security_limit_exceeded,
-                 sstr.str());
-  }
-
-  // TODO: seems we always have to compose this in RGB since the background color is an RGB value
-  img = std::make_shared<HeifPixelImage>();
-  img->create(w, h,
-              heif_colorspace_RGB,
-              heif_chroma_444);
-  img->add_plane(heif_channel_R, w, h, 8); // TODO: other bit depths
-  img->add_plane(heif_channel_G, w, h, 8); // TODO: other bit depths
-  img->add_plane(heif_channel_B, w, h, 8); // TODO: other bit depths
-
-  uint16_t bkg_color[4];
-  overlay.get_background_color(bkg_color);
-
-  err = img->fill_RGB_16bit(bkg_color[0], bkg_color[1], bkg_color[2], bkg_color[3]);
-  if (err) {
-    return err;
-  }
-
-
-  for (size_t i = 0; i < image_references.size(); i++) {
-    std::shared_ptr<HeifPixelImage> overlay_img;
-    err = decode_image_planar(image_references[i], overlay_img,
-                              heif_colorspace_RGB, nullptr, false); // TODO: always RGB? Probably yes, because of RGB background color.
-    if (err != Error::Ok) {
-      return err;
-    }
-
-    overlay_img = convert_colorspace(overlay_img, heif_colorspace_RGB, heif_chroma_444, nullptr);
-    if (!overlay_img) {
-      return Error(heif_error_Unsupported_feature, heif_suberror_Unsupported_color_conversion);
-    }
-
-    int32_t dx, dy;
-    overlay.get_offset(i, &dx, &dy);
-
-    err = img->overlay(overlay_img, dx, dy);
-    if (err) {
-      if (err.error_code == heif_error_Invalid_input &&
-          err.sub_error_code == heif_suberror_Overlay_image_outside_of_canvas) {
-        // NOP, ignore this error
-
-        err = Error::Ok;
-      }
-      else {
-        return err;
-      }
-    }
-  }
-
-  return err;
-}
-
-
-static std::shared_ptr<HeifPixelImage>
-create_alpha_image_from_image_alpha_channel(const std::shared_ptr<HeifPixelImage> image)
-{
-  // --- generate alpha image
-
-  std::shared_ptr<HeifPixelImage> alpha_image = std::make_shared<HeifPixelImage>();
-  alpha_image->create(image->get_width(), image->get_height(),
-                      heif_colorspace_monochrome, heif_chroma_monochrome);
-  alpha_image->copy_new_plane_from(image, heif_channel_Alpha, heif_channel_Y);
-
-
-  // --- set nclx profile with full-range flag
-
-  auto nclx = std::make_shared<color_profile_nclx>();
-  nclx->set_undefined();
-  nclx->set_full_range_flag(true); // this is the default, but just to be sure in case the defaults change
-  alpha_image->set_color_profile_nclx(nclx);
-
-  return alpha_image;
-}
-
-
-void HeifContext::Image::set_preencoded_hevc_image(const std::vector<uint8_t>& data)
-{
-  m_heif_context->m_heif_file->add_hvcC_property(m_id);
-
-
-  // --- parse the h265 stream and set hvcC headers and compressed image data
-
-  int state = 0;
-
-  bool first = true;
-  bool eof = false;
-
-  int prev_start_code_start = -1; // init to an invalid value, will always be overwritten before use
-  int start_code_start;
-  int ptr = 0;
-
-  for (;;) {
-    bool dump_nal = false;
-
-    uint8_t c = data[ptr++];
-
-    if (state == 3) {
-      state = 0;
-    }
-
-    if (c == 0 && state <= 1) {
-      state++;
-    }
-    else if (c == 0) {
-      // NOP
-    }
-    else if (c == 1 && state == 2) {
-      start_code_start = ptr - 3;
-      dump_nal = true;
-      state = 3;
-    }
-    else {
-      state = 0;
-    }
-
-    if (ptr == (int) data.size()) {
-      start_code_start = (int) data.size();
-      dump_nal = true;
-      eof = true;
-    }
-
-    if (dump_nal) {
-      if (first) {
-        first = false;
-      }
-      else {
-        std::vector<uint8_t> nal_data;
-        size_t length = start_code_start - (prev_start_code_start + 3);
-
-        nal_data.resize(length);
-
-        assert(prev_start_code_start >= 0);
-        memcpy(nal_data.data(), data.data() + prev_start_code_start + 3, length);
-
-        int nal_type = (nal_data[0] >> 1);
-
-        switch (nal_type) {
-          case 0x20:
-          case 0x21:
-          case 0x22:
-            m_heif_context->m_heif_file->append_hvcC_nal_data(m_id, nal_data);
-            /*hvcC->append_nal_data(nal_data);*/
-            break;
-
-          default: {
-            std::vector<uint8_t> nal_data_with_size;
-            nal_data_with_size.resize(nal_data.size() + 4);
-
-            memcpy(nal_data_with_size.data() + 4, nal_data.data(), nal_data.size());
-            nal_data_with_size[0] = ((nal_data.size() >> 24) & 0xFF);
-            nal_data_with_size[1] = ((nal_data.size() >> 16) & 0xFF);
-            nal_data_with_size[2] = ((nal_data.size() >> 8) & 0xFF);
-            nal_data_with_size[3] = ((nal_data.size() >> 0) & 0xFF);
-
-            m_heif_context->m_heif_file->append_iloc_data(m_id, nal_data_with_size);
-          }
-            break;
-        }
-      }
-
-      prev_start_code_start = start_code_start;
-    }
-
-    if (eof) {
-      break;
-    }
-  }
-}
-
-
-Error HeifContext::encode_image(std::shared_ptr<HeifPixelImage> pixel_image,
-                                struct heif_encoder* encoder,
-                                const struct heif_encoding_options* options,
-                                enum heif_image_input_class input_class,
-                                std::shared_ptr<Image>& out_image)
-{
-  Error error;
-
-  // TODO: the hdlr box is not the right place for comments
-  // m_heif_file->set_hdlr_library_info(encoder->plugin->get_plugin_name());
-
-  switch (encoder->plugin->compression_format) {
-    case heif_compression_HEVC: {
-      error = encode_image_as_hevc(pixel_image,
-                                   encoder,
-                                   options,
-                                   heif_image_input_class_normal,
-                                   out_image);
-    }
-      break;
-
-    case heif_compression_AV1: {
-      error = encode_image_as_av1(pixel_image,
-                                  encoder,
-                                  options,
-                                  heif_image_input_class_normal,
-                                  out_image);
-    }
-      break;
-
-    default:
-      return Error(heif_error_Encoder_plugin_error, heif_suberror_Unsupported_codec);
-  }
-
-  m_heif_file->set_brand(encoder->plugin->compression_format,
-                         out_image->is_miaf_compatible());
-
-  return error;
-}
-
-
-Error HeifContext::encode_image_as_hevc(std::shared_ptr<HeifPixelImage> image,
-                                        struct heif_encoder* encoder,
-                                        const struct heif_encoding_options* options,
-                                        enum heif_image_input_class input_class,
-                                        std::shared_ptr<Image>& out_image)
-{
-  heif_item_id image_id = m_heif_file->add_new_image("hvc1");
-  out_image = std::make_shared<Image>(this, image_id);
-
-
-  // --- check whether we have to convert the image color space
-
-  heif_colorspace colorspace = image->get_colorspace();
-  heif_chroma chroma = image->get_chroma_format();
-  auto nclx_profile = image->get_color_profile_nclx();
-  if (!nclx_profile) {
-    nclx_profile = std::make_shared<color_profile_nclx>();
-  }
-
-  if (encoder->plugin->plugin_api_version >= 2) {
-    encoder->plugin->query_input_colorspace2(encoder->encoder, &colorspace, &chroma);
-  }
-  else {
-    encoder->plugin->query_input_colorspace(&colorspace, &chroma);
-  }
-
-  if (colorspace != image->get_colorspace() ||
-      chroma != image->get_chroma_format()) {
-    // @TODO: use color profile when converting
-    image = convert_colorspace(image, colorspace, chroma, nclx_profile);
-    if (!image) {
-      return Error(heif_error_Unsupported_feature, heif_suberror_Unsupported_color_conversion);
-    }
-  }
-
-
-  out_image->set_size(image->get_width(heif_channel_Y),
-                      image->get_height(heif_channel_Y));
-
-
-  m_heif_file->add_hvcC_property(image_id);
-
-
-  heif_image c_api_image;
-  c_api_image.image = image;
-
-  struct heif_error err = encoder->plugin->encode_image(encoder->encoder, &c_api_image, input_class);
-  if (err.code) {
-    return Error(err.code,
-                 err.subcode,
-                 err.message);
-  }
-
-  int encoded_width, encoded_height;
-
-  for (;;) {
-    uint8_t* data;
-    int size;
-
-    encoder->plugin->get_compressed_data(encoder->encoder, &data, &size, NULL);
-
-    if (data == NULL) {
-      break;
-    }
-
-
-    const uint8_t NAL_SPS = 33;
-
-    if ((data[0] >> 1) == NAL_SPS) {
-      Box_hvcC::configuration config;
-
-      parse_sps_for_hvcC_configuration(data, size, &config, &encoded_width, &encoded_height);
-
-      m_heif_file->set_hvcC_configuration(image_id, config);
-    }
-
-    switch (data[0] >> 1) {
-      case 0x20:
-      case 0x21:
-      case 0x22:
-        m_heif_file->append_hvcC_nal_data(image_id, data, size);
-        break;
-
-      default:
-        m_heif_file->append_iloc_data_with_4byte_size(image_id, data, size);
-    }
-  }
-
-
-  // if image size was rounded up to even size, add a 'clap' box to crop the
-  // padding border away
-
-  if (out_image->get_width() != encoded_width ||
-      out_image->get_height() != encoded_height) {
-    if (options->macOS_compatibility_workaround == false) {
-      m_heif_file->add_clap_property(image_id,
-                                     out_image->get_width(),
-                                     out_image->get_height(),
-                                     encoded_width,
-                                     encoded_height);
-
-      m_heif_file->add_ispe_property(image_id, out_image->get_width(), out_image->get_height());
-
-      // MIAF 7.3.6.7
-
-      if (!is_integer_multiple_of_chroma_size(out_image->get_width(),
-                                              out_image->get_height(),
-                                              image->get_chroma_format())) {
-        out_image->mark_not_miaf_compatible();
-      }
-    }
-    else {
-      // --- wrap the encoded image in a grid image just to apply the cropping
-
-      heif_item_id grid_image_id = m_heif_file->add_new_image("grid");
-      auto grid_image = std::make_shared<Image>(this, grid_image_id);
-
-      m_heif_file->add_iref_reference(grid_image_id, fourcc("dimg"), {image_id});
-
-      ImageGrid grid;
-      grid.set_num_tiles(1, 1);
-      grid.set_output_size(image->get_width(heif_channel_Y), image->get_height(heif_channel_Y)); // TODO: using out_image->get_width/height() would be shorter.
-      auto grid_data = grid.write();
-
-      // MIAF 7.3.11.4.2
-
-      if (!is_integer_multiple_of_chroma_size(out_image->get_width(),
-                                              out_image->get_height(),
-                                              image->get_chroma_format())) {
-        grid_image->mark_not_miaf_compatible();
-      }
-
-      if ((encoded_width % 64) != 0 &&
-          (encoded_height % 64) != 0) {
-        grid_image->mark_not_miaf_compatible();
-      }
-
-
-      m_heif_file->append_iloc_data(grid_image_id, grid_data, 1);
-
-      m_heif_file->add_ispe_property(grid_image_id,
-                                     image->get_width(heif_channel_Y), // TODO: using out_image->get_width/height() would be shorter.
-                                     image->get_height(heif_channel_Y));
-
-      m_heif_file->add_ispe_property(image_id, encoded_width, encoded_height);
-
-
-      // --- now use the grid image instead of the original image
-
-      // hide the original image
-      m_heif_file->get_infe_box(image_id)->set_hidden_item(true);
-
-      out_image = grid_image;
-
-      // now use the grid image for all further property output
-      image_id = grid_image_id;
-    }
-  }
-  else {
-    m_heif_file->add_ispe_property(image_id, out_image->get_width(), out_image->get_height());
-  }
-
-  // --- choose which color profile to put into 'colr' box
-
-  if (input_class == heif_image_input_class_normal || input_class == heif_image_input_class_thumbnail) {
-    auto icc_profile = image->get_color_profile_icc();
-    if (icc_profile) {
-      m_heif_file->set_color_profile(image_id, icc_profile);
-    }
-
-    // save nclx profile
-
-    bool save_nclx_profile = (nclx_profile != nullptr);
-
-    // if there is an ICC profile, only save NCLX when we chose to save both profiles
-    if (icc_profile && !(options->version >= 3 &&
-                         options->save_two_colr_boxes_when_ICC_and_nclx_available)) {
-      save_nclx_profile = false;
-    }
-
-    // we might have turned off nclx completely because macOS/iOS cannot read it
-    if (options->version >= 4 && options->macOS_compatibility_workaround_no_nclx_profile) {
-      save_nclx_profile = false;
-    }
-
-    if (save_nclx_profile) {
-      m_heif_file->set_color_profile(image_id, nclx_profile);
-    }
-  }
-
-
-  // --- write PIXI property
-
-  if (image->get_chroma_format() == heif_chroma_monochrome) {
-    m_heif_file->add_pixi_property(image_id,
-                                   image->get_bits_per_pixel(heif_channel_Y), 0, 0);
-  }
-  else {
-    m_heif_file->add_pixi_property(image_id,
-                                   image->get_bits_per_pixel(heif_channel_Y),
-                                   image->get_bits_per_pixel(heif_channel_Cb),
-                                   image->get_bits_per_pixel(heif_channel_Cr));
-  }
-
-  m_top_level_images.push_back(out_image);
-
-
-
-  // --- If there is an alpha channel, add it as an additional image.
-  //     Save alpha after the color image because we need to know the final reference to the color image.
-
-  if (options->save_alpha_channel && image->has_channel(heif_channel_Alpha)) {
-
-    // --- generate alpha image
-    // TODO: can we directly code a monochrome image instead of the dummy color channels?
-
-    std::shared_ptr<HeifPixelImage> alpha_image;
-    alpha_image = create_alpha_image_from_image_alpha_channel(image);
-
-
-    // --- encode the alpha image
-
-    std::shared_ptr<HeifContext::Image> heif_alpha_image;
-
-    Error error = encode_image_as_hevc(alpha_image, encoder, options,
-                                       heif_image_input_class_alpha,
-                                       heif_alpha_image);
-    if (error) {
-      return error;
-    }
-
-    m_heif_file->add_iref_reference(heif_alpha_image->get_id(), fourcc("auxl"), {image_id});
-
-    if (image->is_premultiplied_alpha()) {
-      m_heif_file->add_iref_reference(image_id, fourcc("prem"), {heif_alpha_image->get_id()});
-    }
-
-    // TODO: MIAF says that the *:hevc:* urn is deprecated and we should use "urn:mpeg:mpegB:cicp:systems:auxiliary:alpha"
-    // Is this compatible to other decoders?
-    m_heif_file->set_auxC_property(heif_alpha_image->get_id(), "urn:mpeg:hevc:2015:auxid:1");
-  }
-
-
-  return Error::Ok;
-}
-
-
-Error HeifContext::encode_image_as_av1(std::shared_ptr<HeifPixelImage> image,
-                                       struct heif_encoder* encoder,
-                                       const struct heif_encoding_options* options,
-                                       enum heif_image_input_class input_class,
-                                       std::shared_ptr<Image>& out_image)
-{
-  heif_item_id image_id = m_heif_file->add_new_image("av01");
-
-  out_image = std::make_shared<Image>(this, image_id);
-  m_top_level_images.push_back(out_image);
-
-  // --- check whether we have to convert the image color space
-
-  heif_colorspace colorspace = image->get_colorspace();
-  heif_chroma chroma = image->get_chroma_format();
-  auto color_profile = image->get_color_profile_nclx();
-  if (!color_profile) {
-    color_profile = std::make_shared<color_profile_nclx>();
-  }
-  auto nclx_profile = std::dynamic_pointer_cast<const color_profile_nclx>(color_profile);
-
-  if (encoder->plugin->plugin_api_version >= 2) {
-    encoder->plugin->query_input_colorspace2(encoder->encoder, &colorspace, &chroma);
-  }
-  else {
-    encoder->plugin->query_input_colorspace(&colorspace, &chroma);
-  }
-
-  if (colorspace != image->get_colorspace() ||
-      chroma != image->get_chroma_format()) {
-    // @TODO: use color profile when converting
-    image = convert_colorspace(image, colorspace, chroma, nclx_profile);
-    if (!image) {
-      return Error(heif_error_Unsupported_feature, heif_suberror_Unsupported_color_conversion);
-    }
-  }
-
-
-  // --- choose which color profile to put into 'colr' box
-
-  if (input_class == heif_image_input_class_normal || input_class == heif_image_input_class_thumbnail) {
-    auto icc_profile = image->get_color_profile_icc();
-    if (icc_profile) {
-      m_heif_file->set_color_profile(image_id, icc_profile);
-    }
-
-    if (nclx_profile &&
-        (!icc_profile || (options->version >= 3 &&
-                          options->save_two_colr_boxes_when_ICC_and_nclx_available))) {
-      m_heif_file->set_color_profile(image_id, nclx_profile);
-    }
-  }
-
-
-  // --- if there is an alpha channel, add it as an additional image
-
-  if (options->save_alpha_channel && image->has_channel(heif_channel_Alpha)) {
-
-    // --- generate alpha image
-    // TODO: can we directly code a monochrome image instead of the dummy color channels?
-
-    std::shared_ptr<HeifPixelImage> alpha_image;
-    alpha_image = create_alpha_image_from_image_alpha_channel(image);
-
-
-    // --- encode the alpha image
-
-    std::shared_ptr<HeifContext::Image> heif_alpha_image;
-
-
-    Error error = encode_image_as_av1(alpha_image, encoder, options,
-                                      heif_image_input_class_alpha,
-                                      heif_alpha_image);
-    if (error) {
-      return error;
-    }
-
-    m_heif_file->add_iref_reference(heif_alpha_image->get_id(), fourcc("auxl"), {image_id});
-    m_heif_file->set_auxC_property(heif_alpha_image->get_id(), "urn:mpeg:mpegB:cicp:systems:auxiliary:alpha");
-
-    if (image->is_premultiplied_alpha()) {
-      m_heif_file->add_iref_reference(image_id, fourcc("prem"), {heif_alpha_image->get_id()});
-    }
-  }
-
-  Box_av1C::configuration config;
-
-  // Fill preliminary av1C in case we cannot parse the sequence_header() correctly in the code below.
-  // TODO: maybe we can remove this later.
-  fill_av1C_configuration(&config, image);
-
-  heif_image c_api_image;
-  c_api_image.image = image;
-
-  encoder->plugin->encode_image(encoder->encoder, &c_api_image, input_class);
-
-  for (;;) {
-    uint8_t* data;
-    int size;
-
-    encoder->plugin->get_compressed_data(encoder->encoder, &data, &size, nullptr);
-
-    bool found_config = fill_av1C_configuration_from_stream(&config, data, size);
-    (void)found_config;
-
-    if (data == nullptr) {
-      break;
-    }
-
-    std::vector<uint8_t> vec;
-    vec.resize(size);
-    memcpy(vec.data(), data, size);
-
-    m_heif_file->append_iloc_data(image_id, vec);
-  }
-
-  m_heif_file->add_av1C_property(image_id);
-  m_heif_file->set_av1C_configuration(image_id, config);
-
-
-  uint32_t input_width, input_height;
-  input_width = image->get_width();
-  input_height = image->get_height();
-  m_heif_file->add_ispe_property(image_id, input_width, input_height);
-
-
-  if (encoder->plugin->plugin_api_version >= 3) {
-    uint32_t encoded_width, encoded_height;
-
-    encoder->plugin->query_encoded_size(encoder->encoder,
-                                        input_width, input_height,
-                                        &encoded_width,
-                                        &encoded_height);
-    if (input_width != encoded_width ||
-        input_height != encoded_height) {
-      m_heif_file->add_clap_property(image_id, input_width, input_height,
-                                     encoded_width, encoded_height);
-
-      // MIAF 7.3.6.7
-
-      if (!is_integer_multiple_of_chroma_size(out_image->get_width(),
-                                              out_image->get_height(),
-                                              image->get_chroma_format())) {
-        out_image->mark_not_miaf_compatible();
-      }
-    }
-  }
-
-
-  // --- write PIXI property
-
-  if (image->get_chroma_format() == heif_chroma_monochrome) {
-    m_heif_file->add_pixi_property(image_id,
-                                   image->get_bits_per_pixel(heif_channel_Y), 0, 0);
-  }
-  else {
-    m_heif_file->add_pixi_property(image_id,
-                                   image->get_bits_per_pixel(heif_channel_Y),
-                                   image->get_bits_per_pixel(heif_channel_Cb),
-                                   image->get_bits_per_pixel(heif_channel_Cr));
-  }
-
-  return Error::Ok;
-}
-
-
-void HeifContext::set_primary_image(std::shared_ptr<Image> image)
-{
-  // update heif context
-
-  if (m_primary_image) {
-    m_primary_image->set_primary(false);
-  }
-
-  image->set_primary(true);
-  m_primary_image = image;
-
-
-  // update pitm box in HeifFile
-
-  m_heif_file->set_primary_item_id(image->get_id());
-}
-
-
-Error HeifContext::set_primary_item(heif_item_id id)
-{
-  auto iter = m_all_images.find(id);
-  if (iter == m_all_images.end()) {
-    return Error(heif_error_Usage_error,
-                 heif_suberror_No_or_invalid_primary_item,
-                 "Cannot set primary item as the ID does not exist.");
-  }
-
-  set_primary_image(iter->second);
-
-  return Error::Ok;
-}
-
-
-Error HeifContext::assign_thumbnail(std::shared_ptr<Image> master_image,
-                                    std::shared_ptr<Image> thumbnail_image)
-{
-  m_heif_file->add_iref_reference(thumbnail_image->get_id(),
-                                  fourcc("thmb"), {master_image->get_id()});
-
-  return Error::Ok;
-}
-
-
-Error HeifContext::encode_thumbnail(std::shared_ptr<HeifPixelImage> image,
-                                    struct heif_encoder* encoder,
-                                    const struct heif_encoding_options* options,
-                                    int bbox_size,
-                                    std::shared_ptr<Image>& out_thumbnail_handle)
-{
-  Error error;
-
-  int orig_width = image->get_width();
-  int orig_height = image->get_height();
-
-  int thumb_width, thumb_height;
-
-  if (orig_width <= bbox_size && orig_height <= bbox_size) {
-    // original image is smaller than thumbnail size -> do not encode any thumbnail
-
-    out_thumbnail_handle.reset();
-    return Error::Ok;
-  }
-  else if (orig_width > orig_height) {
-    thumb_height = orig_height * bbox_size / orig_width;
-    thumb_width = bbox_size;
-  }
-  else {
-    thumb_width = orig_width * bbox_size / orig_height;
-    thumb_height = bbox_size;
-  }
-
-
-  // round size to even width and height
-
-  thumb_width &= ~1;
-  thumb_height &= ~1;
-
-
-  std::shared_ptr<HeifPixelImage> thumbnail_image;
-  error = image->scale_nearest_neighbor(thumbnail_image, thumb_width, thumb_height);
-  if (error) {
-    return error;
-  }
-
-  error = encode_image(thumbnail_image,
-                       encoder, options,
-                       heif_image_input_class_thumbnail,
-                       out_thumbnail_handle);
-  if (error) {
-    return error;
-  }
-
-  return error;
-}
-
-
-Error HeifContext::add_exif_metadata(std::shared_ptr<Image> master_image, const void* data, int size)
-{
-  // find location of TIFF header
-  uint32_t offset = 0;
-  const char* tiffmagic1 = "MM\0*";
-  const char* tiffmagic2 = "II*\0";
-  while (offset + 4 < (unsigned int) size) {
-    if (!memcmp((uint8_t*) data + offset, tiffmagic1, 4)) break;
-    if (!memcmp((uint8_t*) data + offset, tiffmagic2, 4)) break;
-    offset++;
-  }
-  if (offset >= (unsigned int) size) {
-    return Error(heif_error_Usage_error,
-                 heif_suberror_Invalid_parameter_value,
-                 "Could not find location of TIFF header in Exif metadata.");
-  }
-
-
-  std::vector<uint8_t> data_array;
-  data_array.resize(size + 4);
-  data_array[0] = (uint8_t) ((offset >> 24) & 0xFF);
-  data_array[1] = (uint8_t) ((offset >> 16) & 0xFF);
-  data_array[2] = (uint8_t) ((offset >> 8) & 0xFF);
-  data_array[3] = (uint8_t) ((offset) & 0xFF);
-  memcpy(data_array.data() + 4, data, size);
-
-
-  return add_generic_metadata(master_image,
-                              data_array.data(), (int) data_array.size(),
-                              "Exif", nullptr);
-}
-
-
-Error HeifContext::add_XMP_metadata(std::shared_ptr<Image> master_image, const void* data, int size)
-{
-  return add_generic_metadata(master_image, data, size, "mime", "application/rdf+xml");
-}
-
-
-Error HeifContext::add_generic_metadata(std::shared_ptr<Image> master_image, const void* data, int size,
-                                        const char* item_type, const char* content_type)
-{
-  // create an infe box describing what kind of data we are storing (this also creates a new ID)
-
-  auto metadata_infe_box = m_heif_file->add_new_infe_box(item_type);
-  metadata_infe_box->set_hidden_item(true);
-  if (content_type != nullptr) {
-    metadata_infe_box->set_content_type(content_type);
-  }
-
-  heif_item_id metadata_id = metadata_infe_box->get_item_ID();
-
-
-  // we assign this data to the image
-
-  m_heif_file->add_iref_reference(metadata_id,
-                                  fourcc("cdsc"), {master_image->get_id()});
-
-
-  // copy the XMP data into the file, store the pointer to it in an iloc box entry
-
-  std::vector<uint8_t> data_array;
-  data_array.resize(size);
-  memcpy(data_array.data(), data, size);
-
-  m_heif_file->append_iloc_data(metadata_id, data_array);
-
-  return Error::Ok;
-}
diff --git a/libheif/heif_context.h b/libheif/heif_context.h
deleted file mode 100644
index 2b00f251db..0000000000
--- a/libheif/heif_context.h
+++ /dev/null
@@ -1,439 +0,0 @@
-/*
- * HEIF codec.
- * Copyright (c) 2017 struktur AG, Dirk Farin <farin@struktur.de>
- *
- * This file is part of libheif.
- *
- * libheif is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as
- * published by the Free Software Foundation, either version 3 of
- * the License, or (at your option) any later version.
- *
- * libheif is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef LIBHEIF_HEIF_CONTEXT_H
-#define LIBHEIF_HEIF_CONTEXT_H
-
-#include <map>
-#include <memory>
-#include <set>
-#include <string>
-#include <vector>
-#include <utility>
-
-#include "error.h"
-
-#include "heif.h"
-#include "heif_plugin.h"
-#include "bitstream.h"
-
-#include "box.h" // only for color_profile, TODO: maybe move the color_profiles to its own header
-
-namespace heif {
-  class HeifContext;
-}
-
-
-namespace heif {
-
-  class HeifFile;
-
-  class HeifPixelImage;
-
-  class StreamWriter;
-
-
-  class ImageMetadata
-  {
-  public:
-    heif_item_id item_id;
-    std::string item_type;  // e.g. "Exif"
-    std::string content_type;
-    std::vector<uint8_t> m_data;
-  };
-
-
-  // This is a higher-level view than HeifFile.
-  // Images are grouped logically into main images and their thumbnails.
-  // The class also handles automatic color-space conversion.
-  class HeifContext : public ErrorBuffer
-  {
-  public:
-    HeifContext();
-
-    ~HeifContext();
-
-    void set_max_decoding_threads(int max_threads) { m_max_decoding_threads = max_threads; }
-
-    void set_maximum_image_size_limit(int maximum_size)
-    {
-      m_maximum_image_width_limit = maximum_size;
-      m_maximum_image_height_limit = maximum_size;
-    }
-
-    Error read(std::shared_ptr<StreamReader> reader);
-
-    Error read_from_file(const char* input_filename);
-
-    Error read_from_memory(const void* data, size_t size, bool copy);
-
-    class Image : public ErrorBuffer
-    {
-    public:
-      Image(HeifContext* file, heif_item_id id);
-
-      ~Image();
-
-      void clear()
-      {
-        m_thumbnails.clear();
-        m_alpha_channel.reset();
-        m_depth_channel.reset();
-        m_aux_images.clear();
-      }
-
-      void set_resolution(int w, int h)
-      {
-        m_width = w;
-        m_height = h;
-      }
-
-      void set_ispe_resolution(int w, int h)
-      {
-        m_ispe_width = w;
-        m_ispe_height = h;
-      }
-
-      void set_primary(bool flag = true) { m_is_primary = flag; }
-
-      heif_item_id get_id() const { return m_id; }
-
-      //void set_id(heif_item_id id) { m_id=id; }  (already set in constructor)
-
-      int get_width() const { return m_width; }
-
-      int get_height() const { return m_height; }
-
-      int get_ispe_width() const { return m_ispe_width; }
-
-      int get_ispe_height() const { return m_ispe_height; }
-
-      int get_luma_bits_per_pixel() const;
-
-      int get_chroma_bits_per_pixel() const;
-
-      bool is_primary() const { return m_is_primary; }
-
-      void set_size(int w, int h)
-      {
-        m_width = w;
-        m_height = h;
-      }
-
-
-      // -- thumbnails
-
-      void set_is_thumbnail_of(heif_item_id id)
-      {
-        m_is_thumbnail = true;
-        m_thumbnail_ref_id = id;
-      }
-
-      void add_thumbnail(const std::shared_ptr<Image>& img) { m_thumbnails.push_back(img); }
-
-      bool is_thumbnail() const { return m_is_thumbnail; }
-
-      const std::vector<std::shared_ptr<Image>>& get_thumbnails() const { return m_thumbnails; }
-
-
-      // --- alpha channel
-
-      void set_is_alpha_channel_of(heif_item_id id, bool consumed)
-      {
-        m_is_alpha_channel = true;
-        m_alpha_channel_ref_id = id;
-        m_implicitly_consumed_alpha = consumed;
-      }
-
-      void set_alpha_channel(std::shared_ptr<Image> img) { m_alpha_channel = std::move(img); }
-
-      bool is_alpha_channel() const { return m_is_alpha_channel; }
-
-      const std::shared_ptr<Image>& get_alpha_channel() const { return m_alpha_channel; }
-
-      void set_is_premultiplied_alpha(bool flag) { m_premultiplied_alpha = flag; }
-
-      bool is_premultiplied_alpha() const { return m_premultiplied_alpha; }
-
-
-      // --- depth channel
-
-      void set_is_depth_channel_of(heif_item_id id)
-      {
-        m_is_depth_channel = true;
-        m_depth_channel_ref_id = id;
-      }
-
-      void set_depth_channel(std::shared_ptr<Image> img) { m_depth_channel = std::move(img); }
-
-      bool is_depth_channel() const { return m_is_depth_channel; }
-
-      const std::shared_ptr<Image>& get_depth_channel() const { return m_depth_channel; }
-
-
-      void set_depth_representation_info(struct heif_depth_representation_info& info)
-      {
-        m_has_depth_representation_info = true;
-        m_depth_representation_info = info;
-      }
-
-      bool has_depth_representation_info() const
-      {
-        return m_has_depth_representation_info;
-      }
-
-      const struct heif_depth_representation_info& get_depth_representation_info() const
-      {
-        return m_depth_representation_info;
-      }
-
-
-      // --- generic aux image
-
-      void set_is_aux_image_of(heif_item_id id, const std::string& aux_type)
-      {
-        m_is_aux_image = true;
-        m_aux_image_ref_id = id;
-        m_aux_image_type = aux_type;
-      }
-
-      void add_aux_image(std::shared_ptr<Image> img) { m_aux_images.push_back(std::move(img)); }
-
-      bool is_aux_image() const { return m_is_aux_image; }
-
-      const std::string& get_aux_type() const { return m_aux_image_type; }
-
-      std::vector<std::shared_ptr<Image>> get_aux_images(int aux_image_filter = 0) const
-      {
-        if (aux_image_filter == 0) {
-          return m_aux_images;
-        }
-        else {
-          std::vector<std::shared_ptr<Image>> auxImgs;
-          for (auto aux : m_aux_images) {
-            if ((aux_image_filter & LIBHEIF_AUX_IMAGE_FILTER_OMIT_ALPHA) &&
-                aux->is_alpha_channel() && aux->m_implicitly_consumed_alpha) {
-              continue;
-            }
-
-            if ((aux_image_filter & LIBHEIF_AUX_IMAGE_FILTER_OMIT_DEPTH) &&
-                aux->is_depth_channel()) {
-              continue;
-            }
-
-            auxImgs.push_back(aux);
-          }
-
-          return auxImgs;
-        }
-      }
-
-
-      // --- metadata
-
-      void add_metadata(std::shared_ptr<ImageMetadata> metadata)
-      {
-        m_metadata.push_back(std::move(metadata));
-      }
-
-      const std::vector<std::shared_ptr<ImageMetadata>>& get_metadata() const { return m_metadata; }
-
-
-      // --- miaf
-
-      void mark_not_miaf_compatible() { m_miaf_compatible = false; }
-
-      bool is_miaf_compatible() const { return m_miaf_compatible; }
-
-
-      // === writing ===
-
-      void set_preencoded_hevc_image(const std::vector<uint8_t>& data);
-
-      const std::shared_ptr<const color_profile_nclx>& get_color_profile_nclx() const { return m_color_profile_nclx; }
-
-      const std::shared_ptr<const color_profile_raw>& get_color_profile_icc() const { return m_color_profile_icc; }
-
-      void set_color_profile(std::shared_ptr<const color_profile> profile)
-      {
-        auto icc = std::dynamic_pointer_cast<const color_profile_raw>(profile);
-        if (icc) {
-          m_color_profile_icc = std::move(icc);
-        }
-
-        auto nclx = std::dynamic_pointer_cast<const color_profile_nclx>(profile);
-        if (nclx) {
-          m_color_profile_nclx = std::move(nclx);
-        }
-      };
-
-    private:
-      HeifContext* m_heif_context;
-
-      heif_item_id m_id = 0;
-      uint32_t m_width = 0, m_height = 0;
-      uint32_t m_ispe_width = 0, m_ispe_height = 0; // original image resolution
-      bool m_is_primary = false;
-
-      bool m_is_thumbnail = false;
-      heif_item_id m_thumbnail_ref_id = 0;
-
-      std::vector<std::shared_ptr<Image>> m_thumbnails;
-
-      bool m_is_alpha_channel = false;
-      bool m_premultiplied_alpha = false;
-      bool m_implicitly_consumed_alpha = false; // alpha data was integrated into main color image
-      heif_item_id m_alpha_channel_ref_id = 0;
-      std::shared_ptr<Image> m_alpha_channel;
-
-      bool m_is_depth_channel = false;
-      heif_item_id m_depth_channel_ref_id = 0;
-      std::shared_ptr<Image> m_depth_channel;
-
-      bool m_has_depth_representation_info = false;
-      struct heif_depth_representation_info m_depth_representation_info;
-
-      heif_item_id m_aux_image_ref_id = 0;
-      bool m_is_aux_image = false;
-      std::string m_aux_image_type;
-      std::vector<std::shared_ptr<Image>> m_aux_images;
-
-      std::vector<std::shared_ptr<ImageMetadata>> m_metadata;
-
-      std::shared_ptr<const color_profile_nclx> m_color_profile_nclx;
-      std::shared_ptr<const color_profile_raw> m_color_profile_icc;
-
-      bool m_miaf_compatible = true;
-    };
-
-    std::vector<std::shared_ptr<Image>> get_top_level_images() { return m_top_level_images; }
-
-    std::shared_ptr<Image> get_primary_image() { return m_primary_image; }
-
-    void register_decoder(const heif_decoder_plugin* decoder_plugin);
-
-    bool is_image(heif_item_id ID) const;
-
-    Error decode_image_user(heif_item_id ID, std::shared_ptr<HeifPixelImage>& img,
-                            heif_colorspace out_colorspace,
-                            heif_chroma out_chroma,
-                            const struct heif_decoding_options* options = nullptr) const;
-
-    Error decode_image_planar(heif_item_id ID, std::shared_ptr<HeifPixelImage>& img,
-                              heif_colorspace out_colorspace,
-                              const struct heif_decoding_options* options,
-                              bool alphaImage) const;
-
-    std::string debug_dump_boxes() const;
-
-
-    // === writing ===
-
-    // Create all boxes necessary for an empty HEIF file.
-    // Note that this is no valid HEIF file, since some boxes (e.g. pitm) are generated, but
-    // contain no valid data yet.
-    void reset_to_empty_heif();
-
-    Error encode_image(std::shared_ptr<HeifPixelImage> image,
-                       struct heif_encoder* encoder,
-                       const struct heif_encoding_options* options,
-                       enum heif_image_input_class input_class,
-                       std::shared_ptr<Image>& out_image);
-
-    Error encode_image_as_hevc(std::shared_ptr<HeifPixelImage> image,
-                               struct heif_encoder* encoder,
-                               const struct heif_encoding_options* options,
-                               enum heif_image_input_class input_class,
-                               std::shared_ptr<Image>& out_image);
-
-    Error encode_image_as_av1(std::shared_ptr<HeifPixelImage> image,
-                              struct heif_encoder* encoder,
-                              const struct heif_encoding_options* options,
-                              enum heif_image_input_class input_class,
-                              std::shared_ptr<Image>& out_image);
-
-    void set_primary_image(std::shared_ptr<Image> image);
-
-    Error set_primary_item(heif_item_id id);
-
-    bool is_primary_image_set() const { return m_primary_image != nullptr; }
-
-    Error assign_thumbnail(std::shared_ptr<Image> master_image,
-                           std::shared_ptr<Image> thumbnail_image);
-
-    Error encode_thumbnail(std::shared_ptr<HeifPixelImage> image,
-                           struct heif_encoder* encoder,
-                           const struct heif_encoding_options* options,
-                           int bbox_size,
-                           std::shared_ptr<Image>& out_image_handle);
-
-    Error add_exif_metadata(std::shared_ptr<Image> master_image, const void* data, int size);
-
-    Error add_XMP_metadata(std::shared_ptr<Image> master_image, const void* data, int size);
-
-    Error add_generic_metadata(std::shared_ptr<Image> master_image, const void* data, int size,
-                               const char* item_type, const char* content_type);
-
-    void write(StreamWriter& writer);
-
-  private:
-    const struct heif_decoder_plugin* get_decoder(enum heif_compression_format type) const;
-
-    std::set<const struct heif_decoder_plugin*> m_decoder_plugins;
-
-    std::map<heif_item_id, std::shared_ptr<Image>> m_all_images;
-
-    // We store this in a vector because we need stable indices for the C API.
-    // TODO: stable indices are obsolet now...
-    std::vector<std::shared_ptr<Image>> m_top_level_images;
-
-    std::shared_ptr<Image> m_primary_image; // shortcut to primary image
-
-    std::shared_ptr<HeifFile> m_heif_file;
-
-    int m_max_decoding_threads = 4;
-
-    uint32_t m_maximum_image_width_limit;
-    uint32_t m_maximum_image_height_limit;
-
-    Error interpret_heif_file();
-
-    void remove_top_level_image(std::shared_ptr<Image> image);
-
-    Error decode_full_grid_image(heif_item_id ID,
-                                 std::shared_ptr<HeifPixelImage>& img,
-                                 const std::vector<uint8_t>& grid_data) const;
-
-    Error decode_and_paste_tile_image(heif_item_id tileID,
-                                      std::shared_ptr<HeifPixelImage> out_image,
-                                      int x0, int y0) const;
-
-    Error decode_derived_image(heif_item_id ID,
-                               std::shared_ptr<HeifPixelImage>& img) const;
-
-    Error decode_overlay_image(heif_item_id ID,
-                               std::shared_ptr<HeifPixelImage>& img,
-                               const std::vector<uint8_t>& overlay_data) const;
-
-    Error get_id_of_non_virtual_child_image(heif_item_id in, heif_item_id& out) const;
-  };
-}
-
-#endif
diff --git a/libheif/heif_decoder_aom.cc b/libheif/heif_decoder_aom.cc
deleted file mode 100644
index 817c5d83f3..0000000000
--- a/libheif/heif_decoder_aom.cc
+++ /dev/null
@@ -1,274 +0,0 @@
-/*
- * AVIF codec.
- * Copyright (c) 2019 struktur AG, Dirk Farin <farin@struktur.de>
- *
- * This file is part of libheif.
- *
- * libheif is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as
- * published by the Free Software Foundation, either version 3 of
- * the License, or (at your option) any later version.
- *
- * libheif is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "heif.h"
-#include "heif_plugin.h"
-
-#if defined(HAVE_CONFIG_H)
-#include "config.h"
-#endif
-
-#include <memory>
-#include <cstring>
-#include <cassert>
-
-#include <aom/aom_decoder.h>
-#include <aom/aomdx.h>
-
-
-struct aom_decoder
-{
-  aom_codec_ctx_t codec;
-  bool codec_initialized = false;
-
-  aom_codec_iface_t* iface;
-};
-
-static const char kSuccess[] = "Success";
-static const char kEmptyString[] = "";
-
-static const int AOM_PLUGIN_PRIORITY = 100;
-
-#define MAX_PLUGIN_NAME_LENGTH 80
-
-static char plugin_name[MAX_PLUGIN_NAME_LENGTH];
-
-
-static const char* aom_plugin_name()
-{
-  if (strlen(aom_codec_iface_name(aom_codec_av1_dx())) < MAX_PLUGIN_NAME_LENGTH) {
-    strcpy(plugin_name, aom_codec_iface_name(aom_codec_av1_dx()));
-  }
-  else {
-    strcpy(plugin_name, "AOMedia AV1 decoder");
-  }
-
-  return plugin_name;
-}
-
-
-static void aom_init_plugin()
-{
-}
-
-
-static void aom_deinit_plugin()
-{
-}
-
-
-static int aom_does_support_format(enum heif_compression_format format)
-{
-  if (format == heif_compression_AV1) {
-    return AOM_PLUGIN_PRIORITY;
-  }
-  else {
-    return 0;
-  }
-}
-
-
-struct heif_error aom_new_decoder(void** dec)
-{
-  struct aom_decoder* decoder = new aom_decoder();
-
-  decoder->iface = aom_codec_av1_dx();
-
-  aom_codec_err_t aomerr = aom_codec_dec_init(&decoder->codec, decoder->iface, NULL, 0);
-  if (aomerr) {
-    *dec = NULL;
-
-    delete decoder;
-
-    struct heif_error err = {heif_error_Decoder_plugin_error, heif_suberror_Unspecified, aom_codec_err_to_string(aomerr)};
-    return err;
-  }
-
-  decoder->codec_initialized = true;
-  *dec = decoder;
-
-  struct heif_error err = {heif_error_Ok, heif_suberror_Unspecified, kSuccess};
-  return err;
-}
-
-
-void aom_free_decoder(void* decoder_raw)
-{
-  struct aom_decoder* decoder = (aom_decoder*) decoder_raw;
-
-  if (!decoder) {
-    return;
-  }
-
-  if (decoder->codec_initialized) {
-    aom_codec_destroy(&decoder->codec);
-    decoder->codec_initialized = false;
-  }
-
-  delete decoder;
-}
-
-
-struct heif_error aom_push_data(void* decoder_raw, const void* frame_data, size_t frame_size)
-{
-  struct aom_decoder* decoder = (struct aom_decoder*) decoder_raw;
-
-  aom_codec_err_t aomerr;
-  aomerr = aom_codec_decode(&decoder->codec, (const uint8_t*) frame_data, frame_size, NULL);
-  if (aomerr) {
-    struct heif_error err = {heif_error_Invalid_input, heif_suberror_Unspecified, aom_codec_err_to_string(aomerr)};
-    return err;
-  }
-
-
-  struct heif_error err = {heif_error_Ok, heif_suberror_Unspecified, kSuccess};
-  return err;
-}
-
-
-struct heif_error aom_decode_image(void* decoder_raw, struct heif_image** out_img)
-{
-  struct aom_decoder* decoder = (struct aom_decoder*) decoder_raw;
-
-  aom_codec_iter_t iter = NULL;
-  aom_image_t* img = NULL;
-
-  img = aom_codec_get_frame(&decoder->codec, &iter);
-
-  if (img == NULL) {
-    struct heif_error err = {heif_error_Decoder_plugin_error,
-                             heif_suberror_Unspecified,
-                             kEmptyString};
-    return err;
-  }
-
-
-  if (img->fmt != AOM_IMG_FMT_I420 &&
-      img->fmt != AOM_IMG_FMT_I42016 &&
-      img->fmt != AOM_IMG_FMT_I422 &&
-      img->fmt != AOM_IMG_FMT_I42216 &&
-      img->fmt != AOM_IMG_FMT_I444 &&
-      img->fmt != AOM_IMG_FMT_I44416) {
-    struct heif_error err = {heif_error_Decoder_plugin_error,
-                             heif_suberror_Unsupported_image_type,
-                             kEmptyString};
-    return err;
-  }
-
-
-  heif_chroma chroma;
-  if (img->fmt == AOM_IMG_FMT_I444 ||
-      img->fmt == AOM_IMG_FMT_I44416) {
-    chroma = heif_chroma_444;
-  }
-  else if (img->fmt == AOM_IMG_FMT_I422 ||
-           img->fmt == AOM_IMG_FMT_I42216) {
-    chroma = heif_chroma_422;
-  }
-  else {
-    chroma = heif_chroma_420;
-  }
-
-  struct heif_image* heif_img = nullptr;
-  struct heif_error err = heif_image_create(img->d_w, img->d_h,
-                                            heif_colorspace_YCbCr,
-                                            chroma,
-                                            &heif_img);
-  if (err.code != heif_error_Ok) {
-    assert(heif_img==nullptr);
-    return err;
-  }
-
-
-  // --- read nclx parameters from decoded AV1 bitstream
-
-  heif_color_profile_nclx nclx;
-  nclx.color_primaries = (heif_color_primaries) img->cp;
-  nclx.transfer_characteristics = (heif_transfer_characteristics) img->tc;
-  nclx.matrix_coefficients = (heif_matrix_coefficients) img->mc;
-  nclx.full_range_flag = (img->range == AOM_CR_FULL_RANGE);
-  heif_image_set_nclx_color_profile(heif_img, &nclx);
-
-
-  // --- transfer data from aom_image_t to HeifPixelImage
-
-  heif_channel channel2plane[3] = {
-      heif_channel_Y,
-      heif_channel_Cb,
-      heif_channel_Cr
-  };
-
-
-  for (int c = 0; c < 3; c++) {
-    int bpp = img->bit_depth;
-
-    const uint8_t* data = img->planes[c];
-    int stride = img->stride[c];
-
-    int w = img->d_w;
-    int h = img->d_h;
-
-    if (c > 0 && chroma == heif_chroma_420) {
-      w = (w + 1) / 2;
-      h = (h + 1) / 2;
-    }
-    else if (c > 0 && chroma == heif_chroma_422) {
-      w = (w + 1) / 2;
-    }
-
-    err = heif_image_add_plane(heif_img, channel2plane[c], w, h, bpp);
-    if (err.code != heif_error_Ok) {
-      heif_image_release(heif_img);
-      return err;
-    }
-
-    int dst_stride;
-    uint8_t* dst_mem = heif_image_get_plane(heif_img, channel2plane[c], &dst_stride);
-
-    int bytes_per_pixel = (bpp + 7) / 8;
-
-    for (int y = 0; y < h; y++) {
-      memcpy(dst_mem + y * dst_stride, data + y * stride, w * bytes_per_pixel);
-    }
-  }
-
-  *out_img = heif_img;
-  return err;
-}
-
-
-static const struct heif_decoder_plugin decoder_aom
-    {
-        1,
-        aom_plugin_name,
-        aom_init_plugin,
-        aom_deinit_plugin,
-        aom_does_support_format,
-        aom_new_decoder,
-        aom_free_decoder,
-        aom_push_data,
-        aom_decode_image
-    };
-
-
-const struct heif_decoder_plugin* get_decoder_plugin_aom()
-{
-  return &decoder_aom;
-}
diff --git a/libheif/heif_decoder_dav1d.cc b/libheif/heif_decoder_dav1d.cc
deleted file mode 100644
index 4a2f1e29b6..0000000000
--- a/libheif/heif_decoder_dav1d.cc
+++ /dev/null
@@ -1,303 +0,0 @@
-/*
- * AVIF codec.
- * Copyright (c) 2020 struktur AG, Dirk Farin <farin@struktur.de>
- *
- * This file is part of libheif.
- *
- * libheif is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as
- * published by the Free Software Foundation, either version 3 of
- * the License, or (at your option) any later version.
- *
- * libheif is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "heif.h"
-#include "heif_plugin.h"
-#include "heif_limits.h"
-#include "heif_image.h"
-
-#if defined(HAVE_CONFIG_H)
-#include "config.h"
-#endif
-
-#include <memory>
-#include <cstring>
-#include <cassert>
-
-#include <dav1d/version.h>
-#include <dav1d/dav1d.h>
-
-struct dav1d_decoder
-{
-  Dav1dSettings settings;
-  Dav1dContext* context;
-  Dav1dData data;
-};
-
-static const char kEmptyString[] = "";
-
-static const int DAV1D_PLUGIN_PRIORITY = 150;
-
-#define MAX_PLUGIN_NAME_LENGTH 80
-
-static char plugin_name[MAX_PLUGIN_NAME_LENGTH];
-
-
-static const char* dav1d_plugin_name()
-{
-  snprintf(plugin_name, MAX_PLUGIN_NAME_LENGTH, "dav1d v%d.%d.%d",
-           DAV1D_API_VERSION_MAJOR,
-           DAV1D_API_VERSION_MINOR,
-           DAV1D_API_VERSION_PATCH);
-
-  // make sure that the string is null-terminated
-  plugin_name[MAX_PLUGIN_NAME_LENGTH - 1] = 0;
-
-  return plugin_name;
-}
-
-
-static void dav1d_init_plugin()
-{
-}
-
-
-static void dav1d_deinit_plugin()
-{
-}
-
-
-static int dav1d_does_support_format(enum heif_compression_format format)
-{
-  if (format == heif_compression_AV1) {
-    return DAV1D_PLUGIN_PRIORITY;
-  }
-  else {
-    return 0;
-  }
-}
-
-
-struct heif_error dav1d_new_decoder(void** dec)
-{
-  auto* decoder = new dav1d_decoder();
-
-  dav1d_default_settings(&decoder->settings);
-
-  decoder->settings.frame_size_limit = MAX_IMAGE_WIDTH * MAX_IMAGE_HEIGHT;
-  decoder->settings.all_layers = 0;
-
-  if (dav1d_open(&decoder->context, &decoder->settings) != 0) {
-    struct heif_error err = {heif_error_Decoder_plugin_error, heif_suberror_Unspecified, kSuccess};
-    return err;
-  }
-
-  memset(&decoder->data, 0, sizeof(Dav1dData));
-
-  *dec = decoder;
-
-  struct heif_error err = {heif_error_Ok, heif_suberror_Unspecified, kSuccess};
-  return err;
-}
-
-
-void dav1d_free_decoder(void* decoder_raw)
-{
-  auto* decoder = (dav1d_decoder*) decoder_raw;
-
-  if (!decoder) {
-    return;
-  }
-
-  if (decoder->data.sz) {
-    dav1d_data_unref(&decoder->data);
-  }
-  if (decoder->context) {
-    dav1d_close(&decoder->context);
-  }
-
-  delete decoder;
-}
-
-
-struct heif_error dav1d_push_data(void* decoder_raw, const void* frame_data, size_t frame_size)
-{
-  auto* decoder = (struct dav1d_decoder*) decoder_raw;
-
-  assert(decoder->data.sz == 0);
-
-  uint8_t* d = dav1d_data_create(&decoder->data, frame_size);
-  if (d == nullptr) {
-    struct heif_error err = {heif_error_Memory_allocation_error, heif_suberror_Unspecified, kSuccess};
-    return err;
-  }
-
-  memcpy(d, frame_data, frame_size);
-
-  struct heif_error err = {heif_error_Ok, heif_suberror_Unspecified, kSuccess};
-  return err;
-}
-
-
-struct heif_error dav1d_decode_image(void* decoder_raw, struct heif_image** out_img)
-{
-  auto* decoder = (struct dav1d_decoder*) decoder_raw;
-
-  struct heif_error err;
-
-  Dav1dPicture frame;
-  memset(&frame, 0, sizeof(Dav1dPicture));
-
-  for (;;) {
-    int res = dav1d_send_data(decoder->context, &decoder->data);
-    if ((res < 0) && (res != DAV1D_ERR(EAGAIN))) {
-      err = {heif_error_Decoder_plugin_error,
-             heif_suberror_Unspecified,
-             kEmptyString};
-      return err;
-    }
-
-    res = dav1d_get_picture(decoder->context, &frame);
-    if (res == DAV1D_ERR(EAGAIN)) {
-      err = {heif_error_Decoder_plugin_error,
-             heif_suberror_Unspecified,
-             kEmptyString};
-      return err;
-    }
-    else if (res < 0) {
-      err = {heif_error_Decoder_plugin_error,
-             heif_suberror_Unspecified,
-             kEmptyString};
-      return err;
-    }
-    else {
-      break;
-    }
-  }
-
-  heif_chroma chroma;
-  heif_colorspace colorspace;
-  switch (frame.p.layout) {
-    case DAV1D_PIXEL_LAYOUT_I420:
-      chroma = heif_chroma_420;
-      colorspace = heif_colorspace_YCbCr;
-      break;
-    case DAV1D_PIXEL_LAYOUT_I422:
-      chroma = heif_chroma_422;
-      colorspace = heif_colorspace_YCbCr;
-      break;
-    case DAV1D_PIXEL_LAYOUT_I444:
-      chroma = heif_chroma_444;
-      colorspace = heif_colorspace_YCbCr;
-      break;
-    case DAV1D_PIXEL_LAYOUT_I400:
-      chroma = heif_chroma_monochrome;
-      colorspace = heif_colorspace_monochrome;
-      break;
-    default: {
-      err = {heif_error_Decoder_plugin_error,
-             heif_suberror_Unspecified,
-             kEmptyString};
-      return err;
-    }
-  }
-
-
-  struct heif_image* heif_img = nullptr;
-  err = heif_image_create(frame.p.w, frame.p.h,
-                          colorspace,
-                          chroma,
-                          &heif_img);
-  if (err.code != heif_error_Ok) {
-    assert(heif_img == nullptr);
-    return err;
-  }
-
-
-  // --- read nclx parameters from decoded AV1 bitstream
-
-  heif_color_profile_nclx nclx;
-  nclx.color_primaries = (heif_color_primaries) frame.seq_hdr->pri;
-  nclx.transfer_characteristics = (heif_transfer_characteristics) frame.seq_hdr->trc;
-  nclx.matrix_coefficients = (heif_matrix_coefficients) frame.seq_hdr->mtrx;
-  nclx.full_range_flag = (frame.seq_hdr->color_range != 0);
-  heif_image_set_nclx_color_profile(heif_img, &nclx);
-
-
-
-  // --- transfer data from aom_image_t to HeifPixelImage
-
-  heif_channel channel2plane[3] = {
-      heif_channel_Y,
-      heif_channel_Cb,
-      heif_channel_Cr
-  };
-
-
-  // --- copy image data
-
-  for (int c = 0; c < 3; c++) {
-    if (chroma == heif_chroma_monochrome && c > 0) {
-      break;
-    }
-
-    int bpp = frame.p.bpc;
-
-    const uint8_t* data = (uint8_t*) frame.data[c];
-    int stride = (int) frame.stride[c > 0 ? 1 : 0];
-
-    int w, h;
-    heif::get_subsampled_size(frame.p.w, frame.p.h,
-                              channel2plane[c], chroma, &w, &h);
-
-    err = heif_image_add_plane(heif_img, channel2plane[c], w, h, bpp);
-    if (err.code != heif_error_Ok) {
-      heif_image_release(heif_img);
-      return err;
-    }
-
-    int dst_stride;
-    uint8_t* dst_mem = heif_image_get_plane(heif_img, channel2plane[c], &dst_stride);
-
-    int bytes_per_pixel = (bpp + 7) / 8;
-
-    for (int y = 0; y < h; y++) {
-      memcpy(dst_mem + y * dst_stride, data + y * stride, w * bytes_per_pixel);
-    }
-  }
-
-  dav1d_picture_unref(&frame);
-
-  *out_img = heif_img;
-
-
-  err = {heif_error_Ok, heif_suberror_Unspecified, kSuccess};
-  return err;
-}
-
-
-static const struct heif_decoder_plugin decoder_dav1d
-    {
-        1,
-        dav1d_plugin_name,
-        dav1d_init_plugin,
-        dav1d_deinit_plugin,
-        dav1d_does_support_format,
-        dav1d_new_decoder,
-        dav1d_free_decoder,
-        dav1d_push_data,
-        dav1d_decode_image
-    };
-
-
-const struct heif_decoder_plugin* get_decoder_plugin_dav1d()
-{
-  return &decoder_dav1d;
-}
diff --git a/libheif/heif_decoder_libde265.cc b/libheif/heif_decoder_libde265.cc
deleted file mode 100644
index ad76df1cd4..0000000000
--- a/libheif/heif_decoder_libde265.cc
+++ /dev/null
@@ -1,387 +0,0 @@
-/*
- * HEIF codec.
- * Copyright (c) 2017 struktur AG, Dirk Farin <farin@struktur.de>
- *
- * This file is part of libheif.
- *
- * libheif is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as
- * published by the Free Software Foundation, either version 3 of
- * the License, or (at your option) any later version.
- *
- * libheif is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "heif.h"
-#include "heif_plugin.h"
-#include "heif_colorconversion.h"
-#include "heif_api_structs.h"
-
-#if defined(HAVE_CONFIG_H)
-#include "config.h"
-#endif
-
-#include <memory>
-#include <cstring>
-
-#include <libde265/de265.h>
-
-using namespace heif;
-
-
-struct libde265_decoder
-{
-  de265_decoder_context* ctx;
-};
-
-static const char kEmptyString[] = "";
-
-static const int LIBDE265_PLUGIN_PRIORITY = 100;
-
-#define MAX_PLUGIN_NAME_LENGTH 80
-
-static char plugin_name[MAX_PLUGIN_NAME_LENGTH];
-
-
-static const char* libde265_plugin_name()
-{
-  strcpy(plugin_name, "libde265 HEVC decoder");
-
-  const char* libde265_version = de265_get_version();
-
-  if (strlen(libde265_version) + 10 < MAX_PLUGIN_NAME_LENGTH) {
-    strcat(plugin_name, ", version ");
-    strcat(plugin_name, libde265_version);
-  }
-
-  return plugin_name;
-}
-
-
-static void libde265_init_plugin()
-{
-  de265_init();
-}
-
-
-static void libde265_deinit_plugin()
-{
-  de265_free();
-}
-
-
-static int libde265_does_support_format(enum heif_compression_format format)
-{
-  if (format == heif_compression_HEVC) {
-    return LIBDE265_PLUGIN_PRIORITY;
-  }
-  else {
-    return 0;
-  }
-}
-
-
-static struct heif_error convert_libde265_image_to_heif_image(struct libde265_decoder* decoder,
-                                                              const struct de265_image* de265img,
-                                                              struct heif_image** image)
-{
-  bool is_mono = (de265_get_chroma_format(de265img) == de265_chroma_mono);
-
-  std::shared_ptr<HeifPixelImage> yuv_img = std::make_shared<HeifPixelImage>();
-  yuv_img->create(de265_get_image_width(de265img, 0),
-                  de265_get_image_height(de265img, 0),
-                  is_mono ? heif_colorspace_monochrome : heif_colorspace_YCbCr,
-                  (heif_chroma) de265_get_chroma_format(de265img));
-
-  // --- transfer data from de265_image to HeifPixelImage
-
-  heif_channel channel2plane[3] = {
-      heif_channel_Y,
-      heif_channel_Cb,
-      heif_channel_Cr
-  };
-
-
-  int bpp = de265_get_bits_per_pixel(de265img, 0);
-
-  int nPlanes = (is_mono ? 1 : 3);
-
-  for (int c = 0; c < nPlanes; c++) {
-    if (de265_get_bits_per_pixel(de265img, c) != bpp) {
-      struct heif_error err = {heif_error_Unsupported_feature,
-                               heif_suberror_Unsupported_color_conversion,
-                               "Channels with different number of bits per pixel are not supported"};
-      return err;
-    }
-
-    int stride;
-    const uint8_t* data = de265_get_image_plane(de265img, c, &stride);
-
-    int w = de265_get_image_width(de265img, c);
-    int h = de265_get_image_height(de265img, c);
-    if (w <= 0 || h <= 0) {
-      struct heif_error err = {heif_error_Decoder_plugin_error,
-                               heif_suberror_Invalid_image_size,
-                               kEmptyString};
-      return err;
-    }
-
-    if (!yuv_img->add_plane(channel2plane[c], w, h, bpp)) {
-      struct heif_error err = {heif_error_Memory_allocation_error,
-                               heif_suberror_Unspecified,
-                               "Cannot allocate memory for image plane"};
-      return err;
-    }
-
-    int dst_stride;
-    uint8_t* dst_mem = yuv_img->get_plane(channel2plane[c], &dst_stride);
-
-    int bytes_per_pixel = (bpp + 7) / 8;
-
-    for (int y = 0; y < h; y++) {
-      memcpy(dst_mem + y * dst_stride, data + y * stride, w * bytes_per_pixel);
-    }
-  }
-
-
-  *image = new heif_image;
-  (*image)->image = yuv_img;
-
-  struct heif_error err = {heif_error_Ok, heif_suberror_Unspecified, kSuccess};
-  return err;
-}
-
-
-static struct heif_error libde265_new_decoder(void** dec)
-{
-  struct libde265_decoder* decoder = new libde265_decoder();
-  struct heif_error err = {heif_error_Ok, heif_suberror_Unspecified, kSuccess};
-
-  decoder->ctx = de265_new_decoder();
-#if defined(__EMSCRIPTEN__)
-  // Speed up decoding from JavaScript.
-  de265_set_parameter_bool(decoder->ctx, DE265_DECODER_PARAM_DISABLE_DEBLOCKING, 1);
-  de265_set_parameter_bool(decoder->ctx, DE265_DECODER_PARAM_DISABLE_SAO, 1);
-#else
-  // Worker threads are not supported when running on Emscripten.
-  de265_start_worker_threads(decoder->ctx, 1);
-#endif
-
-  *dec = decoder;
-  return err;
-}
-
-static void libde265_free_decoder(void* decoder_raw)
-{
-  struct libde265_decoder* decoder = (struct libde265_decoder*) decoder_raw;
-
-  de265_error err = de265_free_decoder(decoder->ctx);
-  (void) err;
-
-  delete decoder;
-}
-
-
-#if LIBDE265_NUMERIC_VERSION >= 0x02000000
-
-static struct heif_error libde265_v2_push_data(void* decoder_raw, const void* data, size_t size)
-{
-  struct libde265_decoder* decoder = (struct libde265_decoder*)decoder_raw;
-
-  const uint8_t* cdata = (const uint8_t*)data;
-
-  size_t ptr=0;
-  while (ptr < size) {
-    if (4 > size - ptr) {
-      struct heif_error err = { heif_error_Decoder_plugin_error,
-                                heif_suberror_End_of_data,
-                                kEmptyString };
-      return err;
-    }
-
-    // TODO: the size of the NAL unit length variable is defined in the hvcC header.
-    // We should not assume that it is always 4 bytes.
-    uint32_t nal_size = (cdata[ptr]<<24) | (cdata[ptr+1]<<16) | (cdata[ptr+2]<<8) | (cdata[ptr+3]);
-    ptr+=4;
-
-    if (nal_size > size - ptr) {
-      //sstr << "NAL size (" << size32 << ") exceeds available data in file ("
-      //<< data_bytes_left_to_read << ")";
-
-      struct heif_error err = { heif_error_Decoder_plugin_error,
-                                heif_suberror_End_of_data,
-                                kEmptyString };
-      return err;
-    }
-
-    de265_push_NAL(decoder->ctx, cdata+ptr, nal_size, 0, nullptr);
-    ptr += nal_size;
-  }
-
-
-  struct heif_error err = { heif_error_Ok, heif_suberror_Unspecified, kSuccess };
-  return err;
-}
-
-
-static struct heif_error libde265_v2_decode_image(void* decoder_raw,
-                                                  struct heif_image** out_img)
-{
-  struct libde265_decoder* decoder = (struct libde265_decoder*)decoder_raw;
-
-  de265_push_end_of_stream(decoder->ctx);
-
-  int action = de265_get_action(decoder->ctx, 1);
-
-  // TODO: read NCLX from h265 bitstream
-
-  // TODO(farindk): Set "err" if no image was decoded.
-  if (action==de265_action_get_image) {
-    const de265_image* img = de265_get_next_picture(decoder->ctx);
-    if (img) {
-      struct heif_error err = convert_libde265_image_to_heif_image(decoder, img,
-                                                                   out_img);
-      de265_release_picture(img);
-
-      return err;
-    }
-  }
-
-  struct heif_error err = { heif_error_Decoder_plugin_error, heif_suberror_Unspecified, kEmptyString };
-  return err;
-}
-
-#else
-
-static struct heif_error libde265_v1_push_data(void* decoder_raw, const void* data, size_t size)
-{
-  struct libde265_decoder* decoder = (struct libde265_decoder*) decoder_raw;
-
-  const uint8_t* cdata = (const uint8_t*) data;
-
-  size_t ptr = 0;
-  while (ptr < size) {
-    if (4 > size - ptr) {
-      struct heif_error err = {heif_error_Decoder_plugin_error,
-                               heif_suberror_End_of_data,
-                               kEmptyString};
-      return err;
-    }
-
-    uint32_t nal_size = (cdata[ptr] << 24) | (cdata[ptr + 1] << 16) | (cdata[ptr + 2] << 8) | (cdata[ptr + 3]);
-    ptr += 4;
-
-    if (nal_size > size - ptr) {
-      struct heif_error err = {heif_error_Decoder_plugin_error,
-                               heif_suberror_End_of_data,
-                               kEmptyString};
-      return err;
-    }
-
-    de265_push_NAL(decoder->ctx, cdata + ptr, nal_size, 0, nullptr);
-    ptr += nal_size;
-  }
-
-  // TODO(farindk): Set "err" if data could not be pushed
-  //de265_push_data(decoder->ctx, data, size, 0, nullptr);
-
-  struct heif_error err = {heif_error_Ok, heif_suberror_Unspecified, kSuccess};
-  return err;
-}
-
-
-static struct heif_error libde265_v1_decode_image(void* decoder_raw,
-                                                  struct heif_image** out_img)
-{
-  struct libde265_decoder* decoder = (struct libde265_decoder*) decoder_raw;
-  struct heif_error err = {heif_error_Ok, heif_suberror_Unspecified, kSuccess};
-
-  de265_flush_data(decoder->ctx);
-
-  // TODO(farindk): Set "err" if no image was decoded.
-  int more;
-  de265_error decode_err;
-  *out_img = nullptr;
-  do {
-    more = 0;
-    decode_err = de265_decode(decoder->ctx, &more);
-    if (decode_err != DE265_OK) {
-      // printf("Error decoding: %s (%d)\n", de265_get_error_text(decode_err), decode_err);
-      break;
-    }
-
-    // TODO: read NCLX from h265 bitstream
-
-    const struct de265_image* image = de265_get_next_picture(decoder->ctx);
-    if (image) {
-      // TODO(farindk): Should we return the first image instead?
-      if (*out_img) {
-        heif_image_release(*out_img);
-      }
-      err = convert_libde265_image_to_heif_image(decoder, image, out_img);
-      if (err.code != heif_error_Ok) {
-        return err;
-      }
-
-      auto nclx = std::make_shared<color_profile_nclx>();
-#if LIBDE265_NUMERIC_VERSION >= 0x01000700
-      nclx->set_full_range_flag(de265_get_image_full_range_flag(image));
-      nclx->set_matrix_coefficients((uint16_t)de265_get_image_matrix_coefficients(image));
-      nclx->set_colour_primaries((uint16_t)de265_get_image_colour_primaries(image));
-      nclx->set_transfer_characteristics((uint16_t)de265_get_image_transfer_characteristics(image));
-#endif
-      (*out_img)->image->set_color_profile_nclx(nclx);
-
-      de265_release_next_picture(decoder->ctx);
-    }
-  } while (more);
-
-  return err;
-}
-
-
-#endif
-
-
-#if LIBDE265_NUMERIC_VERSION >= 0x02000000
-
-static const struct heif_decoder_plugin decoder_libde265
-{
-  1,
-  libde265_plugin_name,
-  libde265_init_plugin,
-  libde265_deinit_plugin,
-  libde265_does_support_format,
-  libde265_new_decoder,
-  libde265_free_decoder,
-  libde265_v2_push_data,
-  libde265_v2_decode_image
-};
-
-#else
-
-static const struct heif_decoder_plugin decoder_libde265
-    {
-        1,
-        libde265_plugin_name,
-        libde265_init_plugin,
-        libde265_deinit_plugin,
-        libde265_does_support_format,
-        libde265_new_decoder,
-        libde265_free_decoder,
-        libde265_v1_push_data,
-        libde265_v1_decode_image
-    };
-
-#endif
-
-const struct heif_decoder_plugin* get_decoder_plugin_libde265()
-{
-  return &decoder_libde265;
-}
diff --git a/libheif/heif_emscripten.h b/libheif/heif_emscripten.h
deleted file mode 100644
index 1e19218337..0000000000
--- a/libheif/heif_emscripten.h
+++ /dev/null
@@ -1,296 +0,0 @@
-#ifndef LIBHEIF_BOX_EMSCRIPTEN_H
-#define LIBHEIF_BOX_EMSCRIPTEN_H
-
-#include <emscripten/bind.h>
-
-#include <memory>
-#include <string>
-#include <sstream>
-#include <utility>
-#include <vector>
-
-#include "heif.h"
-
-static std::string _heif_get_version()
-{
-  return heif_get_version();
-}
-
-static struct heif_error _heif_context_read_from_memory(
-    struct heif_context* context, const std::string& data)
-{
-  return heif_context_read_from_memory(context, data.data(), data.size(), nullptr);
-}
-
-static void strided_copy(void* dest, const void* src, int width, int height,
-                         int stride)
-{
-  if (width == stride) {
-    memcpy(dest, src, width * height);
-  }
-  else {
-    const uint8_t* _src = static_cast<const uint8_t*>(src);
-    uint8_t* _dest = static_cast<uint8_t*>(dest);
-    for (int y = 0; y < height; y++, _dest += width, _src += stride) {
-      memcpy(_dest, _src, stride);
-    }
-  }
-}
-
-static emscripten::val heif_js_context_get_image_handle(
-    struct heif_context* context, heif_item_id id)
-{
-  emscripten::val result = emscripten::val::object();
-  if (!context) {
-    return result;
-  }
-
-  struct heif_image_handle* handle;
-  struct heif_error err = heif_context_get_image_handle(context, id, &handle);
-  if (err.code != heif_error_Ok) {
-    return emscripten::val(err);
-  }
-
-  return emscripten::val(handle);
-}
-
-static emscripten::val heif_js_context_get_list_of_top_level_image_IDs(
-    struct heif_context* context)
-{
-  emscripten::val result = emscripten::val::array();
-  if (!context) {
-    return result;
-  }
-
-  int count = heif_context_get_number_of_top_level_images(context);
-  if (count <= 0) {
-    return result;
-  }
-
-  heif_item_id* ids = (heif_item_id*) malloc(count * sizeof(heif_item_id));
-  if (!ids) {
-    struct heif_error err;
-    err.code = heif_error_Memory_allocation_error;
-    err.subcode = heif_suberror_Security_limit_exceeded;
-    return emscripten::val(err);
-  }
-
-  int received = heif_context_get_list_of_top_level_image_IDs(context, ids, count);
-  if (!received) {
-    free(ids);
-    return result;
-  }
-
-  for (int i = 0; i < received; i++) {
-    result.set(i, ids[i]);
-  }
-  free(ids);
-  return result;
-}
-
-static int round_odd(int v) {
-  return (int) ((v / 2.0) + 0.5);
-}
-
-static emscripten::val heif_js_decode_image(struct heif_image_handle* handle,
-                                            enum heif_colorspace colorspace, enum heif_chroma chroma)
-{
-  emscripten::val result = emscripten::val::object();
-  if (!handle) {
-    return result;
-  }
-
-  struct heif_image* image;
-  struct heif_error err = heif_decode_image(handle, &image, colorspace, chroma, nullptr);
-  if (err.code != heif_error_Ok) {
-    return emscripten::val(err);
-  }
-
-  result.set("is_primary", heif_image_handle_is_primary_image(handle));
-  result.set("thumbnails", heif_image_handle_get_number_of_thumbnails(handle));
-  int width = heif_image_get_width(image, heif_channel_Y);
-  result.set("width", width);
-  int height = heif_image_get_height(image, heif_channel_Y);
-  result.set("height", height);
-  std::string data;
-  result.set("chroma", heif_image_get_chroma_format(image));
-  result.set("colorspace", heif_image_get_colorspace(image));
-  switch (heif_image_get_colorspace(image)) {
-    case heif_colorspace_YCbCr: {
-      int stride_y;
-      const uint8_t* plane_y = heif_image_get_plane_readonly(image,
-                                                             heif_channel_Y, &stride_y);
-      int stride_u;
-      const uint8_t* plane_u = heif_image_get_plane_readonly(image,
-                                                             heif_channel_Cb, &stride_u);
-      int stride_v;
-      const uint8_t* plane_v = heif_image_get_plane_readonly(image,
-                                                             heif_channel_Cr, &stride_v);
-      data.resize((width * height) + (2 * round_odd(width) * round_odd(height)));
-      char* dest = const_cast<char*>(data.data());
-      strided_copy(dest, plane_y, width, height, stride_y);
-      strided_copy(dest + (width * height), plane_u,
-                   round_odd(width), round_odd(height), stride_u);
-      strided_copy(dest + (width * height) + (round_odd(width) * round_odd(height)),
-                   plane_v, round_odd(width), round_odd(height), stride_v);
-    }
-      break;
-    case heif_colorspace_RGB: {
-      assert(heif_image_get_chroma_format(image) ==
-             heif_chroma_interleaved_24bit);
-      int stride_rgb;
-      const uint8_t* plane_rgb = heif_image_get_plane_readonly(image,
-                                                               heif_channel_interleaved, &stride_rgb);
-      data.resize(width * height * 3);
-      char* dest = const_cast<char*>(data.data());
-      strided_copy(dest, plane_rgb, width * 3, height, stride_rgb);
-    }
-      break;
-    case heif_colorspace_monochrome: {
-      assert(heif_image_get_chroma_format(image) ==
-             heif_chroma_monochrome);
-      int stride_grey;
-      const uint8_t* plane_grey = heif_image_get_plane_readonly(image,
-                                                                heif_channel_Y, &stride_grey);
-      data.resize(width * height);
-      char* dest = const_cast<char*>(data.data());
-      strided_copy(dest, plane_grey, width, height, stride_grey);
-    }
-      break;
-    default:
-      // Should never reach here.
-      break;
-  }
-  result.set("data", std::move(data));
-  heif_image_release(image);
-  return result;
-}
-
-#define EXPORT_HEIF_FUNCTION(name) \
-  emscripten::function(#name, &name, emscripten::allow_raw_pointers())
-
-EMSCRIPTEN_BINDINGS(libheif) {
-    emscripten::function("heif_get_version", &_heif_get_version,
-                         emscripten::allow_raw_pointers());
-    EXPORT_HEIF_FUNCTION(heif_get_version_number);
-
-    EXPORT_HEIF_FUNCTION(heif_context_alloc);
-    EXPORT_HEIF_FUNCTION(heif_context_free);
-    emscripten::function("heif_context_read_from_memory",
-    &_heif_context_read_from_memory, emscripten::allow_raw_pointers());
-    EXPORT_HEIF_FUNCTION(heif_context_get_number_of_top_level_images);
-    emscripten::function("heif_js_context_get_list_of_top_level_image_IDs",
-    &heif_js_context_get_list_of_top_level_image_IDs, emscripten::allow_raw_pointers());
-    emscripten::function("heif_js_context_get_image_handle",
-    &heif_js_context_get_image_handle, emscripten::allow_raw_pointers());
-    emscripten::function("heif_js_decode_image",
-    &heif_js_decode_image, emscripten::allow_raw_pointers());
-    EXPORT_HEIF_FUNCTION(heif_image_handle_release);
-
-    emscripten::enum_<heif_error_code>("heif_error_code")
-    .value("heif_error_Ok", heif_error_Ok)
-    .value("heif_error_Input_does_not_exist", heif_error_Input_does_not_exist)
-    .value("heif_error_Invalid_input", heif_error_Invalid_input)
-    .value("heif_error_Unsupported_filetype", heif_error_Unsupported_filetype)
-    .value("heif_error_Unsupported_feature", heif_error_Unsupported_feature)
-    .value("heif_error_Usage_error", heif_error_Usage_error)
-    .value("heif_error_Memory_allocation_error", heif_error_Memory_allocation_error)
-    .value("heif_error_Decoder_plugin_error", heif_error_Decoder_plugin_error)
-    .value("heif_error_Encoder_plugin_error", heif_error_Encoder_plugin_error)
-    .value("heif_error_Encoding_error", heif_error_Encoding_error)
-    .value("heif_error_Color_profile_does_not_exist", heif_error_Color_profile_does_not_exist);
-    emscripten::enum_<heif_suberror_code>("heif_suberror_code")
-    .value("heif_suberror_Unspecified", heif_suberror_Unspecified)
-    .value("heif_suberror_Cannot_write_output_data", heif_suberror_Cannot_write_output_data)
-    .value("heif_suberror_End_of_data", heif_suberror_End_of_data)
-    .value("heif_suberror_Invalid_box_size", heif_suberror_Invalid_box_size)
-    .value("heif_suberror_No_ftyp_box", heif_suberror_No_ftyp_box)
-    .value("heif_suberror_No_idat_box", heif_suberror_No_idat_box)
-    .value("heif_suberror_No_meta_box", heif_suberror_No_meta_box)
-    .value("heif_suberror_No_hdlr_box", heif_suberror_No_hdlr_box)
-    .value("heif_suberror_No_hvcC_box", heif_suberror_No_hvcC_box)
-    .value("heif_suberror_No_pitm_box", heif_suberror_No_pitm_box)
-    .value("heif_suberror_No_ipco_box", heif_suberror_No_ipco_box)
-    .value("heif_suberror_No_ipma_box", heif_suberror_No_ipma_box)
-    .value("heif_suberror_No_iloc_box", heif_suberror_No_iloc_box)
-    .value("heif_suberror_No_iinf_box", heif_suberror_No_iinf_box)
-    .value("heif_suberror_No_iprp_box", heif_suberror_No_iprp_box)
-    .value("heif_suberror_No_iref_box", heif_suberror_No_iref_box)
-    .value("heif_suberror_No_pict_handler", heif_suberror_No_pict_handler)
-    .value("heif_suberror_Ipma_box_references_nonexisting_property", heif_suberror_Ipma_box_references_nonexisting_property)
-    .value("heif_suberror_No_properties_assigned_to_item", heif_suberror_No_properties_assigned_to_item)
-    .value("heif_suberror_No_item_data", heif_suberror_No_item_data)
-    .value("heif_suberror_Invalid_grid_data", heif_suberror_Invalid_grid_data)
-    .value("heif_suberror_Missing_grid_images", heif_suberror_Missing_grid_images)
-    .value("heif_suberror_No_av1C_box", heif_suberror_No_av1C_box)
-    .value("heif_suberror_Invalid_clean_aperture", heif_suberror_Invalid_clean_aperture)
-    .value("heif_suberror_Invalid_overlay_data", heif_suberror_Invalid_overlay_data)
-    .value("heif_suberror_Overlay_image_outside_of_canvas", heif_suberror_Overlay_image_outside_of_canvas)
-    .value("heif_suberror_Auxiliary_image_type_unspecified", heif_suberror_Auxiliary_image_type_unspecified)
-    .value("heif_suberror_No_or_invalid_primary_item", heif_suberror_No_or_invalid_primary_item)
-    .value("heif_suberror_No_infe_box", heif_suberror_No_infe_box)
-    .value("heif_suberror_Security_limit_exceeded", heif_suberror_Security_limit_exceeded)
-    .value("heif_suberror_Unknown_color_profile_type", heif_suberror_Unknown_color_profile_type)
-    .value("heif_suberror_Wrong_tile_image_chroma_format", heif_suberror_Wrong_tile_image_chroma_format)
-    .value("heif_suberror_Invalid_fractional_number", heif_suberror_Invalid_fractional_number)
-    .value("heif_suberror_Invalid_image_size", heif_suberror_Invalid_image_size)
-    .value("heif_suberror_Nonexisting_item_referenced", heif_suberror_Nonexisting_item_referenced)
-    .value("heif_suberror_Null_pointer_argument", heif_suberror_Null_pointer_argument)
-    .value("heif_suberror_Nonexisting_image_channel_referenced", heif_suberror_Nonexisting_image_channel_referenced)
-    .value("heif_suberror_Unsupported_plugin_version", heif_suberror_Unsupported_plugin_version)
-    .value("heif_suberror_Unsupported_writer_version", heif_suberror_Unsupported_writer_version)
-    .value("heif_suberror_Unsupported_parameter", heif_suberror_Unsupported_parameter)
-    .value("heif_suberror_Invalid_parameter_value", heif_suberror_Invalid_parameter_value)
-    .value("heif_suberror_Invalid_pixi_box", heif_suberror_Invalid_pixi_box)
-    .value("heif_suberror_Unsupported_codec", heif_suberror_Unsupported_codec)
-    .value("heif_suberror_Unsupported_image_type", heif_suberror_Unsupported_image_type)
-    .value("heif_suberror_Unsupported_data_version", heif_suberror_Unsupported_data_version)
-    .value("heif_suberror_Unsupported_color_conversion", heif_suberror_Unsupported_color_conversion)
-    .value("heif_suberror_Unsupported_item_construction_method", heif_suberror_Unsupported_item_construction_method)
-    .value("heif_suberror_Unsupported_bit_depth", heif_suberror_Unsupported_bit_depth)
-    .value("heif_suberror_Wrong_tile_image_pixel_depth", heif_suberror_Wrong_tile_image_pixel_depth);
-    emscripten::enum_<heif_compression_format>("heif_compression_format")
-    .value("heif_compression_undefined", heif_compression_undefined)
-    .value("heif_compression_HEVC", heif_compression_HEVC)
-    .value("heif_compression_AVC", heif_compression_AVC)
-    .value("heif_compression_JPEG", heif_compression_JPEG)
-    .value("heif_compression_AV1", heif_compression_AV1);
-    emscripten::enum_<heif_chroma>("heif_chroma")
-    .value("heif_chroma_undefined", heif_chroma_undefined)
-    .value("heif_chroma_monochrome", heif_chroma_monochrome)
-    .value("heif_chroma_420", heif_chroma_420)
-    .value("heif_chroma_422", heif_chroma_422)
-    .value("heif_chroma_444", heif_chroma_444)
-    .value("heif_chroma_interleaved_RGB", heif_chroma_interleaved_RGB)
-    .value("heif_chroma_interleaved_RGBA", heif_chroma_interleaved_RGBA)
-    .value("heif_chroma_interleaved_RRGGBB_BE", heif_chroma_interleaved_RRGGBB_BE)
-    .value("heif_chroma_interleaved_RRGGBBAA_BE", heif_chroma_interleaved_RRGGBBAA_BE)
-    .value("heif_chroma_interleaved_RRGGBB_LE", heif_chroma_interleaved_RRGGBB_LE)
-    .value("heif_chroma_interleaved_RRGGBBAA_LE", heif_chroma_interleaved_RRGGBBAA_LE)
-    // Aliases
-    .value("heif_chroma_interleaved_24bit", heif_chroma_interleaved_24bit)
-    .value("heif_chroma_interleaved_32bit", heif_chroma_interleaved_32bit);
-    emscripten::enum_<heif_colorspace>("heif_colorspace")
-    .value("heif_colorspace_undefined", heif_colorspace_undefined)
-    .value("heif_colorspace_YCbCr", heif_colorspace_YCbCr)
-    .value("heif_colorspace_RGB", heif_colorspace_RGB)
-    .value("heif_colorspace_monochrome", heif_colorspace_monochrome);
-    emscripten::enum_<heif_channel>("heif_channel")
-    .value("heif_channel_Y", heif_channel_Y)
-    .value("heif_channel_Cr", heif_channel_Cr)
-    .value("heif_channel_Cb", heif_channel_Cb)
-    .value("heif_channel_R", heif_channel_R)
-    .value("heif_channel_G", heif_channel_G)
-    .value("heif_channel_B", heif_channel_B)
-    .value("heif_channel_Alpha", heif_channel_Alpha)
-    .value("heif_channel_interleaved", heif_channel_interleaved);
-
-    emscripten::class_<heif_context>("heif_context");
-    emscripten::class_<heif_image_handle>("heif_image_handle");
-    emscripten::class_<heif_image>("heif_image");
-    emscripten::value_object<heif_error>("heif_error")
-    .field("code", &heif_error::code)
-    .field("subcode", &heif_error::subcode);
-}
-
-#endif  // LIBHEIF_BOX_EMSCRIPTEN_H
diff --git a/libheif/heif_encoder_aom.cc b/libheif/heif_encoder_aom.cc
deleted file mode 100644
index 5ac4212587..0000000000
--- a/libheif/heif_encoder_aom.cc
+++ /dev/null
@@ -1,926 +0,0 @@
-/*
- * HEIF codec.
- * Copyright (c) 2017 struktur AG, Dirk Farin <farin@struktur.de>
- *
- * This file is part of libheif.
- *
- * libheif is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as
- * published by the Free Software Foundation, either version 3 of
- * the License, or (at your option) any later version.
- *
- * libheif is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "heif.h"
-#include "heif_plugin.h"
-#include "heif_avif.h"
-#include "heif_api_structs.h"
-
-#if defined(HAVE_CONFIG_H)
-#include "config.h"
-#endif
-
-#include <algorithm>
-#include <cstring>
-#include <cassert>
-#include <vector>
-
-#include <aom/aom_encoder.h>
-#include <aom/aomcx.h>
-
-
-struct encoder_struct_aom
-{
-  // --- parameters
-
-  bool realtime_mode;
-  int cpu_used;  // = parameter 'speed'. I guess this is a better name than 'cpu_used'.
-
-  int quality;
-  int min_q;
-  int max_q;
-  int threads;
-  bool lossless;
-
-  aom_tune_metric tune;
-
-  heif_chroma chroma = heif_chroma_420;
-
-  // --- output
-
-  std::vector<uint8_t> compressedData;
-  bool data_read = false;
-};
-
-static const char* kError_out_of_memory = "Out of memory";
-static const char* kError_encode_frame = "Failed to encode frame";
-
-static const char* kParam_min_q = "min-q";
-static const char* kParam_max_q = "max-q";
-static const char* kParam_threads = "threads";
-static const char* kParam_realtime = "realtime";
-static const char* kParam_speed = "speed";
-
-static const char* kParam_chroma = "chroma";
-static const char* const kParam_chroma_valid_values[] = {
-    "420", "422", "444", nullptr
-};
-
-static const char* kParam_tune = "tune";
-static const char* const kParam_tune_valid_values[] = {
-    "psnr", "ssim", nullptr
-};
-
-static const int AOM_PLUGIN_PRIORITY = 40;
-
-#define MAX_PLUGIN_NAME_LENGTH 80
-
-static char plugin_name[MAX_PLUGIN_NAME_LENGTH];
-
-
-static void aom_set_default_parameters(void* encoder);
-
-
-static const char* aom_plugin_name()
-{
-  if (strlen(aom_codec_iface_name(aom_codec_av1_cx())) < MAX_PLUGIN_NAME_LENGTH) {
-    strcpy(plugin_name, aom_codec_iface_name(aom_codec_av1_cx()));
-  }
-  else {
-    strcpy(plugin_name, "AOMedia AV1 encoder");
-  }
-
-  return plugin_name;
-}
-
-
-#define MAX_NPARAMETERS 10
-
-static struct heif_encoder_parameter aom_encoder_params[MAX_NPARAMETERS];
-static const struct heif_encoder_parameter* aom_encoder_parameter_ptrs[MAX_NPARAMETERS + 1];
-
-static void aom_init_parameters()
-{
-  struct heif_encoder_parameter* p = aom_encoder_params;
-  const struct heif_encoder_parameter** d = aom_encoder_parameter_ptrs;
-  int i = 0;
-
-  assert(i < MAX_NPARAMETERS);
-  p->version = 2;
-  p->name = kParam_realtime;
-  p->type = heif_encoder_parameter_type_boolean;
-  p->boolean.default_value = false;
-  p->has_default = true;
-  d[i++] = p++;
-
-  assert(i < MAX_NPARAMETERS);
-  p->version = 2;
-  p->name = kParam_speed;
-  p->type = heif_encoder_parameter_type_integer;
-  p->integer.default_value = 5;
-  p->has_default = true;
-  p->integer.have_minimum_maximum = true;
-  p->integer.minimum = 0;
-
-  if (aom_codec_version_major() >= 3) {
-    p->integer.maximum = 9;
-  }
-  else {
-    p->integer.maximum = 8;
-  }
-  p->integer.valid_values = NULL;
-  p->integer.num_valid_values = 0;
-  d[i++] = p++;
-
-  assert(i < MAX_NPARAMETERS);
-  p->version = 2;
-  p->name = kParam_threads;
-  p->type = heif_encoder_parameter_type_integer;
-  p->integer.default_value = 4;
-  p->has_default = true;
-  p->integer.have_minimum_maximum = true;
-  p->integer.minimum = 1;
-  p->integer.maximum = 16;
-  p->integer.valid_values = NULL;
-  p->integer.num_valid_values = 0;
-  d[i++] = p++;
-
-  assert(i < MAX_NPARAMETERS);
-  p->version = 2;
-  p->name = heif_encoder_parameter_name_quality;
-  p->type = heif_encoder_parameter_type_integer;
-  p->integer.default_value = 50;
-  p->has_default = true;
-  p->integer.have_minimum_maximum = true;
-  p->integer.minimum = 0;
-  p->integer.maximum = 100;
-  p->integer.valid_values = NULL;
-  p->integer.num_valid_values = 0;
-  d[i++] = p++;
-
-  assert(i < MAX_NPARAMETERS);
-  p->version = 2;
-  p->name = heif_encoder_parameter_name_lossless;
-  p->type = heif_encoder_parameter_type_boolean;
-  p->boolean.default_value = false;
-  p->has_default = true;
-  d[i++] = p++;
-
-  assert(i < MAX_NPARAMETERS);
-  p->version = 2;
-  p->name = kParam_chroma;
-  p->type = heif_encoder_parameter_type_string;
-  p->string.default_value = "420";
-  p->has_default = true;
-  p->string.valid_values = kParam_chroma_valid_values;
-  d[i++] = p++;
-
-  assert(i < MAX_NPARAMETERS);
-  p->version = 2;
-  p->name = kParam_tune;
-  p->type = heif_encoder_parameter_type_string;
-  p->string.default_value = "ssim";
-  p->has_default = true;
-  p->string.valid_values = kParam_tune_valid_values;
-  d[i++] = p++;
-
-  assert(i < MAX_NPARAMETERS);
-  p->version = 2;
-  p->name = kParam_min_q;
-  p->type = heif_encoder_parameter_type_integer;
-  p->integer.default_value = 1;
-  p->has_default = true;
-  p->integer.have_minimum_maximum = true;
-  p->integer.minimum = 1;
-  p->integer.maximum = 62;
-  p->integer.valid_values = NULL;
-  p->integer.num_valid_values = 0;
-  d[i++] = p++;
-
-  assert(i < MAX_NPARAMETERS);
-  p->version = 2;
-  p->name = kParam_max_q;
-  p->type = heif_encoder_parameter_type_integer;
-  p->integer.default_value = 63;
-  p->has_default = true;
-  p->integer.have_minimum_maximum = true;
-  p->integer.minimum = 0;
-  p->integer.maximum = 63;
-  p->integer.valid_values = NULL;
-  p->integer.num_valid_values = 0;
-  d[i++] = p++;
-
-  d[i++] = nullptr;
-}
-
-
-const struct heif_encoder_parameter** aom_list_parameters(void* encoder)
-{
-  return aom_encoder_parameter_ptrs;
-}
-
-static void aom_init_plugin()
-{
-  aom_init_parameters();
-}
-
-
-static void aom_cleanup_plugin()
-{
-}
-
-struct heif_error aom_new_encoder(void** enc)
-{
-  struct encoder_struct_aom* encoder = new encoder_struct_aom();
-  struct heif_error err = heif_error_ok;
-
-  *enc = encoder;
-
-  // set default parameters
-
-  aom_set_default_parameters(encoder);
-
-  return err;
-}
-
-void aom_free_encoder(void* encoder_raw)
-{
-  struct encoder_struct_aom* encoder = (struct encoder_struct_aom*) encoder_raw;
-
-  delete encoder;
-}
-
-
-struct heif_error aom_set_parameter_quality(void* encoder_raw, int quality)
-{
-  struct encoder_struct_aom* encoder = (struct encoder_struct_aom*) encoder_raw;
-
-  if (quality < 0 || quality > 100) {
-    return heif_error_invalid_parameter_value;
-  }
-
-  encoder->quality = quality;
-
-  return heif_error_ok;
-}
-
-struct heif_error aom_get_parameter_quality(void* encoder_raw, int* quality)
-{
-  struct encoder_struct_aom* encoder = (struct encoder_struct_aom*) encoder_raw;
-
-  *quality = encoder->quality;
-
-  return heif_error_ok;
-}
-
-struct heif_error aom_set_parameter_lossless(void* encoder_raw, int enable)
-{
-  struct encoder_struct_aom* encoder = (struct encoder_struct_aom*) encoder_raw;
-
-  if (enable) {
-    encoder->min_q = 0;
-    encoder->max_q = 0;
-  }
-
-  encoder->lossless = enable;
-
-  return heif_error_ok;
-}
-
-struct heif_error aom_get_parameter_lossless(void* encoder_raw, int* enable)
-{
-  struct encoder_struct_aom* encoder = (struct encoder_struct_aom*) encoder_raw;
-
-  *enable = encoder->lossless;
-
-  return heif_error_ok;
-}
-
-struct heif_error aom_set_parameter_logging_level(void* encoder_raw, int logging)
-{
-#if 0
-  struct encoder_struct_x265* encoder = (struct encoder_struct_x265*)encoder_raw;
-
-  if (logging<0 || logging>4) {
-    return heif_error_invalid_parameter_value;
-  }
-
-  encoder->logLevel = logging;
-#endif
-
-  return heif_error_ok;
-}
-
-struct heif_error aom_get_parameter_logging_level(void* encoder_raw, int* loglevel)
-{
-#if 0
-  struct encoder_struct_x265* encoder = (struct encoder_struct_x265*)encoder_raw;
-
-  *loglevel = encoder->logLevel;
-#else
-  *loglevel = 0;
-#endif
-
-  return heif_error_ok;
-}
-
-#define set_value(paramname, paramvar) if (strcmp(name, paramname)==0) { encoder->paramvar = value; return heif_error_ok; }
-#define get_value(paramname, paramvar) if (strcmp(name, paramname)==0) { *value = encoder->paramvar; return heif_error_ok; }
-
-
-struct heif_error aom_set_parameter_integer(void* encoder_raw, const char* name, int value)
-{
-  struct encoder_struct_aom* encoder = (struct encoder_struct_aom*) encoder_raw;
-
-  if (strcmp(name, heif_encoder_parameter_name_quality) == 0) {
-    return aom_set_parameter_quality(encoder, value);
-  }
-  else if (strcmp(name, heif_encoder_parameter_name_lossless) == 0) {
-    return aom_set_parameter_lossless(encoder, value);
-  }
-
-  set_value(kParam_min_q, min_q);
-  set_value(kParam_max_q, max_q);
-  set_value(kParam_threads, threads);
-  set_value(kParam_speed, cpu_used);
-
-  return heif_error_unsupported_parameter;
-}
-
-struct heif_error aom_get_parameter_integer(void* encoder_raw, const char* name, int* value)
-{
-  struct encoder_struct_aom* encoder = (struct encoder_struct_aom*) encoder_raw;
-
-  if (strcmp(name, heif_encoder_parameter_name_quality) == 0) {
-    return aom_get_parameter_quality(encoder, value);
-  }
-  else if (strcmp(name, heif_encoder_parameter_name_lossless) == 0) {
-    return aom_get_parameter_lossless(encoder, value);
-  }
-
-  get_value(kParam_min_q, min_q);
-  get_value(kParam_max_q, max_q);
-  get_value(kParam_threads, threads);
-  get_value(kParam_speed, cpu_used);
-
-  return heif_error_unsupported_parameter;
-}
-
-
-struct heif_error aom_set_parameter_boolean(void* encoder_raw, const char* name, int value)
-{
-  struct encoder_struct_aom* encoder = (struct encoder_struct_aom*) encoder_raw;
-
-  if (strcmp(name, heif_encoder_parameter_name_lossless) == 0) {
-    return aom_set_parameter_lossless(encoder, value);
-  }
-
-  set_value(kParam_realtime, realtime_mode);
-
-  return heif_error_unsupported_parameter;
-}
-
-struct heif_error aom_get_parameter_boolean(void* encoder_raw, const char* name, int* value)
-{
-  struct encoder_struct_aom* encoder = (struct encoder_struct_aom*) encoder_raw;
-
-  if (strcmp(name, heif_encoder_parameter_name_lossless) == 0) {
-    return aom_get_parameter_lossless(encoder, value);
-  }
-
-  get_value(kParam_realtime, realtime_mode);
-
-  return heif_error_unsupported_parameter;
-}
-
-
-struct heif_error aom_set_parameter_string(void* encoder_raw, const char* name, const char* value)
-{
-  struct encoder_struct_aom* encoder = (struct encoder_struct_aom*) encoder_raw;
-
-  if (strcmp(name, kParam_chroma) == 0) {
-    if (strcmp(value, "420") == 0) {
-      encoder->chroma = heif_chroma_420;
-      return heif_error_ok;
-    }
-    else if (strcmp(value, "422") == 0) {
-      encoder->chroma = heif_chroma_422;
-      return heif_error_ok;
-    }
-    else if (strcmp(value, "444") == 0) {
-      encoder->chroma = heif_chroma_444;
-      return heif_error_ok;
-    }
-    else {
-      return heif_error_invalid_parameter_value;
-    }
-  }
-
-  if (strcmp(name, kParam_tune) == 0) {
-    if (strcmp(value, "psnr") == 0) {
-      encoder->tune = AOM_TUNE_PSNR;
-      return heif_error_ok;
-    }
-    else if (strcmp(value, "ssim") == 0) {
-      encoder->tune = AOM_TUNE_SSIM;
-      return heif_error_ok;
-    }
-    else {
-      return heif_error_invalid_parameter_value;
-    }
-  }
-
-  return heif_error_unsupported_parameter;
-}
-
-
-static void save_strcpy(char* dst, int dst_size, const char* src)
-{
-  strncpy(dst, src, dst_size - 1);
-  dst[dst_size - 1] = 0;
-}
-
-
-struct heif_error aom_get_parameter_string(void* encoder_raw, const char* name,
-                                           char* value, int value_size)
-{
-  struct encoder_struct_aom* encoder = (struct encoder_struct_aom*) encoder_raw;
-
-  if (strcmp(name, kParam_chroma) == 0) {
-    switch (encoder->chroma) {
-      case heif_chroma_420:
-        save_strcpy(value, value_size, "420");
-        break;
-      case heif_chroma_422:
-        save_strcpy(value, value_size, "422");
-        break;
-      case heif_chroma_444:
-        save_strcpy(value, value_size, "444");
-        break;
-      default:
-        assert(false);
-        return heif_error_invalid_parameter_value;
-    }
-  }
-  else if (strcmp(name, kParam_tune) == 0) {
-    switch (encoder->tune) {
-      case AOM_TUNE_PSNR:
-        save_strcpy(value, value_size, "psnr");
-        break;
-      case AOM_TUNE_SSIM:
-        save_strcpy(value, value_size, "ssim");
-        break;
-      default:
-        assert(false);
-        return heif_error_invalid_parameter_value;
-    }
-  }
-
-  return heif_error_unsupported_parameter;
-}
-
-
-static void aom_set_default_parameters(void* encoder)
-{
-  for (const struct heif_encoder_parameter** p = aom_encoder_parameter_ptrs; *p; p++) {
-    const struct heif_encoder_parameter* param = *p;
-
-    if (param->has_default) {
-      switch (param->type) {
-        case heif_encoder_parameter_type_integer:
-          aom_set_parameter_integer(encoder, param->name, param->integer.default_value);
-          break;
-        case heif_encoder_parameter_type_boolean:
-          aom_set_parameter_boolean(encoder, param->name, param->boolean.default_value);
-          break;
-        case heif_encoder_parameter_type_string:
-          aom_set_parameter_string(encoder, param->name, param->string.default_value);
-          break;
-      }
-    }
-  }
-}
-
-
-void aom_query_input_colorspace(heif_colorspace* colorspace, heif_chroma* chroma)
-{
-  *colorspace = heif_colorspace_YCbCr;
-  *chroma = heif_chroma_420;
-}
-
-
-void aom_query_input_colorspace2(void* encoder_raw, heif_colorspace* colorspace, heif_chroma* chroma)
-{
-  struct encoder_struct_aom* encoder = (struct encoder_struct_aom*) encoder_raw;
-
-  if (*colorspace == heif_colorspace_monochrome) {
-    // keep the monochrome colorspace
-  }
-  else {
-    *colorspace = heif_colorspace_YCbCr;
-    *chroma = encoder->chroma;
-  }
-}
-
-
-void aom_query_encoded_size(void* encoder, uint32_t input_width, uint32_t input_height,
-                            uint32_t* encoded_width, uint32_t* encoded_height)
-{
-  *encoded_width = input_width;
-  *encoded_height = input_height;
-}
-
-
-static heif_error encode_frame(aom_codec_ctx_t* codec, aom_image_t* img)
-{
-  //aom_codec_iter_t iter = NULL;
-  int frame_index = 0; // only encoding a single frame
-  int flags = 0; // no flags
-
-  //const aom_codec_cx_pkt_t *pkt = NULL;
-  const aom_codec_err_t res = aom_codec_encode(codec, img, frame_index, 1, flags);
-  if (res != AOM_CODEC_OK) {
-    struct heif_error err = {
-        heif_error_Encoder_plugin_error,
-        heif_suberror_Unspecified,
-        kError_encode_frame
-    };
-    return err;
-  }
-
-  return heif_error_ok;
-}
-
-
-struct heif_error aom_encode_image(void* encoder_raw, const struct heif_image* image,
-                                   heif_image_input_class input_class)
-{
-  struct encoder_struct_aom* encoder = (struct encoder_struct_aom*) encoder_raw;
-
-  struct heif_error err;
-
-  bool success = image->image->extend_padding_to_size(image->image->get_width(),
-                                                      image->image->get_height());
-  if (!success) {
-    err = {heif_error_Memory_allocation_error,
-           heif_suberror_Unspecified,
-           kError_out_of_memory};
-    return err;
-  }
-
-
-  const int source_width = heif_image_get_width(image, heif_channel_Y);
-  const int source_height = heif_image_get_height(image, heif_channel_Y);
-
-  const heif_chroma chroma = heif_image_get_chroma_format(image);
-
-  int bpp_y = heif_image_get_bits_per_pixel_range(image, heif_channel_Y);
-
-  // --- copy libheif image to aom image
-
-  aom_image_t input_image;
-
-  aom_img_fmt_t img_format = AOM_IMG_FMT_NONE;
-
-  int chroma_height = 0;
-  int chroma_sample_position = AOM_CSP_UNKNOWN;
-
-  switch (chroma) {
-    case heif_chroma_420:
-    case heif_chroma_monochrome:
-      img_format = AOM_IMG_FMT_I420;
-      chroma_height = (source_height+1)/2;
-      chroma_sample_position = AOM_CSP_UNKNOWN; // TODO: change this to CSP_CENTER in the future (https://github.com/AOMediaCodec/av1-avif/issues/88)
-      break;
-    case heif_chroma_422:
-      img_format = AOM_IMG_FMT_I422;
-      chroma_height = (source_height+1)/2;
-      chroma_sample_position = AOM_CSP_COLOCATED;
-      break;
-    case heif_chroma_444:
-      img_format = AOM_IMG_FMT_I444;
-      chroma_height = source_height;
-      chroma_sample_position = AOM_CSP_COLOCATED;
-      break;
-    default:
-      img_format = AOM_IMG_FMT_NONE;
-      chroma_sample_position = AOM_CSP_UNKNOWN;
-      assert(false);
-      break;
-  }
-
-  if (bpp_y > 8) {
-    img_format = (aom_img_fmt_t) (img_format | AOM_IMG_FMT_HIGHBITDEPTH);
-  }
-
-  if (!aom_img_alloc(&input_image, img_format,
-                     source_width, source_height, 1)) {
-    err = {heif_error_Memory_allocation_error,
-           heif_suberror_Unspecified,
-           "Failed to allocate image"};
-    return err;
-  }
-
-
-  for (int plane = 0; plane < 3; plane++) {
-    unsigned char* buf = input_image.planes[plane];
-    const int stride = input_image.stride[plane];
-
-    if (chroma == heif_chroma_monochrome && plane != 0) {
-      if (bpp_y == 8) {
-        memset(buf, 128, chroma_height * stride);
-      }
-      else {
-        uint16_t* buf16 = (uint16_t*) buf;
-        uint16_t half_range = (uint16_t) (1 << (bpp_y - 1));
-        for (int i = 0; i < chroma_height * stride / 2; i++) {
-          buf16[i] = half_range;
-        }
-      }
-
-      continue;
-    }
-
-    /*
-    const int w = aom_img_plane_width(img, plane) *
-                  ((img->fmt & AOM_IMG_FMT_HIGHBITDEPTH) ? 2 : 1);
-    const int h = aom_img_plane_height(img, plane);
-    */
-
-    int in_stride = 0;
-    const uint8_t* in_p = heif_image_get_plane_readonly(image, (heif_channel) plane, &in_stride);
-
-    int w = source_width;
-    int h = source_height;
-
-    if (plane != 0) {
-      if (chroma != heif_chroma_444) { w = (w + 1) / 2; }
-      if (chroma == heif_chroma_420) { h = (h + 1) / 2; }
-
-      assert(w == heif_image_get_width(image, (heif_channel) plane));
-      assert(h == heif_image_get_height(image, (heif_channel) plane));
-    }
-
-    if (bpp_y > 8) {
-      w *= 2;
-    }
-
-    for (int y = 0; y < h; y++) {
-      memcpy(buf, &in_p[y * in_stride], w);
-      buf += stride;
-    }
-  }
-
-
-
-  // --- configure codec
-
-  aom_codec_iface_t* iface;
-  aom_codec_ctx_t codec;
-
-  iface = aom_codec_av1_cx();
-  //encoder->encoder = get_aom_encoder_by_name("av1");
-  if (!iface) {
-    err = {heif_error_Unsupported_feature,
-           heif_suberror_Unsupported_codec,
-           "Unsupported codec: AOMedia Project AV1 Encoder"};
-    return err;
-  }
-
-
-  unsigned int aomUsage = 0;
-#if defined(AOM_USAGE_ALL_INTRA)
-  // aom 3.1.0
-  aomUsage = (encoder->realtime_mode ? AOM_USAGE_REALTIME : AOM_USAGE_ALL_INTRA);
-#elif defined(AOM_USAGE_REALTIME)
-  // aom 2.0
-  aomUsage = (encoder->realtime_mode ? AOM_USAGE_REALTIME : AOM_USAGE_GOOD_QUALITY);
-#endif
-
-  aom_codec_enc_cfg_t cfg;
-  aom_codec_err_t res = aom_codec_enc_config_default(iface, &cfg, aomUsage);
-  if (res) {
-    err = {heif_error_Encoder_plugin_error,
-           heif_suberror_Unspecified,
-           "Failed to get default codec config"};
-    return err;
-  }
-
-  heif::Box_av1C::configuration inout_config;
-  heif::fill_av1C_configuration(&inout_config, image->image);
-
-  cfg.g_w = source_width;
-  cfg.g_h = source_height;
-  // Set the max number of frames to encode to 1. This makes the libaom encoder
-  // set still_picture and reduced_still_picture_header to 1 in the AV1 sequence
-  // header OBU.
-  cfg.g_limit = 1;
-
-  cfg.g_profile = inout_config.seq_profile;
-  cfg.g_bit_depth = (aom_bit_depth_t) bpp_y;
-  cfg.g_input_bit_depth = bpp_y;
-
-  cfg.rc_end_usage = AOM_Q;
-  cfg.rc_min_quantizer = encoder->min_q;
-  cfg.rc_max_quantizer = encoder->max_q;
-  cfg.g_error_resilient = 0;
-  cfg.g_threads = encoder->threads;
-
-  if (chroma == heif_chroma_monochrome) {
-    cfg.monochrome = 1;
-  }
-
-  // --- initialize codec
-
-  aom_codec_flags_t encoder_flags = 0;
-  if (bpp_y > 8) {
-    encoder_flags = (aom_codec_flags_t) (encoder_flags | AOM_CODEC_USE_HIGHBITDEPTH);
-  }
-
-  if (aom_codec_enc_init(&codec, iface, &cfg, encoder_flags)) {
-    err = {heif_error_Encoder_plugin_error,
-           heif_suberror_Unspecified,
-           "Failed to initialize encoder"};
-    return err;
-  }
-
-  aom_codec_control(&codec, AOME_SET_CPUUSED, encoder->cpu_used);
-
-  int cq_level = ((100 - encoder->quality) * 63 + 50) / 100;
-  aom_codec_control(&codec, AOME_SET_CQ_LEVEL, cq_level);
-
-  if (encoder->threads > 1) {
-#if defined(AV1E_SET_ROW_MT)
-    // aom 2.0
-    aom_codec_control(&encoder->codec, AV1E_SET_ROW_MT, 1);
-#endif
-  }
-
-
-  auto nclx = image->image->get_color_profile_nclx();
-
-  // In aom, color_range defaults to limited range (0). Set it to full range (1).
-  aom_codec_control(&codec, AV1E_SET_COLOR_RANGE, nclx ? nclx->get_full_range_flag() : 1);
-  aom_codec_control(&codec, AV1E_SET_CHROMA_SAMPLE_POSITION, chroma_sample_position);
-
-  if (nclx &&
-      (input_class == heif_image_input_class_normal ||
-       input_class == heif_image_input_class_thumbnail)) {
-    aom_codec_control(&codec, AV1E_SET_COLOR_PRIMARIES, nclx->get_colour_primaries());
-    aom_codec_control(&codec, AV1E_SET_MATRIX_COEFFICIENTS, nclx->get_matrix_coefficients());
-    aom_codec_control(&codec, AV1E_SET_TRANSFER_CHARACTERISTICS, nclx->get_transfer_characteristics());
-  }
-
-  aom_codec_control(&codec, AOME_SET_TUNING, encoder->tune);
-
-  if (encoder->lossless) {
-    aom_codec_control(&codec, AV1E_SET_LOSSLESS, 1);
-  }
-
-  // --- encode frame
-
-  err = encode_frame(&codec, &input_image); //, frame_count++, flags, writer);
-  if (err.code != heif_error_Ok) {
-    return err;
-  }
-
-  encoder->compressedData.clear();
-  const aom_codec_cx_pkt_t* pkt = NULL;
-  aom_codec_iter_t iter = NULL; // for extracting the compressed packets
-
-  while ((pkt = aom_codec_get_cx_data(&codec, &iter)) != NULL) {
-
-    if (pkt->kind == AOM_CODEC_CX_FRAME_PKT) {
-      //std::cerr.write((char*)pkt->data.frame.buf, pkt->data.frame.sz);
-
-      //printf("packet of size: %d\n",(int)pkt->data.frame.sz);
-
-
-      // TODO: split the received data into separate OBUs
-      // This allows libheif to easily extract the sequence header for the av1C header
-
-      size_t n = pkt->data.frame.sz;
-      size_t oldSize = encoder->compressedData.size();
-      encoder->compressedData.resize(oldSize + n);
-
-      memcpy(encoder->compressedData.data() + oldSize,
-             pkt->data.frame.buf,
-             n);
-
-      encoder->data_read = false;
-    }
-  }
-
-  int flags = 0;
-  res = aom_codec_encode(&codec, NULL, -1, 0, flags);
-  if (res != AOM_CODEC_OK) {
-    err = {heif_error_Encoder_plugin_error,
-           heif_suberror_Unspecified,
-           kError_encode_frame};
-    return err;
-  }
-
-  iter = NULL;
-
-  while ((pkt = aom_codec_get_cx_data(&codec, &iter)) != NULL) {
-
-    if (pkt->kind == AOM_CODEC_CX_FRAME_PKT) {
-      //std::cerr.write((char*)pkt->data.frame.buf, pkt->data.frame.sz);
-
-      //printf("packet of size: %d\n",(int)pkt->data.frame.sz);
-
-
-      // TODO: split the received data into separate OBUs
-      // This allows libheif to easily extract the sequence header for the av1C header
-
-      size_t n = pkt->data.frame.sz;
-      size_t oldSize = encoder->compressedData.size();
-      encoder->compressedData.resize(oldSize + n);
-
-      memcpy(encoder->compressedData.data() + oldSize,
-             pkt->data.frame.buf,
-             n);
-
-      encoder->data_read = false;
-    }
-  }
-
-
-  // --- clean up
-
-  aom_img_free(&input_image);
-
-  if (aom_codec_destroy(&codec)) {
-    err = {heif_error_Encoder_plugin_error,
-           heif_suberror_Unspecified,
-           "Failed to destroy codec"};
-    return err;
-  }
-
-  return heif_error_ok;
-}
-
-
-struct heif_error aom_get_compressed_data(void* encoder_raw, uint8_t** data, int* size,
-                                          enum heif_encoded_data_type* type)
-{
-  struct encoder_struct_aom* encoder = (struct encoder_struct_aom*) encoder_raw;
-
-  if (encoder->data_read) {
-    *size = 0;
-    *data = nullptr;
-  }
-  else {
-    *size = (int) encoder->compressedData.size();
-    *data = encoder->compressedData.data();
-    encoder->data_read = true;
-  }
-
-  return heif_error_ok;
-}
-
-
-static const struct heif_encoder_plugin encoder_plugin_aom
-    {
-        /* plugin_api_version */ 3,
-        /* compression_format */ heif_compression_AV1,
-        /* id_name */ "aom",
-        /* priority */ AOM_PLUGIN_PRIORITY,
-        /* supports_lossy_compression */ true,
-        /* supports_lossless_compression */ true,
-        /* get_plugin_name */ aom_plugin_name,
-        /* init_plugin */ aom_init_plugin,
-        /* cleanup_plugin */ aom_cleanup_plugin,
-        /* new_encoder */ aom_new_encoder,
-        /* free_encoder */ aom_free_encoder,
-        /* set_parameter_quality */ aom_set_parameter_quality,
-        /* get_parameter_quality */ aom_get_parameter_quality,
-        /* set_parameter_lossless */ aom_set_parameter_lossless,
-        /* get_parameter_lossless */ aom_get_parameter_lossless,
-        /* set_parameter_logging_level */ aom_set_parameter_logging_level,
-        /* get_parameter_logging_level */ aom_get_parameter_logging_level,
-        /* list_parameters */ aom_list_parameters,
-        /* set_parameter_integer */ aom_set_parameter_integer,
-        /* get_parameter_integer */ aom_get_parameter_integer,
-        /* set_parameter_boolean */ aom_set_parameter_boolean,
-        /* get_parameter_boolean */ aom_get_parameter_boolean,
-        /* set_parameter_string */ aom_set_parameter_string,
-        /* get_parameter_string */ aom_get_parameter_string,
-        /* query_input_colorspace */ aom_query_input_colorspace,
-        /* encode_image */ aom_encode_image,
-        /* get_compressed_data */ aom_get_compressed_data,
-        /* query_input_colorspace (v2) */ aom_query_input_colorspace2,
-        /* query_encoded_size (v3) */ aom_query_encoded_size
-    };
-
-const struct heif_encoder_plugin* get_encoder_plugin_aom()
-{
-  return &encoder_plugin_aom;
-}
diff --git a/libheif/heif_file.cc b/libheif/heif_file.cc
deleted file mode 100644
index 483bf2d89a..0000000000
--- a/libheif/heif_file.cc
+++ /dev/null
@@ -1,891 +0,0 @@
-/*
- * HEIF codec.
- * Copyright (c) 2017 struktur AG, Dirk Farin <farin@struktur.de>
- *
- * This file is part of libheif.
- *
- * libheif is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as
- * published by the Free Software Foundation, either version 3 of
- * the License, or (at your option) any later version.
- *
- * libheif is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "heif_file.h"
-
-#include <fstream>
-#include <limits>
-#include <sstream>
-#include <utility>
-#include <cstring>
-#include <cassert>
-
-#ifdef _MSC_VER
-
-#ifndef NOMINMAX
-#define NOMINMAX 1
-#endif
-
-#include <Windows.h>
-#endif
-
-using namespace heif;
-
-// TODO: make this a decoder option
-#define STRICT_PARSING false
-
-
-HeifFile::HeifFile()
-{
-}
-
-
-HeifFile::~HeifFile()
-{
-}
-
-
-std::vector<heif_item_id> HeifFile::get_item_IDs() const
-{
-  std::vector<heif_item_id> IDs;
-
-  for (const auto& infe : m_infe_boxes) {
-    IDs.push_back(infe.second->get_item_ID());
-  }
-
-  return IDs;
-}
-
-
-Error HeifFile::read_from_file(const char* input_filename)
-{
-#ifdef _MSC_VER
-  auto input_stream_istr = std::unique_ptr<std::istream>(new std::ifstream(convert_utf8_path_to_utf16(input_filename).c_str(), std::ios_base::binary));
-#else
-  auto input_stream_istr = std::unique_ptr<std::istream>(new std::ifstream(input_filename, std::ios_base::binary));
-#endif
-  if (!input_stream_istr->good()) {
-    std::stringstream sstr;
-    sstr << "Error opening file: " << strerror(errno) << " (" << errno << ")\n";
-    return Error(heif_error_Input_does_not_exist, heif_suberror_Unspecified, sstr.str());
-  }
-
-  auto input_stream = std::make_shared<StreamReader_istream>(std::move(input_stream_istr));
-  return read(input_stream);
-}
-
-
-Error HeifFile::read_from_memory(const void* data, size_t size, bool copy)
-{
-  auto input_stream = std::make_shared<StreamReader_memory>((const uint8_t*) data, size, copy);
-
-  return read(input_stream);
-}
-
-
-Error HeifFile::read(std::shared_ptr<StreamReader> reader)
-{
-  m_input_stream = reader;
-
-  uint64_t maxSize = std::numeric_limits<int64_t>::max();
-  heif::BitstreamRange range(m_input_stream, maxSize);
-
-  Error error = parse_heif_file(range);
-  return error;
-}
-
-
-void HeifFile::new_empty_file()
-{
-  m_input_stream.reset();
-  m_top_level_boxes.clear();
-
-  m_ftyp_box = std::make_shared<Box_ftyp>();
-  m_hdlr_box = std::make_shared<Box_hdlr>();
-  m_meta_box = std::make_shared<Box_meta>();
-  m_ipco_box = std::make_shared<Box_ipco>();
-  m_ipma_box = std::make_shared<Box_ipma>();
-  m_iloc_box = std::make_shared<Box_iloc>();
-  m_iinf_box = std::make_shared<Box_iinf>();
-  m_iprp_box = std::make_shared<Box_iprp>();
-  m_pitm_box = std::make_shared<Box_pitm>();
-
-  m_meta_box->append_child_box(m_hdlr_box);
-  m_meta_box->append_child_box(m_pitm_box);
-  m_meta_box->append_child_box(m_iloc_box);
-  m_meta_box->append_child_box(m_iinf_box);
-  m_meta_box->append_child_box(m_iprp_box);
-
-  m_iprp_box->append_child_box(m_ipco_box);
-  m_iprp_box->append_child_box(m_ipma_box);
-
-  m_infe_boxes.clear();
-
-  m_top_level_boxes.push_back(m_ftyp_box);
-  m_top_level_boxes.push_back(m_meta_box);
-}
-
-
-void HeifFile::set_brand(heif_compression_format format, bool miaf_compatible)
-{
-  // Note: major brand should be repeated in the compatible brands, according to this:
-  //   ISOBMFF (ISO/IEC 14496-12:2020) § K.4:
-  //   NOTE This document requires that the major brand be repeated in the compatible-brands,
-  //   but this requirement is relaxed in the 'profiles' parameter for compactness.
-  // See https://github.com/strukturag/libheif/issues/478
-
-  switch (format) {
-    case heif_compression_HEVC:
-      m_ftyp_box->set_major_brand(fourcc("heic"));
-      m_ftyp_box->set_minor_version(0);
-      m_ftyp_box->add_compatible_brand(fourcc("mif1"));
-      m_ftyp_box->add_compatible_brand(fourcc("heic"));
-      break;
-
-    case heif_compression_AV1:
-      m_ftyp_box->set_major_brand(fourcc("avif"));
-      m_ftyp_box->set_minor_version(0);
-      m_ftyp_box->add_compatible_brand(fourcc("avif"));
-      m_ftyp_box->add_compatible_brand(fourcc("mif1"));
-      break;
-
-    default:
-      break;
-  }
-
-  if (miaf_compatible) {
-    m_ftyp_box->add_compatible_brand(fourcc("miaf"));
-  }
-}
-
-
-void HeifFile::write(StreamWriter& writer)
-{
-  for (auto& box : m_top_level_boxes) {
-    box->derive_box_version_recursive();
-    box->write(writer);
-  }
-
-  m_iloc_box->write_mdat_after_iloc(writer);
-}
-
-
-std::string HeifFile::debug_dump_boxes() const
-{
-  std::stringstream sstr;
-
-  bool first = true;
-
-  for (const auto& box : m_top_level_boxes) {
-    // dump box content for debugging
-
-    if (first) {
-      first = false;
-    }
-    else {
-      sstr << "\n";
-    }
-
-    heif::Indent indent;
-    sstr << box->dump(indent);
-  }
-
-  return sstr.str();
-}
-
-
-Error HeifFile::parse_heif_file(BitstreamRange& range)
-{
-  // --- read all top-level boxes
-
-  for (;;) {
-    std::shared_ptr<Box> box;
-    Error error = Box::read(range, &box);
-
-    // When an EOF error is returned, this is not really a fatal exception,
-    // but simply the indication that we reached the end of the file.
-    if (error != Error::Ok || range.error() || range.eof()) {
-      break;
-    }
-
-    m_top_level_boxes.push_back(box);
-
-
-    // extract relevant boxes (ftyp, meta)
-
-    if (box->get_short_type() == fourcc("meta")) {
-      m_meta_box = std::dynamic_pointer_cast<Box_meta>(box);
-    }
-
-    if (box->get_short_type() == fourcc("ftyp")) {
-      m_ftyp_box = std::dynamic_pointer_cast<Box_ftyp>(box);
-    }
-  }
-
-
-
-  // --- check whether this is a HEIF file and its structural format
-
-  if (!m_ftyp_box) {
-    return Error(heif_error_Invalid_input,
-                 heif_suberror_No_ftyp_box);
-  }
-
-  if (!m_ftyp_box->has_compatible_brand(fourcc("heic")) &&
-      !m_ftyp_box->has_compatible_brand(fourcc("heix")) &&
-      !m_ftyp_box->has_compatible_brand(fourcc("mif1")) &&
-      !m_ftyp_box->has_compatible_brand(fourcc("avif"))) {
-    std::stringstream sstr;
-    sstr << "File does not include any supported brands.\n";
-
-    return Error(heif_error_Unsupported_filetype,
-                 heif_suberror_Unspecified,
-                 sstr.str());
-  }
-
-  if (!m_meta_box) {
-    return Error(heif_error_Invalid_input,
-                 heif_suberror_No_meta_box);
-  }
-
-
-  m_hdlr_box = std::dynamic_pointer_cast<Box_hdlr>(m_meta_box->get_child_box(fourcc("hdlr")));
-  if (STRICT_PARSING && !m_hdlr_box) {
-    return Error(heif_error_Invalid_input,
-                 heif_suberror_No_hdlr_box);
-  }
-
-  if (m_hdlr_box &&
-      m_hdlr_box->get_handler_type() != fourcc("pict")) {
-    return Error(heif_error_Invalid_input,
-                 heif_suberror_No_pict_handler);
-  }
-
-
-  // --- find mandatory boxes needed for image decoding
-
-  m_pitm_box = std::dynamic_pointer_cast<Box_pitm>(m_meta_box->get_child_box(fourcc("pitm")));
-  if (!m_pitm_box) {
-    return Error(heif_error_Invalid_input,
-                 heif_suberror_No_pitm_box);
-  }
-
-  m_iprp_box = std::dynamic_pointer_cast<Box_iprp>(m_meta_box->get_child_box(fourcc("iprp")));
-  if (!m_iprp_box) {
-    return Error(heif_error_Invalid_input,
-                 heif_suberror_No_iprp_box);
-  }
-
-  m_ipco_box = std::dynamic_pointer_cast<Box_ipco>(m_iprp_box->get_child_box(fourcc("ipco")));
-  if (!m_ipco_box) {
-    return Error(heif_error_Invalid_input,
-                 heif_suberror_No_ipco_box);
-  }
-
-  m_ipma_box = std::dynamic_pointer_cast<Box_ipma>(m_iprp_box->get_child_box(fourcc("ipma")));
-  if (!m_ipma_box) {
-    return Error(heif_error_Invalid_input,
-                 heif_suberror_No_ipma_box);
-  }
-
-  m_iloc_box = std::dynamic_pointer_cast<Box_iloc>(m_meta_box->get_child_box(fourcc("iloc")));
-  if (!m_iloc_box) {
-    return Error(heif_error_Invalid_input,
-                 heif_suberror_No_iloc_box);
-  }
-
-  m_idat_box = std::dynamic_pointer_cast<Box_idat>(m_meta_box->get_child_box(fourcc("idat")));
-
-  m_iref_box = std::dynamic_pointer_cast<Box_iref>(m_meta_box->get_child_box(fourcc("iref")));
-
-  m_iinf_box = std::dynamic_pointer_cast<Box_iinf>(m_meta_box->get_child_box(fourcc("iinf")));
-  if (!m_iinf_box) {
-    return Error(heif_error_Invalid_input,
-                 heif_suberror_No_iinf_box);
-  }
-
-
-
-  // --- build list of images
-
-  std::vector<std::shared_ptr<Box>> infe_boxes = m_iinf_box->get_child_boxes(fourcc("infe"));
-
-  for (auto& box : infe_boxes) {
-    std::shared_ptr<Box_infe> infe_box = std::dynamic_pointer_cast<Box_infe>(box);
-    if (!infe_box) {
-      return Error(heif_error_Invalid_input,
-                   heif_suberror_No_infe_box);
-    }
-
-    m_infe_boxes.insert(std::make_pair(infe_box->get_item_ID(), infe_box));
-  }
-
-  return Error::Ok;
-}
-
-
-bool HeifFile::image_exists(heif_item_id ID) const
-{
-  auto image_iter = m_infe_boxes.find(ID);
-  return image_iter != m_infe_boxes.end();
-}
-
-
-std::shared_ptr<Box_infe> HeifFile::get_infe(heif_item_id ID) const
-{
-  // --- get the image from the list of all images
-
-  auto image_iter = m_infe_boxes.find(ID);
-  if (image_iter == m_infe_boxes.end()) {
-    return nullptr;
-  }
-
-  return image_iter->second;
-}
-
-
-std::string HeifFile::get_item_type(heif_item_id ID) const
-{
-  auto infe_box = get_infe(ID);
-  if (!infe_box) {
-    return "";
-  }
-
-  return infe_box->get_item_type();
-}
-
-
-std::string HeifFile::get_content_type(heif_item_id ID) const
-{
-  auto infe_box = get_infe(ID);
-  if (!infe_box) {
-    return "";
-  }
-
-  return infe_box->get_content_type();
-}
-
-
-Error HeifFile::get_properties(heif_item_id imageID,
-                               std::vector<Box_ipco::Property>& properties) const
-{
-  if (!m_ipco_box) {
-    return Error(heif_error_Invalid_input,
-                 heif_suberror_No_ipco_box);
-  }
-  else if (!m_ipma_box) {
-    return Error(heif_error_Invalid_input,
-                 heif_suberror_No_ipma_box);
-  }
-
-  return m_ipco_box->get_properties_for_item_ID(imageID, m_ipma_box, properties);
-}
-
-
-heif_chroma HeifFile::get_image_chroma_from_configuration(heif_item_id imageID) const
-{
-  // HEVC
-
-  auto box = m_ipco_box->get_property_for_item_ID(imageID, m_ipma_box, fourcc("hvcC"));
-  std::shared_ptr<Box_hvcC> hvcC_box = std::dynamic_pointer_cast<Box_hvcC>(box);
-  if (hvcC_box) {
-    return (heif_chroma) (hvcC_box->get_configuration().chroma_format);
-  }
-
-
-  // AV1
-
-  box = m_ipco_box->get_property_for_item_ID(imageID, m_ipma_box, fourcc("av1C"));
-  std::shared_ptr<Box_av1C> av1C_box = std::dynamic_pointer_cast<Box_av1C>(box);
-  if (av1C_box) {
-    Box_av1C::configuration config = av1C_box->get_configuration();
-    if (config.chroma_subsampling_x == 1 &&
-        config.chroma_subsampling_y == 1) {
-      return heif_chroma_420;
-    }
-    else if (config.chroma_subsampling_x == 1 &&
-             config.chroma_subsampling_y == 0) {
-      return heif_chroma_422;
-    }
-    else if (config.chroma_subsampling_x == 0 &&
-             config.chroma_subsampling_y == 0) {
-      return heif_chroma_444;
-    }
-    else {
-      return heif_chroma_undefined;
-    }
-  }
-
-
-  assert(false);
-  return heif_chroma_undefined;
-}
-
-
-int HeifFile::get_luma_bits_per_pixel_from_configuration(heif_item_id imageID) const
-{
-  std::string image_type = get_item_type(imageID);
-
-  // HEVC
-
-  if (image_type == "hvc1") {
-    auto box = m_ipco_box->get_property_for_item_ID(imageID, m_ipma_box, fourcc("hvcC"));
-    std::shared_ptr<Box_hvcC> hvcC_box = std::dynamic_pointer_cast<Box_hvcC>(box);
-    if (hvcC_box) {
-      return hvcC_box->get_configuration().bit_depth_luma;
-    }
-  }
-
-
-  // AV1
-
-  if (image_type == "av01") {
-    auto box = m_ipco_box->get_property_for_item_ID(imageID, m_ipma_box, fourcc("av1C"));
-    std::shared_ptr<Box_av1C> av1C_box = std::dynamic_pointer_cast<Box_av1C>(box);
-    if (av1C_box) {
-      Box_av1C::configuration config = av1C_box->get_configuration();
-      if (!config.high_bitdepth) {
-        return 8;
-      }
-      else if (config.twelve_bit) {
-        return 12;
-      }
-      else {
-        return 10;
-      }
-    }
-  }
-
-  return -1;
-}
-
-
-int HeifFile::get_chroma_bits_per_pixel_from_configuration(heif_item_id imageID) const
-{
-  std::string image_type = get_item_type(imageID);
-
-  // HEVC
-
-  if (image_type == "hvc1") {
-    auto box = m_ipco_box->get_property_for_item_ID(imageID, m_ipma_box, fourcc("hvcC"));
-    std::shared_ptr<Box_hvcC> hvcC_box = std::dynamic_pointer_cast<Box_hvcC>(box);
-    if (hvcC_box) {
-      return hvcC_box->get_configuration().bit_depth_chroma;
-    }
-  }
-
-  // AV1
-
-  if (image_type == "av01") {
-    auto box = m_ipco_box->get_property_for_item_ID(imageID, m_ipma_box, fourcc("av1C"));
-    std::shared_ptr<Box_av1C> av1C_box = std::dynamic_pointer_cast<Box_av1C>(box);
-    if (av1C_box) {
-      Box_av1C::configuration config = av1C_box->get_configuration();
-      if (!config.high_bitdepth) {
-        return 8;
-      }
-      else if (config.twelve_bit) {
-        return 12;
-      }
-      else {
-        return 10;
-      }
-    }
-  }
-
-  return -1;
-}
-
-
-Error HeifFile::get_compressed_image_data(heif_item_id ID, std::vector<uint8_t>* data) const
-{
-#if ENABLE_PARALLEL_TILE_DECODING
-  std::lock_guard<std::mutex> guard(m_read_mutex);
-#endif
-
-  if (!image_exists(ID)) {
-    return Error(heif_error_Usage_error,
-                 heif_suberror_Nonexisting_item_referenced);
-  }
-
-  auto infe_box = get_infe(ID);
-  if (!infe_box) {
-    return Error(heif_error_Usage_error,
-                 heif_suberror_Nonexisting_item_referenced);
-  }
-
-
-  std::string item_type = infe_box->get_item_type();
-  std::string content_type = infe_box->get_content_type();
-
-  // --- get coded image data pointers
-
-  auto items = m_iloc_box->get_items();
-  const Box_iloc::Item* item = nullptr;
-  for (const auto& i : items) {
-    if (i.item_ID == ID) {
-      item = &i;
-      break;
-    }
-  }
-  if (!item) {
-    std::stringstream sstr;
-    sstr << "Item with ID " << ID << " has no compressed data";
-
-    return Error(heif_error_Invalid_input,
-                 heif_suberror_No_item_data,
-                 sstr.str());
-  }
-
-  Error error = Error(heif_error_Unsupported_feature,
-                      heif_suberror_Unsupported_codec);
-  if (item_type == "hvc1") {
-    // --- --- --- HEVC
-
-    // --- get properties for this image
-
-    std::vector<Box_ipco::Property> properties;
-    Error err = m_ipco_box->get_properties_for_item_ID(ID, m_ipma_box, properties);
-    if (err) {
-      return err;
-    }
-
-    // --- get codec configuration
-
-    std::shared_ptr<Box_hvcC> hvcC_box;
-    for (auto& prop : properties) {
-      if (prop.property->get_short_type() == fourcc("hvcC")) {
-        hvcC_box = std::dynamic_pointer_cast<Box_hvcC>(prop.property);
-        if (hvcC_box) {
-          break;
-        }
-      }
-    }
-
-    if (!hvcC_box) {
-      // Should always have an hvcC box, because we are checking this in
-      // heif_context::interpret_heif_file()
-      assert(false);
-      return Error(heif_error_Invalid_input,
-                   heif_suberror_No_hvcC_box);
-    }
-    else if (!hvcC_box->get_headers(data)) {
-      return Error(heif_error_Invalid_input,
-                   heif_suberror_No_item_data);
-    }
-
-    error = m_iloc_box->read_data(*item, m_input_stream, m_idat_box, data);
-  }
-  else if (item_type == "av01") {
-    // --- --- --- AV1
-
-    // --- get properties for this image
-
-    std::vector<Box_ipco::Property> properties;
-    Error err = m_ipco_box->get_properties_for_item_ID(ID, m_ipma_box, properties);
-    if (err) {
-      return err;
-    }
-
-    // --- get codec configuration
-
-    std::shared_ptr<Box_av1C> av1C_box;
-    for (auto& prop : properties) {
-      if (prop.property->get_short_type() == fourcc("av1C")) {
-        av1C_box = std::dynamic_pointer_cast<Box_av1C>(prop.property);
-        if (av1C_box) {
-          break;
-        }
-      }
-    }
-
-    if (!av1C_box) {
-      // Should always have an hvcC box, because we are checking this in
-      // heif_context::interpret_heif_file()
-      return Error(heif_error_Invalid_input,
-                   heif_suberror_No_av1C_box);
-    }
-    else if (!av1C_box->get_headers(data)) {
-      return Error(heif_error_Invalid_input,
-                   heif_suberror_No_item_data);
-    }
-
-    error = m_iloc_box->read_data(*item, m_input_stream, m_idat_box, data);
-  }
-  else if (true ||  // fallback case for all kinds of generic metadata (e.g. 'iptc')
-           item_type == "grid" ||
-           item_type == "iovl" ||
-           item_type == "Exif" ||
-           (item_type == "mime" && content_type == "application/rdf+xml")) {
-    error = m_iloc_box->read_data(*item, m_input_stream, m_idat_box, data);
-  }
-
-  if (error != Error::Ok) {
-    return error;
-  }
-
-  return Error::Ok;
-}
-
-
-heif_item_id HeifFile::get_unused_item_id() const
-{
-  for (heif_item_id id = 1;;
-       id++) {
-
-    bool id_exists = false;
-
-    for (const auto& infe : m_infe_boxes) {
-      if (infe.second->get_item_ID() == id) {
-        id_exists = true;
-        break;
-      }
-    }
-
-    if (!id_exists) {
-      return id;
-    }
-  }
-
-  assert(false); // should never be reached
-  return 0;
-}
-
-
-heif_item_id HeifFile::add_new_image(const char* item_type)
-{
-  auto box = add_new_infe_box(item_type);
-  return box->get_item_ID();
-}
-
-
-std::shared_ptr<Box_infe> HeifFile::add_new_infe_box(const char* item_type)
-{
-  heif_item_id id = get_unused_item_id();
-
-  auto infe = std::make_shared<Box_infe>();
-  infe->set_item_ID(id);
-  infe->set_hidden_item(false);
-  infe->set_item_type(item_type);
-
-  m_infe_boxes[id] = infe;
-  m_iinf_box->append_child_box(infe);
-
-  return infe;
-}
-
-
-void HeifFile::add_ispe_property(heif_item_id id, uint32_t width, uint32_t height)
-{
-  auto ispe = std::make_shared<Box_ispe>();
-  ispe->set_size(width, height);
-
-  int index = m_ipco_box->append_child_box(ispe);
-
-  m_ipma_box->add_property_for_item_ID(id, Box_ipma::PropertyAssociation{false, uint16_t(index + 1)});
-}
-
-void HeifFile::add_clap_property(heif_item_id id, uint32_t clap_width, uint32_t clap_height,
-                                 uint32_t image_width, uint32_t image_height)
-{
-  auto clap = std::make_shared<Box_clap>();
-  clap->set(clap_width, clap_height, image_width, image_height);
-
-  int index = m_ipco_box->append_child_box(clap);
-
-  m_ipma_box->add_property_for_item_ID(id, Box_ipma::PropertyAssociation{true, uint16_t(index + 1)});
-}
-
-
-void HeifFile::add_pixi_property(heif_item_id id, uint8_t c1, uint8_t c2, uint8_t c3)
-{
-  auto pixi = std::make_shared<Box_pixi>();
-  pixi->add_channel_bits(c1);
-  if (c2 || c3) {
-    pixi->add_channel_bits(c2);
-    pixi->add_channel_bits(c3);
-  }
-
-  int index = m_ipco_box->append_child_box(pixi);
-
-  m_ipma_box->add_property_for_item_ID(id, Box_ipma::PropertyAssociation{true, uint16_t(index + 1)});
-}
-
-
-void HeifFile::add_hvcC_property(heif_item_id id)
-{
-  auto hvcC = std::make_shared<Box_hvcC>();
-  int index = m_ipco_box->append_child_box(hvcC);
-
-  m_ipma_box->add_property_for_item_ID(id, Box_ipma::PropertyAssociation{true, uint16_t(index + 1)});
-}
-
-
-Error HeifFile::append_hvcC_nal_data(heif_item_id id, const std::vector<uint8_t>& nal_data)
-{
-  auto hvcC = std::dynamic_pointer_cast<Box_hvcC>(m_ipco_box->get_property_for_item_ID(id,
-                                                                                       m_ipma_box,
-                                                                                       fourcc("hvcC")));
-
-  if (hvcC) {
-    hvcC->append_nal_data(nal_data);
-    return Error::Ok;
-  }
-  else {
-    // Should always have an hvcC box, because we are checking this in
-    // heif_context::interpret_heif_file()
-    assert(false);
-    return Error(heif_error_Usage_error,
-                 heif_suberror_No_hvcC_box);
-  }
-}
-
-
-Error HeifFile::set_hvcC_configuration(heif_item_id id, const Box_hvcC::configuration& config)
-{
-  auto hvcC = std::dynamic_pointer_cast<Box_hvcC>(m_ipco_box->get_property_for_item_ID(id,
-                                                                                       m_ipma_box,
-                                                                                       fourcc("hvcC")));
-
-  if (hvcC) {
-    hvcC->set_configuration(config);
-    return Error::Ok;
-  }
-  else {
-    return Error(heif_error_Usage_error,
-                 heif_suberror_No_hvcC_box);
-  }
-}
-
-
-Error HeifFile::append_hvcC_nal_data(heif_item_id id, const uint8_t* data, size_t size)
-{
-  std::vector<Box_ipco::Property> properties;
-
-  auto hvcC = std::dynamic_pointer_cast<Box_hvcC>(m_ipco_box->get_property_for_item_ID(id,
-                                                                                       m_ipma_box,
-                                                                                       fourcc("hvcC")));
-
-  if (hvcC) {
-    hvcC->append_nal_data(data, size);
-    return Error::Ok;
-  }
-  else {
-    return Error(heif_error_Usage_error,
-                 heif_suberror_No_hvcC_box);
-  }
-}
-
-
-void HeifFile::add_av1C_property(heif_item_id id)
-{
-  auto av1C = std::make_shared<Box_av1C>();
-  int index = m_ipco_box->append_child_box(av1C);
-
-  m_ipma_box->add_property_for_item_ID(id, Box_ipma::PropertyAssociation{true, uint16_t(index + 1)});
-}
-
-
-Error HeifFile::set_av1C_configuration(heif_item_id id, const Box_av1C::configuration& config)
-{
-  auto av1C = std::dynamic_pointer_cast<Box_av1C>(m_ipco_box->get_property_for_item_ID(id,
-                                                                                       m_ipma_box,
-                                                                                       fourcc("av1C")));
-
-  if (av1C) {
-    av1C->set_configuration(config);
-    return Error::Ok;
-  }
-  else {
-    return Error(heif_error_Usage_error,
-                 heif_suberror_No_av1C_box);
-  }
-}
-
-
-void HeifFile::append_iloc_data(heif_item_id id, const std::vector<uint8_t>& nal_packets, uint8_t construction_method)
-{
-  m_iloc_box->append_data(id, nal_packets, construction_method);
-}
-
-
-void HeifFile::append_iloc_data_with_4byte_size(heif_item_id id, const uint8_t* data, size_t size)
-{
-  std::vector<uint8_t> nal;
-  nal.resize(size + 4);
-
-  nal[0] = (uint8_t) ((size >> 24) & 0xFF);
-  nal[1] = (uint8_t) ((size >> 16) & 0xFF);
-  nal[2] = (uint8_t) ((size >> 8) & 0xFF);
-  nal[3] = (uint8_t) ((size >> 0) & 0xFF);
-
-  memcpy(nal.data() + 4, data, size);
-
-  append_iloc_data(id, nal);
-}
-
-void HeifFile::set_primary_item_id(heif_item_id id)
-{
-  m_pitm_box->set_item_ID(id);
-}
-
-void HeifFile::add_iref_reference(uint32_t type, heif_item_id from,
-                                  std::vector<heif_item_id> to)
-{
-  if (!m_iref_box) {
-    m_iref_box = std::make_shared<Box_iref>();
-    m_meta_box->append_child_box(m_iref_box);
-  }
-
-  m_iref_box->add_reference(type, from, to);
-}
-
-void HeifFile::set_auxC_property(heif_item_id id, std::string type)
-{
-  auto auxC = std::make_shared<Box_auxC>();
-  auxC->set_aux_type(type);
-
-  int index = m_ipco_box->append_child_box(auxC);
-
-  m_ipma_box->add_property_for_item_ID(id, Box_ipma::PropertyAssociation{true, uint16_t(index + 1)});
-}
-
-void HeifFile::set_color_profile(heif_item_id id, const std::shared_ptr<const color_profile> profile)
-{
-  auto colr = std::make_shared<Box_colr>();
-  colr->set_color_profile(profile);
-
-  int index = m_ipco_box->append_child_box(colr);
-  m_ipma_box->add_property_for_item_ID(id, Box_ipma::PropertyAssociation{true, uint16_t(index + 1)});
-}
-
-
-// TODO: the hdlr box is probably not the right place for this. Into which box should we write comments?
-void HeifFile::set_hdlr_library_info(std::string encoder_plugin_version)
-{
-  std::stringstream sstr;
-  sstr << "libheif (" << LIBHEIF_VERSION << ") / " << encoder_plugin_version;
-  m_hdlr_box->set_name(sstr.str());
-}
-
-
-#ifdef _MSC_VER
-std::wstring HeifFile::convert_utf8_path_to_utf16(std::string str)
-{
-  std::wstring ret;
-  int len = MultiByteToWideChar(CP_UTF8, 0, str.c_str(), str.length(), NULL, 0);
-  if (len > 0)
-  {
-    ret.resize(len);
-    MultiByteToWideChar(CP_UTF8, 0, str.c_str(), str.length(), &ret[0], len);
-  }
-  return ret;
-}
-#endif
diff --git a/libheif/heif_file.h b/libheif/heif_file.h
deleted file mode 100644
index b053d391d2..0000000000
--- a/libheif/heif_file.h
+++ /dev/null
@@ -1,198 +0,0 @@
-/*
- * HEIF codec.
- * Copyright (c) 2017 struktur AG, Dirk Farin <farin@struktur.de>
- *
- * This file is part of libheif.
- *
- * libheif is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as
- * published by the Free Software Foundation, either version 3 of
- * the License, or (at your option) any later version.
- *
- * libheif is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef LIBHEIF_HEIF_FILE_H
-#define LIBHEIF_HEIF_FILE_H
-
-#if defined(HAVE_CONFIG_H)
-#include "config.h"
-#endif
-
-#include "box.h"
-
-#include <map>
-#include <memory>
-#include <string>
-#include <map>
-#include <vector>
-
-#if ENABLE_PARALLEL_TILE_DECODING
-#include <mutex>
-#endif
-
-
-namespace heif {
-
-  class HeifPixelImage;
-
-  class HeifImage;
-
-
-  class HeifFile
-  {
-  public:
-    HeifFile();
-
-    ~HeifFile();
-
-    Error read(std::shared_ptr<StreamReader> reader);
-
-    Error read_from_file(const char* input_filename);
-
-    Error read_from_memory(const void* data, size_t size, bool copy);
-
-    void new_empty_file();
-
-    void set_brand(heif_compression_format format, bool miaf_compatible);
-
-    void write(StreamWriter& writer);
-
-    int get_num_images() const
-    { return static_cast<int>(m_infe_boxes.size()); }
-
-    heif_item_id get_primary_image_ID() const
-    { return m_pitm_box->get_item_ID(); }
-
-    std::vector<heif_item_id> get_item_IDs() const;
-
-    bool image_exists(heif_item_id ID) const;
-
-    std::string get_item_type(heif_item_id ID) const;
-
-    std::string get_content_type(heif_item_id ID) const;
-
-    Error get_compressed_image_data(heif_item_id ID, std::vector<uint8_t>* out_data) const;
-
-
-    std::shared_ptr<Box_infe> get_infe_box(heif_item_id imageID)
-    {
-      auto iter = m_infe_boxes.find(imageID);
-      if (iter == m_infe_boxes.end()) {
-        return nullptr;
-      }
-
-      return iter->second;
-    }
-
-    std::shared_ptr<Box_iref> get_iref_box()
-    { return m_iref_box; }
-
-    std::shared_ptr<Box_ipco> get_ipco_box()
-    { return m_ipco_box; }
-
-    std::shared_ptr<Box_ipma> get_ipma_box()
-    { return m_ipma_box; }
-
-    Error get_properties(heif_item_id imageID,
-                         std::vector<Box_ipco::Property>& properties) const;
-
-    heif_chroma get_image_chroma_from_configuration(heif_item_id imageID) const;
-
-    int get_luma_bits_per_pixel_from_configuration(heif_item_id imageID) const;
-
-    int get_chroma_bits_per_pixel_from_configuration(heif_item_id imageID) const;
-
-    std::string debug_dump_boxes() const;
-
-
-    // --- writing ---
-
-    heif_item_id get_unused_item_id() const;
-
-    heif_item_id add_new_image(const char* item_type);
-
-    std::shared_ptr<Box_infe> add_new_infe_box(const char* item_type);
-
-    void add_hvcC_property(heif_item_id id);
-
-    Error append_hvcC_nal_data(heif_item_id id, const std::vector<uint8_t>& data);
-
-    Error append_hvcC_nal_data(heif_item_id id, const uint8_t* data, size_t size);
-
-    Error set_hvcC_configuration(heif_item_id id, const Box_hvcC::configuration& config);
-
-    void add_av1C_property(heif_item_id id);
-
-    Error set_av1C_configuration(heif_item_id id, const Box_av1C::configuration& config);
-
-    void add_ispe_property(heif_item_id id, uint32_t width, uint32_t height);
-
-    void add_clap_property(heif_item_id id, uint32_t clap_width, uint32_t clap_height,
-                           uint32_t image_width, uint32_t image_height);
-
-    void add_pixi_property(heif_item_id id, uint8_t c1, uint8_t c2=0, uint8_t c3=0);
-
-    void append_iloc_data(heif_item_id id, const std::vector<uint8_t>& nal_packets, uint8_t construction_method = 0);
-
-    void append_iloc_data_with_4byte_size(heif_item_id id, const uint8_t* data, size_t size);
-
-    void set_primary_item_id(heif_item_id id);
-
-    void add_iref_reference(heif_item_id from, uint32_t type,
-                            std::vector<heif_item_id> to);
-
-    void set_auxC_property(heif_item_id id, std::string type);
-
-    void set_color_profile(heif_item_id id, const std::shared_ptr<const color_profile> profile);
-
-    // TODO: the hdlr box is probably not the right place for this. Into which box should we write comments?
-    void set_hdlr_library_info(std::string encoder_plugin_version);
-
-#ifdef _MSC_VER
-    static std::wstring convert_utf8_path_to_utf16(std::string pathutf8);
-#endif
-
-  private:
-#if ENABLE_PARALLEL_TILE_DECODING
-    mutable std::mutex m_read_mutex;
-#endif
-
-    std::shared_ptr<StreamReader> m_input_stream;
-
-    std::vector<std::shared_ptr<Box> > m_top_level_boxes;
-
-    std::shared_ptr<Box_ftyp> m_ftyp_box;
-    std::shared_ptr<Box_hdlr> m_hdlr_box;
-    std::shared_ptr<Box_meta> m_meta_box;
-
-    std::shared_ptr<Box_ipco> m_ipco_box;
-    std::shared_ptr<Box_ipma> m_ipma_box;
-    std::shared_ptr<Box_iloc> m_iloc_box;
-    std::shared_ptr<Box_idat> m_idat_box;
-    std::shared_ptr<Box_iref> m_iref_box;
-    std::shared_ptr<Box_pitm> m_pitm_box;
-    std::shared_ptr<Box_iinf> m_iinf_box;
-
-    std::shared_ptr<Box_iprp> m_iprp_box;
-
-    std::map<heif_item_id, std::shared_ptr<Box_infe> > m_infe_boxes;
-
-    // list of image items (does not include hidden images or Exif data)
-    //std::vector<heif_item_id> m_valid_image_IDs;
-
-
-    Error parse_heif_file(BitstreamRange& bitstream);
-
-    std::shared_ptr<Box_infe> get_infe(heif_item_id ID) const;
-  };
-
-}
-
-#endif
diff --git a/libheif/heif_hevc.cc b/libheif/heif_hevc.cc
deleted file mode 100644
index 27e8ee014f..0000000000
--- a/libheif/heif_hevc.cc
+++ /dev/null
@@ -1,305 +0,0 @@
-/*
- * HEIF codec.
- * Copyright (c) 2017 struktur AG, Dirk Farin <farin@struktur.de>
- *
- * This file is part of libheif.
- *
- * libheif is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as
- * published by the Free Software Foundation, either version 3 of
- * the License, or (at your option) any later version.
- *
- * libheif is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "heif_hevc.h"
-#include "bitstream.h"
-
-#include <cmath>
-
-using namespace heif;
-
-
-static double read_depth_rep_info_element(BitReader& reader)
-{
-  int sign_flag = reader.get_bits(1);
-  int exponent = reader.get_bits(7);
-  int mantissa_len = reader.get_bits(5) + 1;
-  if (mantissa_len < 1 || mantissa_len > 32) {
-    // TODO err
-  }
-
-  if (exponent == 127) {
-    // TODO value unspecified
-  }
-
-  int mantissa = reader.get_bits(mantissa_len);
-  double value;
-
-  //printf("sign:%d exponent:%d mantissa_len:%d mantissa:%d\n",sign_flag,exponent,mantissa_len,mantissa);
-
-  if (exponent > 0) {
-    value = pow(2, exponent - 31) * (1.0 + mantissa / pow(2, mantissa_len));
-  }
-  else {
-    value = pow(2, -(30 + mantissa_len)) * mantissa;
-  }
-
-  if (sign_flag) {
-    value = -value;
-  }
-
-  return value;
-}
-
-
-static std::shared_ptr<SEIMessage> read_depth_representation_info(BitReader& reader)
-{
-  auto msg = std::make_shared<SEIMessage_depth_representation_info>();
-
-
-  // default values
-
-  msg->version = 1;
-
-  msg->disparity_reference_view = 0;
-  msg->depth_nonlinear_representation_model_size = 0;
-  msg->depth_nonlinear_representation_model = nullptr;
-
-
-  // read header
-
-  msg->has_z_near = (uint8_t) reader.get_bits(1);
-  msg->has_z_far = (uint8_t) reader.get_bits(1);
-  msg->has_d_min = (uint8_t) reader.get_bits(1);
-  msg->has_d_max = (uint8_t) reader.get_bits(1);
-
-  int rep_type;
-  if (!reader.get_uvlc(&rep_type)) {
-    // TODO error
-  }
-  // TODO: check rep_type range
-  msg->depth_representation_type = (enum heif_depth_representation_type) rep_type;
-
-  //printf("flags: %d %d %d %d\n",msg->has_z_near,msg->has_z_far,msg->has_d_min,msg->has_d_max);
-  //printf("type: %d\n",rep_type);
-
-  if (msg->has_d_min || msg->has_d_max) {
-    int ref_view;
-    if (!reader.get_uvlc(&ref_view)) {
-      // TODO error
-    }
-    msg->disparity_reference_view = ref_view;
-
-    //printf("ref_view: %d\n",msg->disparity_reference_view);
-  }
-
-  if (msg->has_z_near) msg->z_near = read_depth_rep_info_element(reader);
-  if (msg->has_z_far) msg->z_far = read_depth_rep_info_element(reader);
-  if (msg->has_d_min) msg->d_min = read_depth_rep_info_element(reader);
-  if (msg->has_d_max) msg->d_max = read_depth_rep_info_element(reader);
-
-  /*
-  printf("z_near: %f\n",msg->z_near);
-  printf("z_far: %f\n",msg->z_far);
-  printf("dmin: %f\n",msg->d_min);
-  printf("dmax: %f\n",msg->d_max);
-  */
-
-  if (msg->depth_representation_type == heif_depth_representation_type_nonuniform_disparity) {
-    // TODO: load non-uniform response curve
-  }
-
-  return msg;
-}
-
-
-// aux subtypes: 00 00 00 11 / 00 00 00 0d / 4e 01 / b1 09 / 35 1e 78 c8 01 03 c5 d0 20
-
-Error heif::decode_hevc_aux_sei_messages(const std::vector<uint8_t>& data,
-                                         std::vector<std::shared_ptr<SEIMessage>>& msgs)
-{
-  // TODO: we probably do not need a full BitReader just for the array size.
-  // Read this and the NAL size directly on the array data.
-
-  BitReader reader(data.data(), (int) data.size());
-  uint32_t len = (uint32_t) reader.get_bits(32);
-
-  if (len > data.size() - 4) {
-    // ERROR: read past end of data
-  }
-
-  while (reader.get_current_byte_index() < (int) len) {
-    int currPos = reader.get_current_byte_index();
-    BitReader sei_reader(data.data() + currPos, (int) data.size() - currPos);
-
-    uint32_t nal_size = (uint32_t) sei_reader.get_bits(32);
-    (void) nal_size;
-
-    uint8_t nal_type = (uint8_t) (sei_reader.get_bits(8) >> 1);
-    sei_reader.skip_bits(8);
-
-    // SEI
-
-    if (nal_type == 39 ||
-        nal_type == 40) {
-
-      // TODO: loading of multi-byte sei headers
-      uint8_t payload_id = (uint8_t) (sei_reader.get_bits(8));
-      uint8_t payload_size = (uint8_t) (sei_reader.get_bits(8));
-      (void) payload_size;
-
-      switch (payload_id) {
-        case 177: // depth_representation_info
-          std::shared_ptr<SEIMessage> sei = read_depth_representation_info(sei_reader);
-          msgs.push_back(sei);
-          break;
-      }
-    }
-
-    break; // TODO: read next SEI
-  }
-
-
-  return Error::Ok;
-}
-
-
-static std::vector<uint8_t> remove_start_code_emulation(const uint8_t* sps, size_t size)
-{
-  std::vector<uint8_t> out_data;
-
-  for (size_t i = 0; i < size; i++) {
-    if (i + 2 < size &&
-        sps[i] == 0 &&
-        sps[i + 1] == 0 &&
-        sps[i + 2] == 3) {
-      out_data.push_back(0);
-      out_data.push_back(0);
-      i += 2;
-    }
-    else {
-      out_data.push_back(sps[i]);
-    }
-  }
-
-  return out_data;
-}
-
-
-Error heif::parse_sps_for_hvcC_configuration(const uint8_t* sps, size_t size,
-                                             Box_hvcC::configuration* config,
-                                             int* width, int* height)
-{
-  // remove start-code emulation bytes from SPS header stream
-
-  std::vector<uint8_t> sps_no_emul = remove_start_code_emulation(sps, size);
-
-  sps = sps_no_emul.data();
-  size = sps_no_emul.size();
-
-
-  BitReader reader(sps, (int) size);
-
-  // skip NAL header
-  reader.skip_bits(2 * 8);
-
-  // skip VPS ID
-  reader.skip_bits(4);
-
-  int nMaxSubLayersMinus1 = reader.get_bits(3);
-
-  config->temporal_id_nested = (uint8_t) reader.get_bits(1);
-
-  // --- profile_tier_level ---
-
-  config->general_profile_space = (uint8_t) reader.get_bits(2);
-  config->general_tier_flag = (uint8_t) reader.get_bits(1);
-  config->general_profile_idc = (uint8_t) reader.get_bits(5);
-  config->general_profile_compatibility_flags = reader.get_bits(32);
-
-  reader.skip_bits(16); // skip reserved bits
-  reader.skip_bits(16); // skip reserved bits
-  reader.skip_bits(16); // skip reserved bits
-
-  config->general_level_idc = (uint8_t) reader.get_bits(8);
-
-  std::vector<bool> layer_profile_present(nMaxSubLayersMinus1);
-  std::vector<bool> layer_level_present(nMaxSubLayersMinus1);
-
-  for (int i = 0; i < nMaxSubLayersMinus1; i++) {
-    layer_profile_present[i] = reader.get_bits(1);
-    layer_level_present[i] = reader.get_bits(1);
-  }
-
-  for (int i = 0; i < nMaxSubLayersMinus1; i++) {
-    if (layer_profile_present[i]) {
-      reader.skip_bits(2 + 1 + 5);
-      reader.skip_bits(32);
-      reader.skip_bits(16);
-    }
-
-    if (layer_level_present[i]) {
-      reader.skip_bits(8);
-    }
-  }
-
-
-  // --- SPS continued ---
-
-  int dummy, value;
-  reader.get_uvlc(&dummy); // skip seq_parameter_seq_id
-
-  reader.get_uvlc(&value);
-  config->chroma_format = (uint8_t) value;
-
-  if (config->chroma_format == 3) {
-    reader.skip_bits(1);
-  }
-
-  reader.get_uvlc(width);
-  reader.get_uvlc(height);
-
-  bool conformance_window = reader.get_bits(1);
-  if (conformance_window) {
-    int left, right, top, bottom;
-    reader.get_uvlc(&left);
-    reader.get_uvlc(&right);
-    reader.get_uvlc(&top);
-    reader.get_uvlc(&bottom);
-
-    //printf("conformance borders: %d %d %d %d\n",left,right,top,bottom);
-
-    int subH=1, subV=1;
-    if (config->chroma_format == 1) { subV=2; subH=2; }
-    if (config->chroma_format == 2) { subH=2; }
-
-    *width -= subH * (left + right);
-    *height -= subV * (top + bottom);
-  }
-
-  reader.get_uvlc(&value);
-  config->bit_depth_luma = (uint8_t) (value + 8);
-
-  reader.get_uvlc(&value);
-  config->bit_depth_chroma = (uint8_t) (value + 8);
-
-
-
-  // --- init static configuration fields ---
-
-  config->configuration_version = 1;
-  config->min_spatial_segmentation_idc = 0; // TODO: get this value from the VUI, 0 should be safe
-  config->parallelism_type = 0; // TODO, 0 should be safe
-  config->avg_frame_rate = 0; // makes no sense for HEIF
-  config->constant_frame_rate = 0; // makes no sense for HEIF
-  config->num_temporal_layers = 1; // makes no sense for HEIF
-
-  return Error::Ok;
-}
diff --git a/libheif/heif_image.cc b/libheif/heif_image.cc
deleted file mode 100644
index 44d38e110a..0000000000
--- a/libheif/heif_image.cc
+++ /dev/null
@@ -1,1004 +0,0 @@
-/*
- * HEIF codec.
- * Copyright (c) 2017 struktur AG, Dirk Farin <farin@struktur.de>
- *
- * This file is part of libheif.
- *
- * libheif is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as
- * published by the Free Software Foundation, either version 3 of
- * the License, or (at your option) any later version.
- *
- * libheif is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-
-#include "heif_image.h"
-#include "heif_colorconversion.h"
-
-#include <cassert>
-#include <cstring>
-
-#include <utility>
-
-using namespace heif;
-
-
-uint8_t heif::chroma_h_subsampling(heif_chroma c)
-{
-  switch (c) {
-    case heif_chroma_monochrome:
-    case heif_chroma_444:
-      return 1;
-
-    case heif_chroma_420:
-    case heif_chroma_422:
-      return 2;
-
-    case heif_chroma_interleaved_RGB:
-    case heif_chroma_interleaved_RGBA:
-    default:
-      assert(false);
-      return 0;
-  }
-}
-
-uint8_t heif::chroma_v_subsampling(heif_chroma c)
-{
-  switch (c) {
-    case heif_chroma_monochrome:
-    case heif_chroma_444:
-    case heif_chroma_422:
-      return 1;
-
-    case heif_chroma_420:
-      return 2;
-
-    case heif_chroma_interleaved_RGB:
-    case heif_chroma_interleaved_RGBA:
-    default:
-      assert(false);
-      return 0;
-  }
-}
-
-heif_chroma heif::chroma_from_subsampling(int h, int v)
-{
-  if (h == 2 && v == 2) {
-    return heif_chroma_420;
-  }
-  else if (h == 2 && v == 1) {
-    return heif_chroma_422;
-  }
-  else if (h == 1 && v == 1) {
-    return heif_chroma_444;
-  }
-  else {
-    assert(false);
-    return heif_chroma_undefined;
-  }
-}
-
-
-HeifPixelImage::~HeifPixelImage()
-{
-  for (auto& iter : m_planes) {
-    delete[] iter.second.allocated_mem;
-  }
-}
-
-
-int heif::num_interleaved_pixels_per_plane(heif_chroma chroma)
-{
-  switch (chroma) {
-    case heif_chroma_undefined:
-    case heif_chroma_monochrome:
-    case heif_chroma_420:
-    case heif_chroma_422:
-    case heif_chroma_444:
-      return 1;
-
-    case heif_chroma_interleaved_RGB:
-    case heif_chroma_interleaved_RRGGBB_BE:
-    case heif_chroma_interleaved_RRGGBB_LE:
-      return 3;
-
-    case heif_chroma_interleaved_RGBA:
-    case heif_chroma_interleaved_RRGGBBAA_BE:
-    case heif_chroma_interleaved_RRGGBBAA_LE:
-      return 4;
-  }
-
-  assert(false);
-  return 0;
-}
-
-
-bool heif::is_integer_multiple_of_chroma_size(int width,
-                                              int height,
-                                              heif_chroma chroma)
-{
-  switch (chroma) {
-    case heif_chroma_444:
-    case heif_chroma_monochrome:
-      return true;
-    case heif_chroma_422:
-      return (width & 1) == 0;
-    case heif_chroma_420:
-      return (width & 1) == 0 && (height & 1) == 0;
-    default:
-      assert(false);
-      return false;
-  }
-}
-
-
-void HeifPixelImage::create(int width, int height, heif_colorspace colorspace, heif_chroma chroma)
-{
-  m_width = width;
-  m_height = height;
-  m_colorspace = colorspace;
-  m_chroma = chroma;
-}
-
-static uint32_t rounded_size(uint32_t s)
-{
-  s = (s + 1U) & ~1U;
-
-  if (s < 64) {
-    s = 64;
-  }
-
-  return s;
-}
-
-bool HeifPixelImage::add_plane(heif_channel channel, int width, int height, int bit_depth)
-{
-  ImagePlane plane;
-  if (plane.alloc(width, height, bit_depth, m_chroma)) {
-    m_planes.insert(std::make_pair(channel, plane));
-    return true;
-  }
-  else {
-    return false;
-  }
-}
-
-
-bool HeifPixelImage::ImagePlane::alloc(int width, int height, int bit_depth, heif_chroma chroma)
-{
-  assert(width >= 0);
-  assert(height >= 0);
-  assert(bit_depth >= 1);
-  assert(bit_depth <= 32);
-
-  // use 16 byte alignment
-  uint16_t alignment = 16; // must be power of two
-
-  m_width = width;
-  m_height = height;
-
-  m_mem_width = rounded_size(width);
-  m_mem_height = rounded_size(height);
-
-  // for backwards compatibility, allow for 24/32 bits for RGB/RGBA interleaved chromas
-
-  if (chroma == heif_chroma_interleaved_RGB && bit_depth == 24) {
-    bit_depth = 8;
-  }
-
-  if (chroma == heif_chroma_interleaved_RGBA && bit_depth == 32) {
-    bit_depth = 8;
-  }
-
-  assert(m_bit_depth <= 16);
-  m_bit_depth = static_cast<uint8_t>(bit_depth);
-
-
-  int bytes_per_component = (m_bit_depth + 7) / 8;
-  int bytes_per_pixel = num_interleaved_pixels_per_plane(chroma) * bytes_per_component;
-
-  stride = m_mem_width * bytes_per_pixel;
-  stride = (stride + alignment - 1U) & ~(alignment - 1U);
-
-  try {
-    allocated_mem = new uint8_t[m_mem_height * stride + alignment - 1];
-    mem = allocated_mem;
-
-    // shift beginning of image data to aligned memory position
-
-    auto mem_start_addr = (uint64_t) mem;
-    auto mem_start_offset = (mem_start_addr & (alignment - 1U));
-    if (mem_start_offset != 0) {
-      mem += alignment - mem_start_offset;
-    }
-
-    return true;
-  }
-  catch (const std::bad_alloc& excpt) {
-    return false;
-  }
-}
-
-
-void heif::get_subsampled_size(int width, int height,
-                               heif_channel channel,
-                               heif_chroma chroma,
-                               int* subsampled_width, int* subsampled_height)
-{
-  if (channel == heif_channel_Cb ||
-      channel == heif_channel_Cr) {
-    uint8_t chromaSubH = chroma_h_subsampling(chroma);
-    uint8_t chromaSubV = chroma_v_subsampling(chroma);
-
-    *subsampled_width = (width + chromaSubH - 1) / chromaSubH;
-    *subsampled_height = (height + chromaSubV - 1) / chromaSubV;
-  }
-  else {
-    *subsampled_width = width;
-    *subsampled_height = height;
-  }
-}
-
-
-bool HeifPixelImage::extend_padding_to_size(int width, int height)
-{
-  for (auto& planeIter : m_planes) {
-    auto* plane = &planeIter.second;
-
-    int subsampled_width, subsampled_height;
-    get_subsampled_size(width, height, planeIter.first, m_chroma,
-                        &subsampled_width, &subsampled_height);
-
-    int old_width = plane->m_width;
-    int old_height = plane->m_height;
-
-    if (plane->m_mem_width < subsampled_width ||
-        plane->m_mem_height < subsampled_height) {
-
-      ImagePlane newPlane;
-      if (!newPlane.alloc(subsampled_width, subsampled_height, plane->m_bit_depth, m_chroma)) {
-        return false;
-      }
-
-      // copy the visible part of the old plane into the new plane
-
-      for (int y = 0; y < plane->m_height; y++) {
-        memcpy(&newPlane.mem[y * newPlane.stride],
-               &plane->mem[y * plane->stride],
-               plane->m_width);
-      }
-
-      planeIter.second = newPlane;
-      plane = &planeIter.second;
-    }
-
-    // extend plane size
-
-    int nbytes = (plane->m_bit_depth + 7) / 8;
-
-    for (int y = 0; y < old_height; y++) {
-      for (int x = old_width; x < subsampled_width; x++) {
-        memcpy(&plane->mem[y * plane->stride + x * nbytes],
-               &plane->mem[y * plane->stride + (plane->m_width - 1) * nbytes],
-               nbytes);
-      }
-    }
-
-    for (int y = old_height; y < subsampled_height; y++) {
-      memcpy(&plane->mem[y * plane->stride],
-             &plane->mem[(plane->m_height - 1) * plane->stride],
-             subsampled_width * nbytes);
-    }
-  }
-
-  // don't modify the logical image size
-
-  return true;
-}
-
-
-bool HeifPixelImage::has_channel(heif_channel channel) const
-{
-  return (m_planes.find(channel) != m_planes.end());
-}
-
-
-bool HeifPixelImage::has_alpha() const
-{
-  return has_channel(heif_channel_Alpha) ||
-         get_chroma_format() == heif_chroma_interleaved_RGBA ||
-         get_chroma_format() == heif_chroma_interleaved_RRGGBBAA_BE ||
-         get_chroma_format() == heif_chroma_interleaved_RRGGBBAA_LE;
-}
-
-
-int HeifPixelImage::get_width(enum heif_channel channel) const
-{
-  auto iter = m_planes.find(channel);
-  if (iter == m_planes.end()) {
-    return -1;
-  }
-
-  return iter->second.m_width;
-}
-
-
-int HeifPixelImage::get_height(enum heif_channel channel) const
-{
-  auto iter = m_planes.find(channel);
-  if (iter == m_planes.end()) {
-    return -1;
-  }
-
-  return iter->second.m_height;
-}
-
-
-std::set<heif_channel> HeifPixelImage::get_channel_set() const
-{
-  std::set<heif_channel> channels;
-
-  for (const auto& plane : m_planes) {
-    channels.insert(plane.first);
-  }
-
-  return channels;
-}
-
-
-uint8_t HeifPixelImage::get_storage_bits_per_pixel(enum heif_channel channel) const
-{
-  if (channel == heif_channel_interleaved) {
-    auto chroma = get_chroma_format();
-    switch (chroma) {
-      case heif_chroma_interleaved_RGB:
-        return 24;
-      case heif_chroma_interleaved_RGBA:
-        return 32;
-      case heif_chroma_interleaved_RRGGBB_BE:
-      case heif_chroma_interleaved_RRGGBB_LE:
-        return 48;
-      case heif_chroma_interleaved_RRGGBBAA_BE:
-      case heif_chroma_interleaved_RRGGBBAA_LE:
-        return 64;
-      default:
-        return -1; // invalid channel/chroma specification
-    }
-  }
-  else {
-    uint32_t bpp = (get_bits_per_pixel(channel) + 7U) & ~7U;
-    assert(bpp <= 255);
-    return static_cast<uint8_t>(bpp);
-  }
-}
-
-
-uint8_t HeifPixelImage::get_bits_per_pixel(enum heif_channel channel) const
-{
-  auto iter = m_planes.find(channel);
-  if (iter == m_planes.end()) {
-    return -1;
-  }
-
-  return iter->second.m_bit_depth;
-}
-
-
-uint8_t* HeifPixelImage::get_plane(enum heif_channel channel, int* out_stride)
-{
-  auto iter = m_planes.find(channel);
-  if (iter == m_planes.end()) {
-    return nullptr;
-  }
-
-  if (out_stride) {
-    *out_stride = iter->second.stride;
-  }
-
-  return iter->second.mem;
-}
-
-
-const uint8_t* HeifPixelImage::get_plane(enum heif_channel channel, int* out_stride) const
-{
-  auto iter = m_planes.find(channel);
-  if (iter == m_planes.end()) {
-    return nullptr;
-  }
-
-  if (out_stride) {
-    *out_stride = iter->second.stride;
-  }
-
-  return iter->second.mem;
-}
-
-
-void HeifPixelImage::copy_new_plane_from(const std::shared_ptr<const HeifPixelImage>& src_image,
-                                         heif_channel src_channel,
-                                         heif_channel dst_channel)
-{
-  int width = src_image->get_width(src_channel);
-  int height = src_image->get_height(src_channel);
-
-  assert(!has_channel(dst_channel));
-
-  add_plane(dst_channel, width, height, src_image->get_bits_per_pixel(src_channel));
-
-  uint8_t* dst;
-  int dst_stride = 0;
-
-  const uint8_t* src;
-  int src_stride = 0;
-
-  src = src_image->get_plane(src_channel, &src_stride);
-  dst = get_plane(dst_channel, &dst_stride);
-
-  int bpl = width * (src_image->get_storage_bits_per_pixel(src_channel) / 8);
-
-  for (int y = 0; y < height; y++) {
-    memcpy(dst + y * dst_stride, src + y * src_stride, bpl);
-  }
-}
-
-void HeifPixelImage::fill_new_plane(heif_channel dst_channel, uint16_t value, int width, int height, int bpp)
-{
-  add_plane(dst_channel, width, height, bpp);
-
-  if (bpp == 8) {
-    uint8_t* dst;
-    int dst_stride = 0;
-    dst = get_plane(dst_channel, &dst_stride);
-
-    for (int y = 0; y < height; y++) {
-      memset(dst + y * dst_stride, value, width);
-    }
-  }
-  else {
-    uint16_t* dst;
-    int dst_stride = 0;
-    dst = (uint16_t*) get_plane(dst_channel, &dst_stride);
-
-    dst_stride /= 2;
-
-    for (int y = 0; y < height; y++) {
-      for (int x = 0; x < width; x++) {
-        dst[y * dst_stride + x] = value;
-      }
-    }
-  }
-}
-
-
-void HeifPixelImage::transfer_plane_from_image_as(const std::shared_ptr<HeifPixelImage>& source,
-                                                  heif_channel src_channel,
-                                                  heif_channel dst_channel)
-{
-  // TODO: check that dst_channel does not exist yet
-
-  ImagePlane plane = source->m_planes[src_channel];
-  source->m_planes.erase(src_channel);
-
-  m_planes.insert(std::make_pair(dst_channel, plane));
-}
-
-
-bool heif::is_chroma_with_alpha(heif_chroma chroma)
-{
-  switch (chroma) {
-    case heif_chroma_undefined:
-    case heif_chroma_monochrome:
-    case heif_chroma_420:
-    case heif_chroma_422:
-    case heif_chroma_444:
-    case heif_chroma_interleaved_RGB:
-    case heif_chroma_interleaved_RRGGBB_BE:
-    case heif_chroma_interleaved_RRGGBB_LE:
-      return false;
-
-    case heif_chroma_interleaved_RGBA:
-    case heif_chroma_interleaved_RRGGBBAA_BE:
-    case heif_chroma_interleaved_RRGGBBAA_LE:
-      return true;
-  }
-
-  assert(false);
-  return false;
-}
-
-
-Error HeifPixelImage::rotate_ccw(int angle_degrees,
-                                 std::shared_ptr<HeifPixelImage>& out_img)
-{
-  // --- create output image (or simply reuse existing image)
-
-  if (angle_degrees == 0) {
-    out_img = shared_from_this();
-    return Error::Ok;
-  }
-
-  int out_width = m_width;
-  int out_height = m_height;
-
-  if (angle_degrees == 90 || angle_degrees == 270) {
-    std::swap(out_width, out_height);
-  }
-
-  out_img = std::make_shared<HeifPixelImage>();
-  out_img->create(out_width, out_height, m_colorspace, m_chroma);
-
-
-  // --- rotate all channels
-
-  for (const auto& plane_pair : m_planes) {
-    heif_channel channel = plane_pair.first;
-    const ImagePlane& plane = plane_pair.second;
-
-    /*
-    if (plane.bit_depth != 8) {
-      return Error(heif_error_Unsupported_feature,
-                   heif_suberror_Unspecified,
-                   "Can currently only rotate images with 8 bits per pixel");
-    }
-    */
-
-    int out_plane_width = plane.m_width;
-    int out_plane_height = plane.m_height;
-
-    if (angle_degrees == 90 || angle_degrees == 270) {
-      std::swap(out_plane_width, out_plane_height);
-    }
-
-    out_img->add_plane(channel, out_plane_width, out_plane_height, plane.m_bit_depth);
-
-
-    int w = plane.m_width;
-    int h = plane.m_height;
-
-    int in_stride = plane.stride;
-    const uint8_t* in_data = plane.mem;
-
-    int out_stride = 0;
-    uint8_t* out_data = out_img->get_plane(channel, &out_stride);
-
-    if (plane.m_bit_depth == 8) {
-      if (angle_degrees == 270) {
-        for (int x = 0; x < h; x++)
-          for (int y = 0; y < w; y++) {
-            out_data[y * out_stride + x] = in_data[(h - 1 - x) * in_stride + y];
-          }
-      }
-      else if (angle_degrees == 180) {
-        for (int y = 0; y < h; y++)
-          for (int x = 0; x < w; x++) {
-            out_data[y * out_stride + x] = in_data[(h - 1 - y) * in_stride + (w - 1 - x)];
-          }
-      }
-      else if (angle_degrees == 90) {
-        for (int x = 0; x < h; x++)
-          for (int y = 0; y < w; y++) {
-            out_data[y * out_stride + x] = in_data[x * in_stride + (w - 1 - y)];
-          }
-      }
-    }
-    else { // 16 bit (TODO: unchecked code)
-      if (angle_degrees == 270) {
-        for (int x = 0; x < h; x++)
-          for (int y = 0; y < w; y++) {
-            out_data[y * out_stride + 2 * x] = in_data[(h - 1 - x) * in_stride + 2 * y];
-            out_data[y * out_stride + 2 * x + 1] = in_data[(h - 1 - x) * in_stride + 2 * y + 1];
-          }
-      }
-      else if (angle_degrees == 180) {
-        for (int y = 0; y < h; y++)
-          for (int x = 0; x < w; x++) {
-            out_data[y * out_stride + 2 * x] = in_data[(h - 1 - y) * in_stride + 2 * (w - 1 - x)];
-            out_data[y * out_stride + 2 * x + 1] = in_data[(h - 1 - y) * in_stride + 2 * (w - 1 - x) + 1];
-          }
-      }
-      else if (angle_degrees == 90) {
-        for (int x = 0; x < h; x++)
-          for (int y = 0; y < w; y++) {
-            out_data[y * out_stride + 2 * x] = in_data[x * in_stride + 2 * (w - 1 - y)];
-            out_data[y * out_stride + 2 * x + 1] = in_data[x * in_stride + 2 * (w - 1 - y) + 1];
-          }
-      }
-    }
-  }
-
-  // --- pass the color profiles to the new image
-
-  out_img->set_color_profile_nclx(get_color_profile_nclx());
-  out_img->set_color_profile_icc(get_color_profile_icc());
-
-  return Error::Ok;
-}
-
-
-Error HeifPixelImage::mirror_inplace(bool horizontal)
-{
-  for (auto& plane_pair : m_planes) {
-    ImagePlane& plane = plane_pair.second;
-
-    if (plane.m_bit_depth != 8) {
-      return Error(heif_error_Unsupported_feature,
-                   heif_suberror_Unspecified,
-                   "Can currently only mirror images with 8 bits per pixel");
-    }
-
-
-    int w = plane.m_width;
-    int h = plane.m_height;
-
-    int stride = plane.stride;
-    uint8_t* data = plane.mem;
-
-    if (horizontal) {
-      for (int y = 0; y < h; y++) {
-        for (int x = 0; x < w / 2; x++)
-          std::swap(data[y * stride + x], data[y * stride + w - 1 - x]);
-      }
-    }
-    else {
-      for (int y = 0; y < h / 2; y++) {
-        for (int x = 0; x < w; x++)
-          std::swap(data[y * stride + x], data[(h - 1 - y) * stride + x]);
-      }
-    }
-  }
-
-  return Error::Ok;
-}
-
-
-Error HeifPixelImage::crop(int left, int right, int top, int bottom,
-                           std::shared_ptr<HeifPixelImage>& out_img) const
-{
-  out_img = std::make_shared<HeifPixelImage>();
-  out_img->create(right - left + 1, bottom - top + 1, m_colorspace, m_chroma);
-
-
-  // --- crop all channels
-
-  for (const auto& plane_pair : m_planes) {
-    heif_channel channel = plane_pair.first;
-    const ImagePlane& plane = plane_pair.second;
-
-    if (false && plane.m_bit_depth != 8) {
-      return Error(heif_error_Unsupported_feature,
-                   heif_suberror_Unspecified,
-                   "Can currently only crop images with 8 bits per pixel");
-    }
-
-
-    int w = plane.m_width;
-    int h = plane.m_height;
-
-    int plane_left = left * w / m_width;
-    int plane_right = right * w / m_width;
-    int plane_top = top * h / m_height;
-    int plane_bottom = bottom * h / m_height;
-
-    out_img->add_plane(channel,
-                       plane_right - plane_left + 1,
-                       plane_bottom - plane_top + 1,
-                       plane.m_bit_depth);
-
-    int in_stride = plane.stride;
-    const uint8_t* in_data = plane.mem;
-
-    int out_stride = 0;
-    uint8_t* out_data = out_img->get_plane(channel, &out_stride);
-
-    if (plane.m_bit_depth == 8) {
-      for (int y = plane_top; y <= plane_bottom; y++) {
-        memcpy(&out_data[(y - plane_top) * out_stride],
-               &in_data[y * in_stride + plane_left],
-               plane_right - plane_left + 1);
-      }
-    }
-    else {
-      for (int y = plane_top; y <= plane_bottom; y++) {
-        memcpy(&out_data[(y - plane_top) * out_stride],
-               &in_data[y * in_stride + plane_left * 2],
-               (plane_right - plane_left + 1) * 2);
-      }
-    }
-  }
-
-  // --- pass the color profiles to the new image
-
-  out_img->set_color_profile_nclx(get_color_profile_nclx());
-  out_img->set_color_profile_icc(get_color_profile_icc());
-
-  return Error::Ok;
-}
-
-
-Error HeifPixelImage::fill_RGB_16bit(uint16_t r, uint16_t g, uint16_t b, uint16_t a)
-{
-  for (const auto& channel : {heif_channel_R, heif_channel_G, heif_channel_B, heif_channel_Alpha}) {
-
-    const auto plane_iter = m_planes.find(channel);
-    if (plane_iter == m_planes.end()) {
-
-      // alpha channel is optional, R,G,B is required
-      if (channel == heif_channel_Alpha) {
-        continue;
-      }
-
-      return Error(heif_error_Usage_error,
-                   heif_suberror_Nonexisting_image_channel_referenced);
-
-    }
-
-    ImagePlane& plane = plane_iter->second;
-
-    if (plane.m_bit_depth != 8) {
-      return Error(heif_error_Unsupported_feature,
-                   heif_suberror_Unspecified,
-                   "Can currently only fill images with 8 bits per pixel");
-    }
-
-    int h = plane.m_height;
-
-    int stride = plane.stride;
-    uint8_t* data = plane.mem;
-
-    uint16_t val16;
-    switch (channel) {
-      case heif_channel_R:
-        val16 = r;
-        break;
-      case heif_channel_G:
-        val16 = g;
-        break;
-      case heif_channel_B:
-        val16 = b;
-        break;
-      case heif_channel_Alpha:
-        val16 = a;
-        break;
-      default:
-        // initialization only to avoid warning of uninitalized variable.
-        val16 = 0;
-        // Should already be detected by the check above ("m_planes.find").
-        assert(false);
-    }
-
-    auto val8 = static_cast<uint8_t>(val16 >> 8U);
-
-    memset(data, val8, stride * h);
-  }
-
-  return Error::Ok;
-}
-
-
-Error HeifPixelImage::overlay(std::shared_ptr<HeifPixelImage>& overlay, int dx, int dy)
-{
-  std::set<enum heif_channel> channels = overlay->get_channel_set();
-
-  bool has_alpha = overlay->has_channel(heif_channel_Alpha);
-  //bool has_alpha_me = has_channel(heif_channel_Alpha);
-
-  int alpha_stride = 0;
-  uint8_t* alpha_p;
-  alpha_p = overlay->get_plane(heif_channel_Alpha, &alpha_stride);
-
-  for (heif_channel channel : channels) {
-    if (!has_channel(channel)) {
-      continue;
-    }
-
-    int in_stride = 0;
-    const uint8_t* in_p;
-
-    int out_stride = 0;
-    uint8_t* out_p;
-
-    in_p = overlay->get_plane(channel, &in_stride);
-    out_p = get_plane(channel, &out_stride);
-
-    int in_w = overlay->get_width(channel);
-    int in_h = overlay->get_height(channel);
-    assert(in_w >= 0);
-    assert(in_h >= 0);
-
-    int out_w = get_width(channel);
-    int out_h = get_height(channel);
-    assert(out_w >= 0);
-    assert(out_h >= 0);
-
-    // overlay image extends past the right border -> cut width for copy
-    if (dx + in_w > out_w) {
-      in_w = out_w - dx;
-    }
-
-    // overlay image extends past the bottom border -> cut height for copy
-    if (dy + in_h > out_h) {
-      in_h = out_h - dy;
-    }
-
-    // overlay image completely outside right or bottom border -> do not copy
-    if (in_w < 0 || in_h < 0) {
-      return Error(heif_error_Invalid_input,
-                   heif_suberror_Overlay_image_outside_of_canvas,
-                   "Overlay image outside of right or bottom canvas border");
-    }
-
-
-    // calculate top-left point where to start copying in source and destination
-    int in_x0 = 0;
-    int in_y0 = 0;
-    int out_x0 = dx;
-    int out_y0 = dy;
-
-    // overlay image started outside of left border
-    // -> move start into the image and start at left output column
-    if (dx < 0) {
-      in_x0 = -dx;
-      out_x0 = 0;
-    }
-
-    // overlay image started outside of top border
-    // -> move start into the image and start at top output row
-    if (dy < 0) {
-      in_y0 = -dy;
-      out_y0 = 0;
-    }
-
-    // if overlay image is completely outside at left border, do not copy anything.
-    if (in_w <= in_x0 ||
-        in_h <= in_y0) {
-      return Error(heif_error_Invalid_input,
-                   heif_suberror_Overlay_image_outside_of_canvas,
-                   "Overlay image outside of left or top canvas border");
-    }
-
-    for (int y = in_y0; y < in_h; y++) {
-      if (!has_alpha) {
-        memcpy(out_p + out_x0 + (out_y0 + y - in_y0) * out_stride,
-               in_p + in_x0 + y * in_stride,
-               in_w - in_x0);
-      }
-      else {
-        for (int x = in_x0; x < in_w; x++) {
-          uint8_t* outptr = &out_p[out_x0 + (out_y0 + y - in_y0) * out_stride + x];
-          uint8_t in_val = in_p[in_x0 + y * in_stride + x];
-          uint8_t alpha_val = alpha_p[in_x0 + y * in_stride + x];
-
-          *outptr = (uint8_t) ((in_val * alpha_val + *outptr * (255 - alpha_val)) / 255);
-        }
-      }
-    }
-  }
-
-  return Error::Ok;
-}
-
-
-Error HeifPixelImage::scale_nearest_neighbor(std::shared_ptr<HeifPixelImage>& out_img,
-                                             int width, int height) const
-{
-  out_img = std::make_shared<HeifPixelImage>();
-  out_img->create(width, height, m_colorspace, m_chroma);
-
-
-  // --- create output image with scaled planes
-
-  if (has_channel(heif_channel_interleaved)) {
-    out_img->add_plane(heif_channel_interleaved, width, height, get_bits_per_pixel(heif_channel_interleaved));
-  }
-  else {
-    if (get_colorspace() == heif_colorspace_RGB) {
-      if (!has_channel(heif_channel_R) ||
-          !has_channel(heif_channel_G) ||
-          !has_channel(heif_channel_B)) {
-        return Error(heif_error_Invalid_input, heif_suberror_Unspecified, "RGB input without R,G,B, planes");
-      }
-
-      out_img->add_plane(heif_channel_R, width, height, get_bits_per_pixel(heif_channel_R));
-      out_img->add_plane(heif_channel_G, width, height, get_bits_per_pixel(heif_channel_G));
-      out_img->add_plane(heif_channel_B, width, height, get_bits_per_pixel(heif_channel_B));
-    }
-    else if (get_colorspace() == heif_colorspace_monochrome) {
-      if (!has_channel(heif_channel_Y)) {
-        return Error(heif_error_Invalid_input, heif_suberror_Unspecified, "monochrome input with no Y plane");
-      }
-
-      out_img->add_plane(heif_channel_Y, width, height, get_bits_per_pixel(heif_channel_Y));
-    }
-    else if (get_colorspace() == heif_colorspace_YCbCr) {
-      if (!has_channel(heif_channel_Y) ||
-          !has_channel(heif_channel_Cb) ||
-          !has_channel(heif_channel_Cr)) {
-        return Error(heif_error_Invalid_input, heif_suberror_Unspecified, "YCbCr image without Y,Cb,Cr planes");
-      }
-
-      int cw, ch;
-      get_subsampled_size(width, height, heif_channel_Cb, get_chroma_format(), &cw, &ch);
-      out_img->add_plane(heif_channel_Y, width, height, get_bits_per_pixel(heif_channel_Y));
-      out_img->add_plane(heif_channel_Cb, cw, ch, get_bits_per_pixel(heif_channel_Cb));
-      out_img->add_plane(heif_channel_Cr, cw, ch, get_bits_per_pixel(heif_channel_Cr));
-    }
-    else {
-      return Error(heif_error_Invalid_input, heif_suberror_Unspecified, "unknown color configuration");
-    }
-
-    if (has_channel(heif_channel_Alpha)) {
-      out_img->add_plane(heif_channel_Alpha, width,height, get_bits_per_pixel(heif_channel_Alpha));
-    }
-  }
-
-
-  // --- scale all channels
-
-  for (const auto& plane_pair : m_planes) {
-    heif_channel channel = plane_pair.first;
-    const ImagePlane& plane = plane_pair.second;
-
-    const int bpp = get_storage_bits_per_pixel(channel) / 8;
-
-    if (!out_img->has_channel(channel)) {
-      return Error(heif_error_Invalid_input, heif_suberror_Unspecified, "scaling input has extra color plane");
-    }
-
-    int out_w = out_img->get_width(channel);
-    int out_h = out_img->get_height(channel);
-
-    int in_stride = plane.stride;
-    const uint8_t* in_data = plane.mem;
-
-    int out_stride = 0;
-    uint8_t* out_data = out_img->get_plane(channel, &out_stride);
-
-
-    for (int y = 0; y < out_h; y++) {
-      int iy = y * m_height / height;
-
-      if (bpp == 1) {
-        for (int x = 0; x < out_w; x++) {
-          int ix = x * m_width / width;
-
-          out_data[y * out_stride + x] = in_data[iy * in_stride + ix];
-        }
-      }
-      else {
-        for (int x = 0; x < out_w; x++) {
-          int ix = x * m_width / width;
-
-          for (int b = 0; b < bpp; b++) {
-            out_data[y * out_stride + bpp * x + b] = in_data[iy * in_stride + bpp * ix + b];
-          }
-        }
-      }
-    }
-  }
-
-  return Error::Ok;
-}
-
-
-void HeifPixelImage::debug_dump() const
-{
-  auto channels = get_channel_set();
-  for (auto c : channels) {
-    int stride = 0;
-    const uint8_t* p = get_plane(c, &stride);
-
-    for (int y = 0; y < 8; y++) {
-      for (int x = 0; x < 8; x++) {
-        printf("%02x ", p[y * stride + x]);
-      }
-      printf("\n");
-    }
-  }
-}
diff --git a/libheif/heif_image.h b/libheif/heif_image.h
deleted file mode 100644
index e0febb59dd..0000000000
--- a/libheif/heif_image.h
+++ /dev/null
@@ -1,169 +0,0 @@
-/*
- * HEIF codec.
- * Copyright (c) 2017 struktur AG, Dirk Farin <farin@struktur.de>
- *
- * This file is part of libheif.
- *
- * libheif is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as
- * published by the Free Software Foundation, either version 3 of
- * the License, or (at your option) any later version.
- *
- * libheif is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef LIBHEIF_HEIF_IMAGE_H
-#define LIBHEIF_HEIF_IMAGE_H
-
-#include "heif.h"
-#include "error.h"
-#include "box.h" // only for color_profile, TODO: maybe move the color_profiles to its own header
-
-#include <vector>
-#include <memory>
-#include <map>
-#include <set>
-
-
-namespace heif {
-
-  uint8_t chroma_h_subsampling(heif_chroma c);
-
-  uint8_t chroma_v_subsampling(heif_chroma c);
-
-  heif_chroma chroma_from_subsampling(int h, int v);
-
-  void get_subsampled_size(int width, int height,
-                           heif_channel channel,
-                           heif_chroma chroma,
-                           int* subsampled_width, int* subsampled_height);
-
-  bool is_chroma_with_alpha(heif_chroma chroma);
-
-  int num_interleaved_pixels_per_plane(heif_chroma chroma);
-
-  bool is_integer_multiple_of_chroma_size(int width,
-                                          int height,
-                                          heif_chroma chroma);
-
-
-  class HeifPixelImage : public std::enable_shared_from_this<HeifPixelImage>,
-                         public ErrorBuffer
-  {
-  public:
-    explicit HeifPixelImage() = default;
-
-    ~HeifPixelImage();
-
-    void create(int width, int height, heif_colorspace colorspace, heif_chroma chroma);
-
-    bool add_plane(heif_channel channel, int width, int height, int bit_depth);
-
-    bool has_channel(heif_channel channel) const;
-
-    // Has alpha information either as a separate channel or in the interleaved format.
-    bool has_alpha() const;
-
-    bool is_premultiplied_alpha() const { return m_premultiplied_alpha; }
-
-    void set_premultiplied_alpha(bool flag) { m_premultiplied_alpha = flag; }
-
-    int get_width() const { return m_width; }
-
-    int get_height() const { return m_height; }
-
-    int get_width(enum heif_channel channel) const;
-
-    int get_height(enum heif_channel channel) const;
-
-    heif_chroma get_chroma_format() const { return m_chroma; }
-
-    heif_colorspace get_colorspace() const { return m_colorspace; }
-
-    std::set<enum heif_channel> get_channel_set() const;
-
-    uint8_t get_storage_bits_per_pixel(enum heif_channel channel) const;
-
-    uint8_t get_bits_per_pixel(enum heif_channel channel) const;
-
-    uint8_t* get_plane(enum heif_channel channel, int* out_stride);
-
-    const uint8_t* get_plane(enum heif_channel channel, int* out_stride) const;
-
-    void copy_new_plane_from(const std::shared_ptr<const HeifPixelImage>& src_image,
-                             heif_channel src_channel,
-                             heif_channel dst_channel);
-
-    void fill_new_plane(heif_channel dst_channel, uint16_t value, int width, int height, int bpp);
-
-    void transfer_plane_from_image_as(const std::shared_ptr<HeifPixelImage>& source,
-                                      heif_channel src_channel,
-                                      heif_channel dst_channel);
-
-    Error rotate_ccw(int angle_degrees,
-                     std::shared_ptr<HeifPixelImage>& out_img);
-
-    Error mirror_inplace(bool horizontal);
-
-    Error crop(int left, int right, int top, int bottom,
-               std::shared_ptr<HeifPixelImage>& out_img) const;
-
-    Error fill_RGB_16bit(uint16_t r, uint16_t g, uint16_t b, uint16_t a);
-
-    Error overlay(std::shared_ptr<HeifPixelImage>& overlay, int dx, int dy);
-
-    Error scale_nearest_neighbor(std::shared_ptr<HeifPixelImage>& output, int width, int height) const;
-
-    void set_color_profile_nclx(std::shared_ptr<const color_profile_nclx> profile) { m_color_profile_nclx = profile; }
-
-    std::shared_ptr<const color_profile_nclx> get_color_profile_nclx() const { return m_color_profile_nclx; }
-
-    void set_color_profile_icc(std::shared_ptr<const color_profile_raw> profile) { m_color_profile_icc = profile; }
-
-    std::shared_ptr<const color_profile_raw> get_color_profile_icc() const { return m_color_profile_icc; }
-
-    void debug_dump() const;
-
-    bool extend_padding_to_size(int width, int height);
-
-  private:
-    struct ImagePlane
-    {
-      bool alloc(int width, int height, int bit_depth, heif_chroma chroma);
-
-      uint8_t m_bit_depth = 0;
-
-      // the "visible" area of the plane
-      int m_width = 0;
-      int m_height = 0;
-
-      // the allocated memory size
-      int m_mem_width = 0;
-      int m_mem_height = 0;
-
-      uint8_t* mem = nullptr; // aligned memory start
-      uint8_t* allocated_mem = nullptr; // unaligned memory we allocated
-      uint32_t stride = 0; // bytes per line
-    };
-
-    int m_width = 0;
-    int m_height = 0;
-    heif_colorspace m_colorspace = heif_colorspace_undefined;
-    heif_chroma m_chroma = heif_chroma_undefined;
-    bool m_premultiplied_alpha = false;
-    std::shared_ptr<const color_profile_nclx> m_color_profile_nclx;
-    std::shared_ptr<const color_profile_raw> m_color_profile_icc;
-
-    std::map<heif_channel, ImagePlane> m_planes;
-  };
-
-}
-
-#endif
diff --git a/libheif/heif_limits.h b/libheif/heif_limits.h
deleted file mode 100644
index 57bd74f4a9..0000000000
--- a/libheif/heif_limits.h
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * HEIF codec.
- * Copyright (c) 2018 struktur AG, Dirk Farin <farin@struktur.de>
- *
- * This file is part of libheif.
- *
- * libheif is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as
- * published by the Free Software Foundation, either version 3 of
- * the License, or (at your option) any later version.
- *
- * libheif is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
- */
-#ifndef LIBHEIF_HEIF_LIMITS_H
-#define LIBHEIF_HEIF_LIMITS_H
-
-#if defined(HAVE_CONFIG_H)
-#include "config.h"
-#endif
-
-#include <cinttypes>
-#include <cstddef>
-
-static const size_t MAX_CHILDREN_PER_BOX = 20000;
-static const int MAX_ILOC_ITEMS = 20000;
-static const int MAX_ILOC_EXTENTS_PER_ITEM = 32;
-static const int MAX_MEMORY_BLOCK_SIZE = 512 * 1024 * 1024; // 512 MB
-
-// Artificial limit to avoid allocating too much memory.
-// 32768^2 = 1.5 GB as YUV-4:2:0 or 4 GB as RGB32
-static const int MAX_IMAGE_WIDTH = 32768;
-static const int MAX_IMAGE_HEIGHT = 32768;
-
-// Maximum nesting level of boxes in input files.
-// We put a limit on this to avoid unlimited stack usage by malicious input files.
-static const int MAX_BOX_NESTING_LEVEL = 20;
-
-static const int MAX_BOX_SIZE = 0x7FFFFFFF; // 2 GB
-static const int64_t MAX_LARGE_BOX_SIZE = 0x0FFFFFFFFFFFFFFF;
-static const int64_t MAX_FILE_POS = 0x007FFFFFFFFFFFFFLL; // maximum file position
-static const int MAX_FRACTION_VALUE = 0x10000;
-
-#endif  // LIBHEIF_HEIF_LIMITS_H
diff --git a/libheif/heif_plugin_registry.cc b/libheif/heif_plugin_registry.cc
deleted file mode 100644
index 15a7cf7c9e..0000000000
--- a/libheif/heif_plugin_registry.cc
+++ /dev/null
@@ -1,178 +0,0 @@
-/*
- * HEIF codec.
- * Copyright (c) 2017 struktur AG, Dirk Farin <farin@struktur.de>
- *
- * This file is part of libheif.
- *
- * libheif is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as
- * published by the Free Software Foundation, either version 3 of
- * the License, or (at your option) any later version.
- *
- * libheif is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#if defined(HAVE_CONFIG_H)
-#include "config.h"
-#endif
-
-#include <utility>
-#include <cstring>
-
-#include "heif_plugin_registry.h"
-
-#if HAVE_LIBDE265
-#include "heif_decoder_libde265.h"
-#endif
-
-#if HAVE_X265
-#include "heif_encoder_x265.h"
-#endif
-
-#if HAVE_AOM_ENCODER
-#include "heif_encoder_aom.h"
-#endif
-
-#if HAVE_AOM_DECODER
-#include "heif_decoder_aom.h"
-#endif
-
-#if HAVE_RAV1E
-#include "heif_encoder_rav1e.h"
-#endif
-
-#if HAVE_DAV1D
-#include "heif_decoder_dav1d.h"
-#endif
-
-
-using namespace heif;
-
-
-std::set<const struct heif_decoder_plugin*> heif::s_decoder_plugins;
-
-
-struct encoder_descriptor_priority_order
-{
-  bool operator()(const std::unique_ptr<struct heif_encoder_descriptor>& a,
-                  const std::unique_ptr<struct heif_encoder_descriptor>& b) const
-  {
-    return a->plugin->priority > b->plugin->priority;  // highest priority first
-  }
-};
-
-
-std::set<std::unique_ptr<struct heif_encoder_descriptor>,
-         encoder_descriptor_priority_order> s_encoder_descriptors;
-
-
-static class Register_Default_Plugins
-{
-public:
-  Register_Default_Plugins()
-  {
-#if HAVE_LIBDE265
-    heif::register_decoder(get_decoder_plugin_libde265());
-#endif
-
-#if HAVE_X265
-    heif::register_encoder(get_encoder_plugin_x265());
-#endif
-
-#if HAVE_AOM_ENCODER
-    heif::register_encoder(get_encoder_plugin_aom());
-#endif
-
-#if HAVE_AOM_DECODER
-    heif::register_decoder(get_decoder_plugin_aom());
-#endif
-
-#if HAVE_RAV1E
-    heif::register_encoder(get_encoder_plugin_rav1e());
-#endif
-
-#if HAVE_DAV1D
-    heif::register_decoder(get_decoder_plugin_dav1d());
-#endif
-  }
-} dummy;
-
-
-void heif::register_decoder(const heif_decoder_plugin* decoder_plugin)
-{
-  if (decoder_plugin->init_plugin) {
-    (*decoder_plugin->init_plugin)();
-  }
-
-  s_decoder_plugins.insert(decoder_plugin);
-}
-
-
-const struct heif_decoder_plugin* heif::get_decoder(enum heif_compression_format type)
-{
-  int highest_priority = 0;
-  const struct heif_decoder_plugin* best_plugin = nullptr;
-
-  for (const auto* plugin : s_decoder_plugins) {
-    int priority = plugin->does_support_format(type);
-    if (priority > highest_priority) {
-      highest_priority = priority;
-      best_plugin = plugin;
-    }
-  }
-
-  return best_plugin;
-}
-
-void heif::register_encoder(const heif_encoder_plugin* encoder_plugin)
-{
-  if (encoder_plugin->init_plugin) {
-    (*encoder_plugin->init_plugin)();
-  }
-
-  auto descriptor = std::unique_ptr<struct heif_encoder_descriptor>(new heif_encoder_descriptor);
-  descriptor->plugin = encoder_plugin;
-
-  s_encoder_descriptors.insert(std::move(descriptor));
-}
-
-
-const struct heif_encoder_plugin* heif::get_encoder(enum heif_compression_format type)
-{
-  auto filtered_encoder_descriptors = get_filtered_encoder_descriptors(type, nullptr);
-  if (filtered_encoder_descriptors.size() > 0) {
-    return filtered_encoder_descriptors[0]->plugin;
-  }
-  else {
-    return nullptr;
-  }
-}
-
-
-std::vector<const struct heif_encoder_descriptor*>
-heif::get_filtered_encoder_descriptors(enum heif_compression_format format,
-                                       const char* name)
-{
-  std::vector<const struct heif_encoder_descriptor*> filtered_descriptors;
-
-  for (const auto& descr : s_encoder_descriptors) {
-    const struct heif_encoder_plugin* plugin = descr->plugin;
-
-    if (plugin->compression_format == format || format == heif_compression_undefined) {
-      if (name == nullptr || strcmp(name, plugin->id_name) == 0) {
-        filtered_descriptors.push_back(descr.get());
-      }
-    }
-  }
-
-
-  // Note: since our std::set<> is ordered by priority, we do not have to sort our output
-
-  return filtered_descriptors;
-}
diff --git a/libheif/heif_plugin_registry.h b/libheif/heif_plugin_registry.h
deleted file mode 100644
index 6c70d49907..0000000000
--- a/libheif/heif_plugin_registry.h
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * HEIF codec.
- * Copyright (c) 2017 struktur AG, Dirk Farin <farin@struktur.de>
- *
- * This file is part of libheif.
- *
- * libheif is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as
- * published by the Free Software Foundation, either version 3 of
- * the License, or (at your option) any later version.
- *
- * libheif is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef LIBHEIF_HEIF_PLUGIN_REGISTRY_H
-#define LIBHEIF_HEIF_PLUGIN_REGISTRY_H
-
-#include <map>
-#include <memory>
-#include <set>
-#include <string>
-#include <vector>
-
-#include "error.h"
-
-#include "heif.h"
-#include "heif_plugin.h"
-
-
-struct heif_encoder_descriptor
-{
-  const struct heif_encoder_plugin* plugin;
-
-  const char* get_name() const
-  { return plugin->get_plugin_name(); }
-
-  enum heif_compression_format get_compression_format() const
-  { return plugin->compression_format; }
-};
-
-
-namespace heif {
-
-  extern std::set<const struct heif_decoder_plugin*> s_decoder_plugins;
-
-  void register_decoder(const heif_decoder_plugin* decoder_plugin);
-
-  void register_encoder(const heif_encoder_plugin* encoder_plugin);
-
-  const struct heif_decoder_plugin* get_decoder(enum heif_compression_format type);
-
-  const struct heif_encoder_plugin* get_encoder(enum heif_compression_format type);
-
-  std::vector<const struct heif_encoder_descriptor*>
-  get_filtered_encoder_descriptors(enum heif_compression_format,
-                                   const char* name);
-}
-
-#endif
diff --git a/libheif/id_creator.cc b/libheif/id_creator.cc
new file mode 100644
index 0000000000..38f532e84b
--- /dev/null
+++ b/libheif/id_creator.cc
@@ -0,0 +1,54 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2026 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "id_creator.h"
+
+Result<uint32_t> IDCreator::get_new_id(Namespace ns)
+{
+  if (m_unif) {
+    if (m_next_id_global == 0) {
+      return Error(heif_error_Usage_error,
+                   heif_suberror_Unspecified,
+                   "ID namespace overflow");
+    }
+    return m_next_id_global++;
+  }
+
+  uint32_t* counter = nullptr;
+  switch (ns) {
+    case Namespace::item:
+      counter = &m_next_id_item;
+      break;
+    case Namespace::track:
+      counter = &m_next_id_track;
+      break;
+    case Namespace::entity_group:
+      counter = &m_next_id_entity_group;
+      break;
+  }
+
+  if (*counter == 0) {
+    return Error(heif_error_Usage_error,
+                 heif_suberror_Unspecified,
+                 "ID namespace overflow");
+  }
+
+  return (*counter)++;
+}
diff --git a/libheif/id_creator.h b/libheif/id_creator.h
new file mode 100644
index 0000000000..fff8c97e27
--- /dev/null
+++ b/libheif/id_creator.h
@@ -0,0 +1,50 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2026 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_ID_CREATOR_H
+#define LIBHEIF_ID_CREATOR_H
+
+#include "error.h"
+#include <cstdint>
+
+class IDCreator
+{
+public:
+  enum class Namespace { item, track, entity_group };
+
+  void set_unif(bool flag) { m_unif = flag; }
+
+  bool get_unif() const { return m_unif; }
+
+  // Returns a new unique ID for the given namespace.
+  // In non-unif mode: separate counters per namespace.
+  // In unif mode: single global counter shared across all namespaces.
+  // Returns error on overflow (counter would exceed 0xFFFFFFFF).
+  Result<uint32_t> get_new_id(Namespace ns);
+
+private:
+  bool m_unif = false;
+  uint32_t m_next_id_item = 1;
+  uint32_t m_next_id_track = 1;
+  uint32_t m_next_id_entity_group = 1;
+  uint32_t m_next_id_global = 1;  // used in unif mode
+};
+
+#endif
diff --git a/libheif/image-items/avc.cc b/libheif/image-items/avc.cc
new file mode 100644
index 0000000000..88f1556142
--- /dev/null
+++ b/libheif/image-items/avc.cc
@@ -0,0 +1,76 @@
+/*
+ * HEIF AVC codec.
+ * Copyright (c) 2023 Brad Hards <bradh@frogmouth.net>
+ * Copyright (c) 2025 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "avc.h"
+#include "context.h"
+#include "codecs/avc_dec.h"
+#include "codecs/avc_boxes.h"
+#include <utility>
+
+#include "codecs/avc_enc.h"
+
+
+ImageItem_AVC::ImageItem_AVC(HeifContext* ctx, heif_item_id id)
+  : ImageItem(ctx, id)
+{
+  m_encoder = std::make_shared<Encoder_AVC>();
+}
+
+
+ImageItem_AVC::ImageItem_AVC(HeifContext* ctx)
+  : ImageItem(ctx)
+{
+  m_encoder = std::make_shared<Encoder_AVC>();
+}
+
+
+Result<std::shared_ptr<Decoder>> ImageItem_AVC::get_decoder() const
+{
+  return {m_decoder};
+}
+
+
+std::shared_ptr<Encoder> ImageItem_AVC::get_encoder() const
+{
+  return m_encoder;
+}
+
+
+Error ImageItem_AVC::initialize_decoder()
+{
+  auto avcC_box = get_property<Box_avcC>();
+  if (!avcC_box) {
+    return Error{heif_error_Invalid_input,
+                 heif_suberror_No_av1C_box};
+  }
+
+  m_decoder = std::make_shared<Decoder_AVC>(avcC_box);
+
+  return Error::Ok;
+}
+
+void ImageItem_AVC::set_decoder_input_data()
+{
+  DataExtent extent;
+  extent.set_from_image_item(get_context()->get_heif_file(), get_id());
+
+  m_decoder->set_data_extent(std::move(extent));
+}
diff --git a/libheif/image-items/avc.h b/libheif/image-items/avc.h
new file mode 100644
index 0000000000..ad03859508
--- /dev/null
+++ b/libheif/image-items/avc.h
@@ -0,0 +1,63 @@
+/*
+ * HEIF AVC codec.
+ * Copyright (c) 2023 Brad Hards <bradh@frogmouth.net>
+ * Copyright (c) 2025 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef HEIF_AVC_H
+#define HEIF_AVC_H
+
+#include "box.h"
+#include "error.h"
+#include <cstdint>
+#include <vector>
+#include <string>
+#include <memory>
+#include "image_item.h"
+
+
+class ImageItem_AVC : public ImageItem
+{
+public:
+  ImageItem_AVC(HeifContext* ctx, heif_item_id id);
+
+  ImageItem_AVC(HeifContext* ctx);
+
+  uint32_t get_infe_type() const override { return fourcc("avc1"); }
+
+  const char* get_auxC_alpha_channel_type() const override { return "urn:mpeg:mpegB:cicp:systems:auxiliary:alpha"; }
+
+  heif_compression_format get_compression_format() const override { return heif_compression_AVC; }
+
+  Error initialize_decoder() override;
+
+  void set_decoder_input_data() override;
+
+  heif_brand2 get_compatible_brand() const override { return heif_brand2_avci; }
+
+protected:
+  Result<std::shared_ptr<Decoder>> get_decoder() const override;
+
+  std::shared_ptr<Encoder> get_encoder() const override;
+
+public:
+  std::shared_ptr<class Decoder_AVC> m_decoder;
+  std::shared_ptr<class Encoder_AVC> m_encoder;
+};
+
+#endif
diff --git a/libheif/image-items/avif.cc b/libheif/image-items/avif.cc
new file mode 100644
index 0000000000..c2fb55cdb0
--- /dev/null
+++ b/libheif/image-items/avif.cc
@@ -0,0 +1,87 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "pixelimage.h"
+#include "avif.h"
+#include "codecs/avif_dec.h"
+#include "codecs/avif_enc.h"
+#include "codecs/avif_boxes.h"
+#include "bitstream.h"
+#include "common_utils.h"
+#include "api_structs.h"
+#include "file.h"
+#include <iomanip>
+#include <limits>
+#include <string>
+#include <cstring>
+#include <utility>
+
+// https://aomediacodec.github.io/av1-spec/av1-spec.pdf
+
+
+ImageItem_AVIF::ImageItem_AVIF(HeifContext* ctx, heif_item_id id) : ImageItem(ctx, id)
+{
+  m_encoder = std::make_shared<Encoder_AVIF>();
+}
+
+ImageItem_AVIF::ImageItem_AVIF(HeifContext* ctx) : ImageItem(ctx)
+{
+  m_encoder = std::make_shared<Encoder_AVIF>();
+}
+
+
+Error ImageItem_AVIF::initialize_decoder()
+{
+  auto av1C_box = get_property<Box_av1C>();
+  if (!av1C_box) {
+    return Error{heif_error_Invalid_input,
+                 heif_suberror_No_av1C_box};
+  }
+
+  m_decoder = std::make_shared<Decoder_AVIF>(av1C_box);
+
+  return Error::Ok;
+}
+
+void ImageItem_AVIF::set_decoder_input_data()
+{
+  DataExtent extent;
+  extent.set_from_image_item(get_context()->get_heif_file(), get_id());
+
+  m_decoder->set_data_extent(std::move(extent));
+}
+
+
+Result<std::vector<uint8_t>> ImageItem_AVIF::read_bitstream_configuration_data() const
+{
+  return m_decoder->read_bitstream_configuration_data();
+}
+
+
+Result<std::shared_ptr<Decoder>> ImageItem_AVIF::get_decoder() const
+{
+  return {m_decoder};
+}
+
+
+std::shared_ptr<Encoder> ImageItem_AVIF::get_encoder() const
+{
+  return m_encoder;
+}
diff --git a/libheif/image-items/avif.h b/libheif/image-items/avif.h
new file mode 100644
index 0000000000..89e9fec68e
--- /dev/null
+++ b/libheif/image-items/avif.h
@@ -0,0 +1,68 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef HEIF_AVIF_H
+#define HEIF_AVIF_H
+
+#include <cassert>
+#include <cmath>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "libheif/heif.h"
+#include "box.h"
+#include "error.h"
+#include "image_item.h"
+
+
+class ImageItem_AVIF : public ImageItem
+{
+public:
+  ImageItem_AVIF(HeifContext* ctx, heif_item_id id);
+
+  ImageItem_AVIF(HeifContext* ctx);
+
+  uint32_t get_infe_type() const override { return fourcc("av01"); }
+
+  const char* get_auxC_alpha_channel_type() const override { return "urn:mpeg:mpegB:cicp:systems:auxiliary:alpha"; }
+
+  heif_compression_format get_compression_format() const override { return heif_compression_AV1; }
+
+  heif_brand2 get_compatible_brand() const override { return heif_brand2_avif; }
+
+  Error initialize_decoder() override;
+
+  void set_decoder_input_data() override;
+
+protected:
+  Result<std::vector<uint8_t>> read_bitstream_configuration_data() const override;
+
+  Result<std::shared_ptr<Decoder>> get_decoder() const override;
+
+  std::shared_ptr<Encoder> get_encoder() const override;
+
+private:
+  std::shared_ptr<class Decoder_AVIF> m_decoder;
+
+  std::shared_ptr<class Encoder_AVIF> m_encoder;
+};
+
+#endif
diff --git a/libheif/image-items/grid.cc b/libheif/image-items/grid.cc
new file mode 100644
index 0000000000..937d04afa2
--- /dev/null
+++ b/libheif/image-items/grid.cc
@@ -0,0 +1,922 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "grid.h"
+#include "context.h"
+#include "file.h"
+#include <cstring>
+#include <deque>
+#include <future>
+#include <mutex>
+#include <set>
+#include <algorithm>
+#include "api_structs.h"
+#include "security_limits.h"
+
+
+Error ImageGrid::parse(const std::vector<uint8_t>& data)
+{
+  if (data.size() < 8) {
+    return {heif_error_Invalid_input,
+            heif_suberror_Invalid_grid_data,
+            "Less than 8 bytes of data"};
+  }
+
+  uint8_t version = data[0];
+  if (version != 0) {
+    std::stringstream sstr;
+    sstr << "Grid image version " << ((int) version) << " is not supported";
+    return {heif_error_Unsupported_feature,
+            heif_suberror_Unsupported_data_version,
+            sstr.str()};
+  }
+
+  uint8_t flags = data[1];
+  int field_size = ((flags & 1) ? 32 : 16);
+
+  m_rows = static_cast<uint16_t>(data[2] + 1);
+  m_columns = static_cast<uint16_t>(data[3] + 1);
+
+  if (field_size == 32) {
+    if (data.size() < 12) {
+      return {heif_error_Invalid_input,
+              heif_suberror_Invalid_grid_data,
+              "Grid image data incomplete"};
+    }
+
+    m_output_width = four_bytes_to_uint32(data[4], data[5], data[6], data[7]);
+    m_output_height = four_bytes_to_uint32(data[8], data[9], data[10], data[11]);
+  }
+  else {
+    m_output_width = two_bytes_to_uint16(data[4], data[5]);
+    m_output_height = two_bytes_to_uint16(data[6], data[7]);
+  }
+
+  return Error::Ok;
+}
+
+
+std::vector<uint8_t> ImageGrid::write() const
+{
+  int field_size;
+
+  if (m_output_width > 0xFFFF ||
+      m_output_height > 0xFFFF) {
+    field_size = 32;
+  }
+  else {
+    field_size = 16;
+  }
+
+  std::vector<uint8_t> data(field_size == 16 ? 8 : 12);
+
+  data[0] = 0; // version
+
+  uint8_t flags = 0;
+  if (field_size == 32) {
+    flags |= 1;
+  }
+
+  data[1] = flags;
+  data[2] = (uint8_t) (m_rows - 1);
+  data[3] = (uint8_t) (m_columns - 1);
+
+  if (field_size == 32) {
+    data[4] = (uint8_t) ((m_output_width >> 24) & 0xFF);
+    data[5] = (uint8_t) ((m_output_width >> 16) & 0xFF);
+    data[6] = (uint8_t) ((m_output_width >> 8) & 0xFF);
+    data[7] = (uint8_t) ((m_output_width) & 0xFF);
+
+    data[8] = (uint8_t) ((m_output_height >> 24) & 0xFF);
+    data[9] = (uint8_t) ((m_output_height >> 16) & 0xFF);
+    data[10] = (uint8_t) ((m_output_height >> 8) & 0xFF);
+    data[11] = (uint8_t) ((m_output_height) & 0xFF);
+  }
+  else {
+    data[4] = (uint8_t) ((m_output_width >> 8) & 0xFF);
+    data[5] = (uint8_t) ((m_output_width) & 0xFF);
+
+    data[6] = (uint8_t) ((m_output_height >> 8) & 0xFF);
+    data[7] = (uint8_t) ((m_output_height) & 0xFF);
+  }
+
+  return data;
+}
+
+
+std::string ImageGrid::dump() const
+{
+  std::ostringstream sstr;
+
+  sstr << "rows: " << m_rows << "\n"
+       << "columns: " << m_columns << "\n"
+       << "output width: " << m_output_width << "\n"
+       << "output height: " << m_output_height << "\n";
+
+  return sstr.str();
+}
+
+
+ImageItem_Grid::ImageItem_Grid(HeifContext* ctx)
+    : ImageItem(ctx)
+{
+  m_tile_encoding_options = heif_encoding_options_alloc();
+}
+
+
+ImageItem_Grid::ImageItem_Grid(HeifContext* ctx, heif_item_id id)
+    : ImageItem(ctx, id)
+{
+  m_tile_encoding_options = heif_encoding_options_alloc();
+}
+
+
+ImageItem_Grid::~ImageItem_Grid()
+{
+  heif_encoding_options_free(m_tile_encoding_options);
+}
+
+
+Error ImageItem_Grid::initialize_decoder()
+{
+  Error err = read_grid_spec();
+  if (err) {
+    return err;
+  }
+
+  return Error::Ok;
+}
+
+
+Error ImageItem_Grid::read_grid_spec()
+{
+  auto heif_file = get_context()->get_heif_file();
+
+  auto gridDataResult = heif_file->get_uncompressed_item_data(get_id());
+  if (!gridDataResult) {
+    return gridDataResult.error();
+  }
+
+  Error err = m_grid_spec.parse(*gridDataResult);
+  if (err) {
+    return err;
+  }
+
+  //std::cout << grid.dump();
+
+
+  auto iref_box = heif_file->get_iref_box();
+
+  if (!iref_box) {
+    return {heif_error_Invalid_input,
+            heif_suberror_No_iref_box,
+            "No iref box available, but needed for grid image"};
+  }
+
+  m_grid_tile_ids = iref_box->get_references(get_id(), fourcc("dimg"));
+
+  if ((int) m_grid_tile_ids.size() != m_grid_spec.get_rows() * m_grid_spec.get_columns()) {
+    std::stringstream sstr;
+    sstr << "Tiled image with " << m_grid_spec.get_rows() << "x" << m_grid_spec.get_columns() << "="
+         << (m_grid_spec.get_rows() * m_grid_spec.get_columns()) << " tiles, but only "
+         << m_grid_tile_ids.size() << " tile images in file";
+
+    return {heif_error_Invalid_input,
+            heif_suberror_Missing_grid_images,
+            sstr.str()};
+  }
+
+  return Error::Ok;
+}
+
+
+Result<std::shared_ptr<HeifPixelImage>> ImageItem_Grid::decode_compressed_image(const heif_decoding_options& options,
+                                                                                bool decode_tile_only, uint32_t tile_x0, uint32_t tile_y0,
+                                                                                std::set<heif_item_id> processed_ids) const
+{
+  if (processed_ids.contains(get_id())) {
+    return Error{heif_error_Invalid_input,
+                 heif_suberror_Unspecified,
+                 "'iref' has cyclic references"};
+  }
+
+  processed_ids.insert(get_id());
+
+
+  if (decode_tile_only) {
+    return decode_grid_tile(options, tile_x0, tile_y0, processed_ids);
+  }
+  else {
+    return decode_full_grid_image(options, processed_ids);
+  }
+}
+
+#if ENABLE_PARALLEL_TILE_DECODING
+static void wait_for_jobs(std::deque<std::future<Error> >* jobs) {
+  if (jobs->empty()) {
+    return;
+  }
+
+  while (!jobs->empty()) {
+    jobs->front().get();
+    jobs->pop_front();
+  }
+}
+#endif
+
+Result<std::shared_ptr<HeifPixelImage>> ImageItem_Grid::decode_full_grid_image(const heif_decoding_options& options, std::set<heif_item_id> processed_ids) const
+{
+  std::shared_ptr<HeifPixelImage> img; // the decoded image
+
+  const ImageGrid& grid = get_grid_spec();
+
+
+  // --- check that all image IDs are valid images
+
+  const std::vector<heif_item_id>& image_references = get_grid_tiles();
+
+  for (heif_item_id tile_id : image_references) {
+    if (!get_context()->is_image(tile_id)) {
+      std::stringstream sstr;
+      sstr << "Tile image ID=" << tile_id << " is not a proper image.";
+
+      return Error(heif_error_Invalid_input,
+                   heif_suberror_Missing_grid_images,
+                   sstr.str());
+    }
+  }
+
+  //auto pixi = get_file()->get_property<Box_pixi>(get_id());
+
+  const uint32_t w = grid.get_width();
+  const uint32_t h = grid.get_height();
+
+  Error err = check_for_valid_image_size(get_context()->get_security_limits(), w, h);
+  if (err) {
+    return err;
+  }
+
+  uint32_t y0 = 0;
+  int reference_idx = 0;
+
+#if ENABLE_PARALLEL_TILE_DECODING
+  // remember which tile to put where into the image
+  struct tile_data
+  {
+    heif_item_id tileID;
+    uint32_t x_origin, y_origin;
+  };
+
+  std::deque<tile_data> tiles;
+  if (get_context()->get_max_decoding_threads() > 0)
+    tiles.resize(static_cast<size_t>(grid.get_rows()) * static_cast<size_t>(grid.get_columns()));
+
+  std::deque<std::future<Error> > errs;
+#endif
+
+  uint32_t tile_width = 0;
+  uint32_t tile_height = 0;
+
+  if (options.start_progress) {
+    options.start_progress(heif_progress_step_total, grid.get_rows() * grid.get_columns(), options.progress_user_data);
+  }
+  if (options.on_progress) {
+    options.on_progress(heif_progress_step_total, 0, options.progress_user_data);
+  }
+
+  int progress_counter = 0;
+  bool cancelled = false;
+  std::shared_ptr<std::vector<Error> > warnings(new std::vector<Error>());
+  std::vector<FailedTile> failed_tiles;
+
+  for (uint32_t y = 0; y < grid.get_rows() && !cancelled; y++) {
+    uint32_t x0 = 0;
+
+    for (uint32_t x = 0; x < grid.get_columns() && !cancelled; x++) {
+
+      heif_item_id tileID = image_references[reference_idx];
+
+      std::shared_ptr<const ImageItem> tileImg = get_context()->get_image(tileID, true);
+      if (!tileImg) {
+        if (!options.strict_decoding && reference_idx != 0) {
+          // Skip missing tiles (unless it's the first one).
+          warnings->push_back(Error{
+            heif_error_Invalid_input,
+            heif_suberror_Missing_grid_images,
+          });
+          failed_tiles.push_back({x0, y0});
+          reference_idx++;
+          x0 += tile_width;
+          continue;
+        }
+
+        return Error{heif_error_Invalid_input,
+                     heif_suberror_Missing_grid_images,
+                     "Nonexistent grid image referenced"};
+      }
+      if (auto error = tileImg->get_item_error()) {
+        if (!options.strict_decoding && reference_idx != 0) {
+          // Skip missing tiles (unless it's the first one).
+          warnings->push_back(error);
+          failed_tiles.push_back({x0, y0});
+          reference_idx++;
+          x0 += tile_width;
+          continue;
+        }
+
+        return error;
+      }
+
+      uint32_t src_width = tileImg->get_width();
+      uint32_t src_height = tileImg->get_height();
+      err = check_for_valid_image_size(get_context()->get_security_limits(), src_width, src_height);
+      if (err) {
+        return err;
+      }
+
+      if (src_width < grid.get_width() / grid.get_columns() ||
+          src_height < grid.get_height() / grid.get_rows()) {
+        return Error{heif_error_Invalid_input,
+                     heif_suberror_Invalid_grid_data,
+                     "Grid tiles do not cover whole image"};
+      }
+
+      if (x == 0 && y == 0) {
+        // remember size of first tile and compare all other tiles against this
+        tile_width = src_width;
+        tile_height = src_height;
+      }
+      else if (src_width != tile_width || src_height != tile_height) {
+        return Error{heif_error_Invalid_input,
+                     heif_suberror_Invalid_grid_data,
+                     "Grid tiles have different sizes"};
+      }
+
+#if ENABLE_PARALLEL_TILE_DECODING
+      if (get_context()->get_max_decoding_threads() > 0)
+        tiles[x + y * grid.get_columns()] = tile_data{tileID, x0, y0};
+      else
+#else
+        if (1)
+#endif
+      {
+        if (options.cancel_decoding) {
+          if (options.cancel_decoding(options.progress_user_data)) {
+            cancelled = true;
+          }
+        }
+
+        err = decode_and_paste_tile_image(tileID, x0, y0, img, options, progress_counter, warnings, failed_tiles, processed_ids);
+        if (err) {
+          return err;
+        }
+      }
+
+      x0 += src_width;
+
+      reference_idx++;
+    }
+
+    y0 += tile_height;
+  }
+
+#if ENABLE_PARALLEL_TILE_DECODING
+  if (get_context()->get_max_decoding_threads() > 0) {
+    // Process all tiles in a set of background threads.
+    // Do not start more than the maximum number of threads.
+
+    while (!tiles.empty() && !cancelled) {
+
+      // If maximum number of threads running, wait until first thread finishes
+
+      if (errs.size() >= (size_t) get_context()->get_max_decoding_threads()) {
+        Error e = errs.front().get();
+        errs.pop_front();
+        if (e) {
+          wait_for_jobs(&errs);
+          return e;
+        }
+      }
+
+
+      if (options.cancel_decoding) {
+        if (options.cancel_decoding(options.progress_user_data)) {
+          cancelled = true;
+        }
+      }
+
+
+      // Start a new decoding thread
+
+      tile_data data = tiles.front();
+      tiles.pop_front();
+
+      errs.push_back(std::async(std::launch::async,
+                                &ImageItem_Grid::decode_and_paste_tile_image, this,
+                                data.tileID, data.x_origin, data.y_origin, std::ref(img), options,
+                                std::ref(progress_counter), warnings, std::ref(failed_tiles), processed_ids));
+    }
+
+    // check for decoding errors in remaining tiles
+
+    while (!errs.empty()) {
+      Error e = errs.front().get();
+      errs.pop_front();
+      if (e) {
+        wait_for_jobs(&errs);
+        return e;
+      }
+    }
+  }
+#endif
+
+  if (options.end_progress) {
+    options.end_progress(heif_progress_step_total, options.progress_user_data);
+  }
+
+  if (cancelled) {
+    return Error{heif_error_Canceled, heif_suberror_Unspecified, "Decoding the image was canceled"};
+  }
+
+  if (img) {
+    for (const auto& tile : failed_tiles) {
+      img->zero_region(tile.x0, tile.y0, tile_width, tile_height);
+    }
+    img->add_warnings(*warnings.get());
+  }
+
+  return img;
+}
+
+static Error progress_and_return_ok(const heif_decoding_options& options, int& progress_counter) {
+  if (options.on_progress) {
+#if ENABLE_PARALLEL_TILE_DECODING
+    static std::mutex progressMutex;
+    std::lock_guard<std::mutex> lock(progressMutex);
+#endif
+
+    options.on_progress(heif_progress_step_total, ++progress_counter, options.progress_user_data);
+  }
+  return Error::Ok;
+}
+
+Error ImageItem_Grid::decode_and_paste_tile_image(heif_item_id tileID, uint32_t x0, uint32_t y0,
+                                                  std::shared_ptr<HeifPixelImage>& inout_image,
+                                                  const heif_decoding_options& options,
+                                                  int& progress_counter,
+                                                  std::shared_ptr<std::vector<Error> > warnings,
+                                                  std::vector<FailedTile>& failed_tiles,
+                                                  std::set<heif_item_id> processed_ids) const
+{
+  std::shared_ptr<HeifPixelImage> tile_img;
+#if ENABLE_PARALLEL_TILE_DECODING
+  static std::mutex failedTilesMutex;
+#endif
+
+  auto tileItem = get_context()->get_image(tileID, true);
+  if (!tileItem && !options.strict_decoding) {
+    // We ignore missing images.
+#if ENABLE_PARALLEL_TILE_DECODING
+    std::lock_guard<std::mutex> lock(failedTilesMutex);
+#endif
+    warnings->emplace_back(
+      heif_error_Invalid_input,
+      heif_suberror_Missing_grid_images,
+      "Missing grid image"
+    );
+    failed_tiles.push_back({x0, y0});
+    return progress_and_return_ok(options, progress_counter);
+  }
+
+  assert(tileItem);
+  if (auto error = tileItem->get_item_error()) {
+    return error;
+  }
+
+  auto decodeResult = tileItem->decode_image(options, false, 0, 0, processed_ids);
+  if (!decodeResult) {
+    if (!options.strict_decoding) {
+      // We ignore broken tiles.
+#if ENABLE_PARALLEL_TILE_DECODING
+      std::lock_guard<std::mutex> lock(failedTilesMutex);
+#endif
+      warnings->push_back(decodeResult.error());
+      failed_tiles.push_back({x0, y0});
+      return progress_and_return_ok(options, progress_counter);
+    }
+
+    return decodeResult.error();
+  }
+
+  tile_img = *decodeResult;
+
+  uint32_t w = get_grid_spec().get_width();
+  uint32_t h = get_grid_spec().get_height();
+
+  // --- generate the image canvas for combining all the tiles
+
+  if (!inout_image) { // this avoids that we normally have to lock a mutex
+#if ENABLE_PARALLEL_TILE_DECODING
+    static std::mutex createImageMutex;
+    std::lock_guard<std::mutex> lock(createImageMutex);
+#endif
+
+    if (!inout_image) {
+      auto grid_image = std::make_shared<HeifPixelImage>();
+      auto err = grid_image->create_clone_image_at_new_size(tile_img, w, h, get_context()->get_security_limits());
+      if (err) {
+        return err;
+      }
+
+      // Fill alpha plane with opaque in case not all tiles have alpha planes
+
+      if (grid_image->has_channel(heif_channel_Alpha)) {
+        uint16_t alpha_bpp = grid_image->get_bits_per_pixel(heif_channel_Alpha);
+        assert(alpha_bpp <= 16);
+
+        auto alpha_default_value = static_cast<uint16_t>((1UL << alpha_bpp) - 1UL);
+        grid_image->fill_plane(heif_channel_Alpha, alpha_default_value);
+      }
+
+      grid_image->forward_all_metadata_from(tile_img);
+
+      inout_image = grid_image; // We have to set this at the very end because of the unlocked check to `inout_image` above.
+    }
+  }
+
+  // --- copy tile into output image
+
+  heif_chroma chroma = inout_image->get_chroma_format();
+
+  if (chroma != tile_img->get_chroma_format()) {
+    return {heif_error_Invalid_input,
+            heif_suberror_Wrong_tile_image_chroma_format,
+            "Image tile has different chroma format than combined image"};
+  }
+
+
+  inout_image->copy_image_to(tile_img, x0, y0);
+
+  return progress_and_return_ok(options, progress_counter);
+}
+
+
+Result<std::shared_ptr<HeifPixelImage>> ImageItem_Grid::decode_grid_tile(const heif_decoding_options& options, uint32_t tx, uint32_t ty,
+                                                                         std::set<heif_item_id> processed_ids) const
+{
+  uint32_t idx = ty * m_grid_spec.get_columns() + tx;
+
+  assert(idx < m_grid_tile_ids.size());
+
+  heif_item_id tile_id = m_grid_tile_ids[idx];
+  std::shared_ptr<const ImageItem> tile_item = get_context()->get_image(tile_id, true);
+  if (auto error = tile_item->get_item_error()) {
+    return error;
+  }
+
+  return tile_item->decode_compressed_image(options, false, 0, 0, processed_ids);
+}
+
+
+void ImageItem_Grid::set_grid_tile_id(uint32_t tile_x, uint32_t tile_y, heif_item_id id)
+{
+  uint32_t idx = tile_y * m_grid_spec.get_columns() + tile_x;
+  m_grid_tile_ids[idx] = id;
+}
+
+
+heif_image_tiling ImageItem_Grid::get_heif_image_tiling() const
+{
+  heif_image_tiling tiling{};
+
+  const ImageGrid& gridspec = get_grid_spec();
+  tiling.num_columns = gridspec.get_columns();
+  tiling.num_rows = gridspec.get_rows();
+
+  tiling.image_width = gridspec.get_width();
+  tiling.image_height = gridspec.get_height();
+  tiling.number_of_extra_dimensions = 0;
+
+  auto tile_ids = get_grid_tiles();
+  if (!tile_ids.empty() && tile_ids[0] != 0) {
+    heif_item_id tile0_id = tile_ids[0];
+    auto tile0 = get_context()->get_image(tile0_id, true);
+    if (tile0 == nullptr || tile0->get_item_error()) {
+      return tiling;
+    }
+
+    tiling.tile_width = tile0->get_width();
+    tiling.tile_height = tile0->get_height();
+  }
+  else {
+    tiling.tile_width = 0;
+    tiling.tile_height = 0;
+  }
+
+  return tiling;
+}
+
+
+void ImageItem_Grid::get_tile_size(uint32_t& w, uint32_t& h) const
+{
+  heif_item_id first_tile_id = get_grid_tiles()[0];
+  auto tile = get_context()->get_image(first_tile_id, true);
+  if (tile->get_item_error()) {
+    w = h = 0;
+  }
+
+  w = tile->get_width();
+  h = tile->get_height();
+}
+
+
+
+int ImageItem_Grid::get_luma_bits_per_pixel() const
+{
+  heif_item_id child;
+  Error err = get_context()->get_id_of_non_virtual_child_image(get_id(), child);
+  if (err) {
+    return -1;
+  }
+
+  auto image = get_context()->get_image(child, true);
+  if (!image) {
+    return -1;
+  }
+
+  return image->get_luma_bits_per_pixel();
+}
+
+
+int ImageItem_Grid::get_chroma_bits_per_pixel() const
+{
+  heif_item_id child;
+  Error err = get_context()->get_id_of_non_virtual_child_image(get_id(), child);
+  if (err) {
+    return -1;
+  }
+
+  auto image = get_context()->get_image(child, true);
+  return image->get_chroma_bits_per_pixel();
+}
+
+Result<std::shared_ptr<Decoder>> ImageItem_Grid::get_decoder() const
+{
+  heif_item_id child;
+  Error err = get_context()->get_id_of_non_virtual_child_image(get_id(), child);
+  if (err) {
+    return {err};
+  }
+
+  auto image = get_context()->get_image(child, true);
+  if (!image) {
+    return Error{heif_error_Invalid_input,
+      heif_suberror_Nonexisting_item_referenced};
+  }
+  else if (auto err = image->get_item_error()) {
+    return err;
+  }
+
+  return image->get_decoder();
+}
+
+
+Result<std::shared_ptr<ImageItem_Grid>> ImageItem_Grid::add_new_grid_item(HeifContext* ctx,
+                                                                          uint32_t output_width,
+                                                                          uint32_t output_height,
+                                                                          uint16_t tile_rows,
+                                                                          uint16_t tile_columns,
+                                                                          const heif_encoding_options* encoding_options)
+{
+  std::shared_ptr<ImageItem_Grid> grid_image;
+  if (tile_rows > 0xFFFF / tile_columns) {
+    return Error{heif_error_Usage_error,
+                 heif_suberror_Unspecified,
+                 "Too many tiles (maximum: 65535)"};
+  }
+
+  // Create ImageGrid
+
+  ImageGrid grid;
+  grid.set_num_tiles(tile_columns, tile_rows);
+  grid.set_output_size(output_width, output_height); // TODO: MIAF restricts the output size to be a multiple of the chroma subsampling (7.3.11.4.2)
+  std::vector<uint8_t> grid_data = grid.write();
+
+  // Create Grid Item
+
+  std::shared_ptr<HeifFile> file = ctx->get_heif_file();
+  auto grid_id_result = file->add_new_image(fourcc("grid"));
+  if (!grid_id_result) {
+    return grid_id_result.error();
+  }
+  heif_item_id grid_id = *grid_id_result;
+  grid_image = std::make_shared<ImageItem_Grid>(ctx, grid_id);
+  grid_image->set_tile_encoding_options(encoding_options);
+  grid_image->set_grid_spec(grid);
+  grid_image->set_resolution(output_width, output_height);
+  grid_image->m_grid_orientation = encoding_options->image_orientation;
+
+  ctx->insert_image_item(grid_id, grid_image);
+  const int construction_method = 1; // 0=mdat 1=idat
+  file->append_iloc_data(grid_id, grid_data, construction_method);
+
+  // generate dummy grid item IDs (0)
+  std::vector<heif_item_id> tile_ids;
+  tile_ids.resize(static_cast<size_t>(tile_rows) * static_cast<size_t>(tile_columns));
+
+  // Connect tiles to grid
+  file->add_iref_reference(grid_id, fourcc("dimg"), tile_ids);
+
+  // Add ISPE property
+  file->add_ispe_property(grid_id, output_width, output_height, false);
+
+  // PIXI property will be added when the first tile is set
+
+  // Set Brands
+  //m_heif_file->set_brand(encoder->plugin->compression_format,
+  //                       grid_image->is_miaf_compatible());
+
+  return grid_image;
+}
+
+void ImageItem_Grid::set_tile_encoding_options(const heif_encoding_options* options)
+{
+  heif_encoding_options_copy(m_tile_encoding_options, options);
+
+  // do not propagate image transformation to tiles
+  m_tile_encoding_options->image_orientation = heif_orientation_normal;
+}
+
+
+Error ImageItem_Grid::add_image_tile(uint32_t tile_x, uint32_t tile_y,
+                                     const std::shared_ptr<HeifPixelImage>& image,
+                                     heif_encoder* encoder)
+{
+  auto encodingResult = get_context()->encode_image(image,
+                                            encoder,
+                                            *m_tile_encoding_options,
+                                            heif_image_input_class_normal);
+  if (!encodingResult) {
+    return encodingResult.error();
+  }
+
+  std::shared_ptr<ImageItem> encoded_image = *encodingResult;
+
+  auto file = get_file();
+  file->get_infe_box(encoded_image->get_id())->set_hidden_item(true); // grid tiles are hidden items
+
+  // Assign tile to grid
+  heif_image_tiling tiling = get_heif_image_tiling();
+  file->set_iref_reference(get_id(), fourcc("dimg"), tile_y * tiling.num_columns + tile_x, encoded_image->get_id());
+
+  set_grid_tile_id(tile_x, tile_y, encoded_image->get_id());
+
+  // Add PIXI property (copy from first tile)
+  auto pixi = encoded_image->get_property<Box_pixi>();
+  add_property(pixi, true);
+
+  // copy over extra properties to grid item
+
+  if (tile_x == 0 && tile_y == 0) {
+    auto property_boxes = encoded_image->generate_property_boxes(false);
+    for (auto& property : property_boxes) {
+      add_property(property, is_property_essential(property));
+    }
+
+    // add color profile similar to first tile image
+    // TODO: this shouldn't be necessary. The colr profiles should be in the ImageExtraData above.
+    auto colr_boxes = add_color_profile(image, *m_tile_encoding_options,
+                                        heif_image_input_class_normal,
+                                        m_tile_encoding_options->output_nclx_profile);
+    for (auto& property : colr_boxes) {
+      add_property(property, is_property_essential(property));
+    }
+
+    // Add transformative properties
+
+    get_context()->get_heif_file()->add_orientation_properties(get_id(), m_grid_orientation);
+  }
+
+  return Error::Ok;
+}
+
+
+Result<std::shared_ptr<ImageItem_Grid>> ImageItem_Grid::add_and_encode_full_grid(HeifContext* ctx,
+                                                                                 const std::vector<std::shared_ptr<HeifPixelImage>>& tiles,
+                                                                                 uint16_t rows,
+                                                                                 uint16_t columns,
+                                                                                 heif_encoder* encoder,
+                                                                                 const heif_encoding_options& options)
+{
+  std::shared_ptr<ImageItem_Grid> griditem;
+
+  // Create ImageGrid
+
+  ImageGrid grid;
+  grid.set_num_tiles(columns, rows);
+  uint32_t tile_width = tiles[0]->get_width(heif_channel_interleaved);
+  uint32_t tile_height = tiles[0]->get_height(heif_channel_interleaved);
+  grid.set_output_size(tile_width * columns, tile_height * rows);
+  std::vector<uint8_t> grid_data = grid.write();
+
+  auto file = ctx->get_heif_file();
+
+  // Encode Tiles
+
+  std::vector<heif_item_id> tile_ids;
+
+  std::shared_ptr<Box_pixi> pixi_property;
+
+  for (int i=0; i<rows*columns; i++) {
+    std::shared_ptr<ImageItem> out_tile;
+    auto encodingResult = ctx->encode_image(tiles[i],
+                                            encoder,
+                                            options,
+                                            heif_image_input_class_normal);
+    if (!encodingResult) {
+      return encodingResult.error();
+    }
+    else {
+      out_tile = *encodingResult;
+    }
+
+    heif_item_id tile_id = out_tile->get_id();
+    file->get_infe_box(tile_id)->set_hidden_item(true); // only show the full grid
+    tile_ids.push_back(out_tile->get_id());
+
+    if (!pixi_property) {
+      pixi_property = out_tile->get_property<Box_pixi>();
+    }
+  }
+
+  // Create Grid Item
+
+  auto grid_id_result = file->add_new_image(fourcc("grid"));
+  if (!grid_id_result) {
+    return grid_id_result.error();
+  }
+  heif_item_id grid_id = *grid_id_result;
+  griditem = std::make_shared<ImageItem_Grid>(ctx, grid_id);
+  ctx->insert_image_item(grid_id, griditem);
+  const int construction_method = 1; // 0=mdat 1=idat
+  file->append_iloc_data(grid_id, grid_data, construction_method);
+
+  // Connect tiles to grid
+
+  file->add_iref_reference(grid_id, fourcc("dimg"), tile_ids);
+
+  // Add ISPE property
+
+  uint32_t image_width = tile_width * columns;
+  uint32_t image_height = tile_height * rows;
+
+  auto ispe = std::make_shared<Box_ispe>();
+  ispe->set_size(image_width, image_height);
+  griditem->add_property(ispe, false);
+
+  // Add PIXI property (copy from first tile)
+
+  griditem->add_property(pixi_property, true);
+
+  // copy over extra properties to grid item
+
+  auto property_boxes = tiles[0]->generate_property_boxes(true);
+  for (auto& property : property_boxes) {
+    griditem->add_property(property, griditem->is_property_essential(property));
+  }
+
+  // Set Brands
+
+  //file->set_brand(encoder->plugin->compression_format,
+  //                griditem->is_miaf_compatible());
+
+  return griditem;
+}
+
+heif_brand2 ImageItem_Grid::get_compatible_brand() const
+{
+  if (m_grid_tile_ids.empty()) { return 0; }
+
+  heif_item_id child_id = m_grid_tile_ids[0];
+  auto child = get_context()->get_image(child_id, false);
+  if (!child) { return 0; }
+
+  return child->get_compatible_brand();
+}
diff --git a/libheif/image-items/grid.h b/libheif/image-items/grid.h
new file mode 100644
index 0000000000..d65a0f2da9
--- /dev/null
+++ b/libheif/image-items/grid.h
@@ -0,0 +1,182 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_IMAGEITEM_GRID_H
+#define LIBHEIF_IMAGEITEM_GRID_H
+
+#include "image_item.h"
+#include <vector>
+#include <string>
+#include <memory>
+#include <set>
+
+
+class ImageGrid
+{
+public:
+  Error parse(const std::vector<uint8_t>& data);
+
+  std::vector<uint8_t> write() const;
+
+  std::string dump() const;
+
+  uint32_t get_width() const { return m_output_width; }
+
+  uint32_t get_height() const { return m_output_height; }
+
+  uint16_t get_rows() const
+  {
+    return m_rows;
+  }
+
+  uint16_t get_columns() const
+  {
+    return m_columns;
+  }
+
+  void set_num_tiles(uint16_t columns, uint16_t rows)
+  {
+    m_rows = rows;
+    m_columns = columns;
+  }
+
+  void set_output_size(uint32_t width, uint32_t height)
+  {
+    m_output_width = width;
+    m_output_height = height;
+  }
+
+private:
+  uint16_t m_rows = 0;
+  uint16_t m_columns = 0;
+  uint32_t m_output_width = 0;
+  uint32_t m_output_height = 0;
+};
+
+
+
+
+
+class ImageItem_Grid : public ImageItem
+{
+public:
+  ImageItem_Grid(HeifContext* ctx, heif_item_id id);
+
+  ImageItem_Grid(HeifContext* ctx);
+
+  ~ImageItem_Grid() override;
+
+  uint32_t get_infe_type() const override { return fourcc("grid"); }
+
+  static Result<std::shared_ptr<ImageItem_Grid>> add_new_grid_item(HeifContext* ctx,
+                                                                   uint32_t output_width,
+                                                                   uint32_t output_height,
+                                                                   uint16_t tile_rows,
+                                                                   uint16_t tile_columns,
+                                                                   const heif_encoding_options* encoding_options);
+
+  Error add_image_tile(uint32_t tile_x, uint32_t tile_y,
+                       const std::shared_ptr<HeifPixelImage>& image,
+                       heif_encoder* encoder);
+
+  static Result<std::shared_ptr<ImageItem_Grid>> add_and_encode_full_grid(HeifContext* ctx,
+                                                                          const std::vector<std::shared_ptr<HeifPixelImage>>& tiles,
+                                                                          uint16_t rows,
+                                                                          uint16_t columns,
+                                                                          heif_encoder* encoder,
+                                                                          const heif_encoding_options& options);
+
+
+  // TODO: nclx depends on contained format
+  // const heif_color_profile_nclx* get_forced_output_nclx() const override { return nullptr; }
+
+  // heif_compression_format get_compression_format() const override { return heif_compression_HEVC; }
+
+  Error initialize_decoder() override;
+
+  int get_luma_bits_per_pixel() const override;
+
+  int get_chroma_bits_per_pixel() const override;
+
+  void set_tile_encoding_options(const heif_encoding_options* options);
+
+  Result<Encoder::CodedImageData> encode(const std::shared_ptr<HeifPixelImage>& image,
+                                         heif_encoder* encoder,
+                                         const heif_encoding_options& options,
+                                         heif_image_input_class input_class) override
+  {
+    return Error{heif_error_Unsupported_feature,
+                 heif_suberror_Unspecified, "Cannot encode image to 'grid'"};
+  }
+
+  Result<std::shared_ptr<HeifPixelImage>> decode_compressed_image(const heif_decoding_options& options,
+                                                                  bool decode_tile_only, uint32_t tile_x0, uint32_t tile_y0,
+                                                                  std::set<heif_item_id> processed_ids) const override;
+
+  heif_brand2 get_compatible_brand() const override;
+
+protected:
+  Result<std::shared_ptr<Decoder>> get_decoder() const override;
+
+public:
+
+  // --- grid specific
+
+  const ImageGrid& get_grid_spec() const { return m_grid_spec; }
+
+  void set_grid_spec(const ImageGrid& grid) { m_grid_spec = grid; m_grid_tile_ids.resize(size_t{grid.get_rows()} * grid.get_columns()); }
+
+  const std::vector<heif_item_id>& get_grid_tiles() const { return m_grid_tile_ids; }
+
+  void set_grid_tile_id(uint32_t tile_x, uint32_t tile_y, heif_item_id);
+
+  heif_image_tiling get_heif_image_tiling() const override;
+
+  void get_tile_size(uint32_t& w, uint32_t& h) const override;
+
+private:
+  ImageGrid m_grid_spec;
+  std::vector<heif_item_id> m_grid_tile_ids;
+
+  heif_orientation m_grid_orientation = heif_orientation_normal;
+  heif_encoding_options* m_tile_encoding_options = nullptr;
+
+  Error read_grid_spec();
+
+  Result<std::shared_ptr<HeifPixelImage>> decode_full_grid_image(const heif_decoding_options& options, std::set<heif_item_id> processed_ids) const;
+
+  Result<std::shared_ptr<HeifPixelImage>> decode_grid_tile(const heif_decoding_options& options, uint32_t tx, uint32_t ty, std::set<heif_item_id> processed_ids) const;
+
+  struct FailedTile {
+    // Top-left pixel coordinates
+    uint32_t x0;
+    uint32_t y0;
+  };
+
+  Error decode_and_paste_tile_image(heif_item_id tileID, uint32_t x0, uint32_t y0,
+                                    std::shared_ptr<HeifPixelImage>& inout_image,
+                                    const heif_decoding_options& options, int& progress_counter,
+                                    std::shared_ptr<std::vector<Error> > warnings,
+                                    std::vector<FailedTile>& failed_tiles,
+                                    std::set<heif_item_id> processed_ids) const;
+};
+
+
+#endif //LIBHEIF_GRID_H
diff --git a/libheif/image-items/hevc.cc b/libheif/image-items/hevc.cc
new file mode 100644
index 0000000000..0b598def1a
--- /dev/null
+++ b/libheif/image-items/hevc.cc
@@ -0,0 +1,214 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "hevc.h"
+#include "codecs/hevc_boxes.h"
+#include "bitstream.h"
+#include "error.h"
+#include "file.h"
+#include "codecs/hevc_dec.h"
+
+#include <cassert>
+#include <cmath>
+#include <cstring>
+#include <iomanip>
+#include <string>
+#include <utility>
+#include "api_structs.h"
+#include "codecs/hevc_enc.h"
+
+
+ImageItem_HEVC::ImageItem_HEVC(HeifContext* ctx, heif_item_id id)
+    : ImageItem(ctx, id)
+{
+  m_encoder = std::make_shared<Encoder_HEVC>();
+}
+
+
+ImageItem_HEVC::ImageItem_HEVC(HeifContext* ctx)
+    : ImageItem(ctx)
+{
+  m_encoder = std::make_shared<Encoder_HEVC>();
+}
+
+
+Error ImageItem_HEVC::initialize_decoder()
+{
+  auto hvcC_box = get_property<Box_hvcC>();
+  if (!hvcC_box) {
+    return Error{heif_error_Invalid_input,
+                 heif_suberror_No_hvcC_box};
+  }
+
+  m_decoder = std::make_shared<Decoder_HEVC>(hvcC_box);
+
+  return Error::Ok;
+}
+
+
+void ImageItem_HEVC::set_decoder_input_data()
+{
+  DataExtent extent;
+  extent.set_from_image_item(get_context()->get_heif_file(), get_id());
+
+  m_decoder->set_data_extent(std::move(extent));
+}
+
+
+heif_brand2 ImageItem_HEVC::get_compatible_brand() const
+{
+  auto hvcC = get_property<Box_hvcC>();
+
+  if (has_essential_property_other_than(std::set{fourcc("hvcC"),
+                                                 fourcc("irot"),
+                                                 fourcc("imir"),
+                                                 fourcc("clap")})) {
+    return 0;
+  }
+
+  const auto& config = hvcC->get_configuration();
+  if (config.is_profile_compatibile(HEVCDecoderConfigurationRecord::Profile_Main) ||
+      config.is_profile_compatibile(HEVCDecoderConfigurationRecord::Profile_MainStillPicture)) {
+    return heif_brand2_heic;
+  }
+
+  if (config.is_profile_compatibile(HEVCDecoderConfigurationRecord::Profile_Main10) ||
+      config.is_profile_compatibile(HEVCDecoderConfigurationRecord::Profile_RExt)) {
+    return heif_brand2_heix;
+  }
+
+  // TODO: what brand should we use for this case?
+
+  return heif_brand2_heix;
+}
+
+
+Result<std::vector<uint8_t>> ImageItem_HEVC::read_bitstream_configuration_data() const
+{
+  return m_decoder->read_bitstream_configuration_data();
+}
+
+
+Result<std::shared_ptr<Decoder>> ImageItem_HEVC::get_decoder() const
+{
+  return {m_decoder};
+}
+
+
+std::shared_ptr<Encoder> ImageItem_HEVC::get_encoder() const
+{
+  return m_encoder;
+}
+
+
+void ImageItem_HEVC::set_preencoded_hevc_image(const std::vector<uint8_t>& data)
+{
+  auto hvcC = std::make_shared<Box_hvcC>();
+
+
+  // --- parse the h265 stream and set hvcC headers and compressed image data
+
+  int state = 0;
+
+  bool first = true;
+  bool eof = false;
+
+  int prev_start_code_start = -1; // init to an invalid value, will always be overwritten before use
+  int start_code_start;
+  int ptr = 0;
+
+  for (;;) {
+    bool dump_nal = false;
+
+    uint8_t c = data[ptr++];
+
+    if (state == 3) {
+      state = 0;
+    }
+
+    if (c == 0 && state <= 1) {
+      state++;
+    }
+    else if (c == 0) {
+      // NOP
+    }
+    else if (c == 1 && state == 2) {
+      start_code_start = ptr - 3;
+      dump_nal = true;
+      state = 3;
+    }
+    else {
+      state = 0;
+    }
+
+    if (ptr == (int) data.size()) {
+      start_code_start = (int) data.size();
+      dump_nal = true;
+      eof = true;
+    }
+
+    if (dump_nal) {
+      if (first) {
+        first = false;
+      }
+      else {
+        std::vector<uint8_t> nal_data;
+        size_t length = start_code_start - (prev_start_code_start + 3);
+
+        nal_data.resize(length);
+
+        assert(prev_start_code_start >= 0);
+        memcpy(nal_data.data(), data.data() + prev_start_code_start + 3, length);
+
+        int nal_type = (nal_data[0] >> 1);
+
+        switch (nal_type) {
+          case 0x20:
+          case 0x21:
+          case 0x22:
+            hvcC->append_nal_data(nal_data);
+            break;
+
+          default: {
+            std::vector<uint8_t> nal_data_with_size;
+            nal_data_with_size.resize(nal_data.size() + 4);
+
+            memcpy(nal_data_with_size.data() + 4, nal_data.data(), nal_data.size());
+            nal_data_with_size[0] = ((nal_data.size() >> 24) & 0xFF);
+            nal_data_with_size[1] = ((nal_data.size() >> 16) & 0xFF);
+            nal_data_with_size[2] = ((nal_data.size() >> 8) & 0xFF);
+            nal_data_with_size[3] = ((nal_data.size() >> 0) & 0xFF);
+
+            get_file()->append_iloc_data(get_id(), nal_data_with_size, 0);
+          }
+            break;
+        }
+      }
+
+      prev_start_code_start = start_code_start;
+    }
+
+    if (eof) {
+      break;
+    }
+  }
+
+  get_file()->add_property(get_id(), hvcC, true);
+}
diff --git a/libheif/image-items/hevc.h b/libheif/image-items/hevc.h
new file mode 100644
index 0000000000..7dff5c1916
--- /dev/null
+++ b/libheif/image-items/hevc.h
@@ -0,0 +1,70 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef HEIF_HEVC_H
+#define HEIF_HEVC_H
+
+#include "libheif/heif.h"
+#include "box.h"
+#include "error.h"
+
+#include <memory>
+#include <string>
+#include <vector>
+#include "image_item.h"
+
+
+class ImageItem_HEVC : public ImageItem
+{
+public:
+  ImageItem_HEVC(HeifContext* ctx, heif_item_id id);
+
+  ImageItem_HEVC(HeifContext* ctx);
+
+  uint32_t get_infe_type() const override { return fourcc("hvc1"); }
+
+  // TODO: MIAF says that the *:hevc:* urn is deprecated and we should use "urn:mpeg:mpegB:cicp:systems:auxiliary:alpha"
+  const char* get_auxC_alpha_channel_type() const override { return "urn:mpeg:hevc:2015:auxid:1"; }
+
+  heif_compression_format get_compression_format() const override { return heif_compression_HEVC; }
+
+  Error initialize_decoder() override;
+
+  void set_decoder_input_data() override;
+
+
+  heif_brand2 get_compatible_brand() const override;
+
+  // currently not used
+  void set_preencoded_hevc_image(const std::vector<uint8_t>& data);
+
+protected:
+  Result<std::vector<uint8_t>> read_bitstream_configuration_data() const override;
+
+  Result<std::shared_ptr<Decoder>> get_decoder() const override;
+
+  std::shared_ptr<Encoder> get_encoder() const override;
+
+private:
+  std::shared_ptr<class Decoder_HEVC> m_decoder;
+  std::shared_ptr<class Encoder_HEVC> m_encoder;
+};
+
+#endif
diff --git a/libheif/image-items/iden.cc b/libheif/image-items/iden.cc
new file mode 100644
index 0000000000..8e771cfa05
--- /dev/null
+++ b/libheif/image-items/iden.cc
@@ -0,0 +1,155 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "iden.h"
+#include "context.h"
+#include "file.h"
+
+
+ImageItem_iden::ImageItem_iden(HeifContext* ctx)
+    : ImageItem(ctx)
+{
+}
+
+
+ImageItem_iden::ImageItem_iden(HeifContext* ctx, heif_item_id id)
+    : ImageItem(ctx, id)
+{
+}
+
+
+Result<std::shared_ptr<HeifPixelImage>> ImageItem_iden::decode_compressed_image(const heif_decoding_options& options,
+                                                                                bool decode_tile_only, uint32_t tile_x0, uint32_t tile_y0,
+                                                                                std::set<heif_item_id> processed_ids) const
+{
+  if (processed_ids.contains(get_id())) {
+    return Error{heif_error_Invalid_input,
+                 heif_suberror_Unspecified,
+                 "'iref' has cyclic references"};
+  }
+
+  processed_ids.insert(get_id());
+
+
+  std::shared_ptr<HeifPixelImage> img;
+
+  // find the ID of the image this image is derived from
+
+  auto iref_box = get_file()->get_iref_box();
+
+  if (!iref_box) {
+    return Error(heif_error_Invalid_input,
+                 heif_suberror_No_iref_box,
+                 "No iref box available, but needed for iden image");
+  }
+
+  std::vector<heif_item_id> image_references = iref_box->get_references(get_id(), fourcc("dimg"));
+
+  if (image_references.size() > 1) {
+    return Error(heif_error_Invalid_input,
+                 heif_suberror_Unspecified,
+                 "'iden' image with more than one reference image");
+  }
+
+  if (image_references.empty()) {
+    return Error(heif_error_Invalid_input,
+                 heif_suberror_Unspecified,
+                 "'iden' image without 'dimg' reference");
+  }
+
+
+  heif_item_id reference_image_id = image_references[0];
+
+  if (reference_image_id == get_id()) {
+    return Error(heif_error_Invalid_input,
+                 heif_suberror_Unspecified,
+                 "'iden' image referring to itself");
+  }
+
+  std::shared_ptr<const ImageItem> imgitem = get_context()->get_image(reference_image_id, true);
+  if (!imgitem) {
+    return Error(heif_error_Invalid_input,
+                 heif_suberror_Unspecified,
+                 "'iden' image references unavailable image");
+  }
+  if (auto error = imgitem->get_item_error()) {
+    return error;
+  }
+
+  return imgitem->decode_image(options, decode_tile_only, tile_x0, tile_y0, processed_ids);
+}
+
+
+Error ImageItem_iden::get_coded_image_colorspace(heif_colorspace* out_colorspace, heif_chroma* out_chroma) const
+{
+  heif_item_id child;
+  Error err = get_context()->get_id_of_non_virtual_child_image(get_id(), child);
+  if (err) {
+    return err;
+  }
+
+  auto image = get_context()->get_image(child, true);
+  if (!image) {
+    return Error{heif_error_Invalid_input,
+                 heif_suberror_Nonexisting_item_referenced};
+  }
+
+  return image->get_coded_image_colorspace(out_colorspace, out_chroma);
+}
+
+
+int ImageItem_iden::get_luma_bits_per_pixel() const
+{
+  heif_item_id child;
+  Error err = get_context()->get_id_of_non_virtual_child_image(get_id(), child);
+  if (err) {
+    return -1;
+  }
+
+  auto image = get_context()->get_image(child, true);
+  if (!image) {
+    return -1;
+  }
+
+  return image->get_luma_bits_per_pixel();
+}
+
+
+int ImageItem_iden::get_chroma_bits_per_pixel() const
+{
+  heif_item_id child;
+  Error err = get_context()->get_id_of_non_virtual_child_image(get_id(), child);
+  if (err) {
+    return -1;
+  }
+
+  auto image = get_context()->get_image(child, true);
+  if (!image) {
+    return -1;
+  }
+
+  return image->get_chroma_bits_per_pixel();
+}
+
+heif_brand2 ImageItem_iden::get_compatible_brand() const
+{
+  assert(false);
+  return 0; // TODO (we never write 'iden' images)
+}
diff --git a/libheif/image-items/iden.h b/libheif/image-items/iden.h
new file mode 100644
index 0000000000..0a8a5cb903
--- /dev/null
+++ b/libheif/image-items/iden.h
@@ -0,0 +1,72 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_IDEN_H
+#define LIBHEIF_IDEN_H
+
+#include "image_item.h"
+#include <vector>
+#include <string>
+#include <memory>
+#include <set>
+
+
+class ImageItem_iden : public ImageItem
+{
+public:
+  ImageItem_iden(HeifContext* ctx, heif_item_id id);
+
+  ImageItem_iden(HeifContext* ctx);
+
+  uint32_t get_infe_type() const override { return fourcc("iden"); }
+
+  // TODO: nclx depends on contained format
+  // const heif_color_profile_nclx* get_forced_output_nclx() const override { return nullptr; }
+
+  // heif_compression_format get_compression_format() const override { return heif_compression_HEVC; }
+
+  //Error on_load_file() override;
+
+  Error get_coded_image_colorspace(heif_colorspace* out_colorspace, heif_chroma* out_chroma) const override;
+
+  int get_luma_bits_per_pixel() const override;
+
+  int get_chroma_bits_per_pixel() const override;
+
+  Result<Encoder::CodedImageData> encode(const std::shared_ptr<HeifPixelImage>& image,
+                                         heif_encoder* encoder,
+                                         const heif_encoding_options& options,
+                                         heif_image_input_class input_class) override
+  {
+    return Error{heif_error_Unsupported_feature,
+                 heif_suberror_Unspecified, "Cannot encode image to 'iden'"};
+  }
+
+  Result<std::shared_ptr<HeifPixelImage>> decode_compressed_image(const heif_decoding_options& options,
+                                                                  bool decode_tile_only, uint32_t tile_x0, uint32_t tile_y0,
+                                                                  std::set<heif_item_id> processed_ids) const override;
+
+  heif_brand2 get_compatible_brand() const override;
+
+private:
+};
+
+
+#endif //LIBHEIF_IDEN_H
diff --git a/libheif/image-items/image_item.cc b/libheif/image-items/image_item.cc
new file mode 100644
index 0000000000..ab3bf23985
--- /dev/null
+++ b/libheif/image-items/image_item.cc
@@ -0,0 +1,1167 @@
+/*
+ * HEIF image base codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "image_item.h"
+#include "mask_image.h"
+#include "context.h"
+#include "file.h"
+#include "jpeg.h"
+#include "jpeg2000.h"
+#include "avif.h"
+#include "avc.h"
+#include "hevc.h"
+#include "grid.h"
+#include "overlay.h"
+#include "iden.h"
+#include "tiled.h"
+#include "codecs/decoder.h"
+#include "color-conversion/colorconversion.h"
+#include "api_structs.h"
+#include "plugin_registry.h"
+#include "security_limits.h"
+
+#include <limits>
+#include <cassert>
+#include <cstring>
+//#include <ranges>
+
+#if WITH_UNCOMPRESSED_CODEC
+#include "image-items/unc_image.h"
+#endif
+
+
+ImageItem::ImageItem(HeifContext* context)
+    : m_heif_context(context)
+{
+  memset(&m_depth_representation_info, 0, sizeof(m_depth_representation_info));
+}
+
+
+ImageItem::ImageItem(HeifContext* context, heif_item_id id)
+    : ImageItem(context)
+{
+  m_id = id;
+}
+
+
+bool ImageItem::is_property_essential(const std::shared_ptr<Box>& property) const
+{
+  if (property->get_short_type() == fourcc("ispe")) {
+    return is_ispe_essential();
+  }
+  else {
+    return property->is_essential();
+  }
+}
+
+
+std::shared_ptr<HeifFile> ImageItem::get_file() const
+{
+  return m_heif_context->get_heif_file();
+}
+
+
+heif_property_id ImageItem::add_property(std::shared_ptr<Box> property, bool essential)
+{
+  if (!property) {
+    return 0;
+  }
+
+  // TODO: is this correct? What happens when add_property does deduplicate the property?
+  m_properties.push_back(property);
+  return get_file()->add_property(get_id(), property, essential);
+}
+
+
+heif_property_id ImageItem::add_property_without_deduplication(std::shared_ptr<Box> property, bool essential)
+{
+  if (!property) {
+    return 0;
+  }
+
+  m_properties.push_back(property);
+  return get_file()->add_property_without_deduplication(get_id(), property, essential);
+}
+
+
+heif_compression_format ImageItem::compression_format_from_fourcc_infe_type(uint32_t type)
+{
+  switch (type) {
+    case fourcc("jpeg"):
+      return heif_compression_JPEG;
+    case fourcc("hvc1"):
+      return heif_compression_HEVC;
+    case fourcc("av01"):
+      return heif_compression_AV1;
+    case fourcc("vvc1"):
+      return heif_compression_VVC;
+    case fourcc("j2k1"):
+      return heif_compression_JPEG2000;
+    case fourcc("unci"):
+      return heif_compression_uncompressed;
+    case fourcc("mski"):
+      return heif_compression_mask;
+    default:
+      return heif_compression_undefined;
+  }
+}
+
+uint32_t ImageItem::compression_format_to_fourcc_infe_type(heif_compression_format format)
+{
+  switch (format) {
+    case heif_compression_JPEG:
+      return fourcc("jpeg");
+    case heif_compression_HEVC:
+      return fourcc("hvc1");
+    case heif_compression_AV1:
+      return fourcc("av01");
+    case heif_compression_VVC:
+      return fourcc("vvc1");
+    case heif_compression_JPEG2000:
+      return fourcc("j2k1");
+    case heif_compression_uncompressed:
+      return fourcc("unci");
+    case heif_compression_mask:
+      return fourcc("mski");
+    default:
+      return 0;
+  }
+}
+
+
+std::shared_ptr<ImageItem> ImageItem::alloc_for_infe_box(HeifContext* ctx, const std::shared_ptr<Box_infe>& infe)
+{
+  uint32_t item_type = infe->get_item_type_4cc();
+  heif_item_id id = infe->get_item_ID();
+
+  if (item_type == fourcc("jpeg") ||
+      (item_type == fourcc("mime") && infe->get_content_type() == "image/jpeg")) {
+    return std::make_shared<ImageItem_JPEG>(ctx, id);
+  }
+  else if (item_type == fourcc("hvc1")) {
+    return std::make_shared<ImageItem_HEVC>(ctx, id);
+  }
+  else if (item_type == fourcc("av01")) {
+    return std::make_shared<ImageItem_AVIF>(ctx, id);
+  }
+  else if (item_type == fourcc("vvc1")) {
+    return std::make_shared<ImageItem_VVC>(ctx, id);
+  }
+  else if (item_type == fourcc("avc1")) {
+    return std::make_shared<ImageItem_AVC>(ctx, id);
+  }
+  else if (item_type == fourcc("unci")) {
+#if WITH_UNCOMPRESSED_CODEC
+    return std::make_shared<ImageItem_uncompressed>(ctx, id);
+#else
+    // It is an image item type that we do not support. Thus, generate an ImageItem_Error.
+
+    std::stringstream sstr;
+    sstr << "Image item of type '" << fourcc_to_string(item_type) << "' is not supported.";
+    Error err{ heif_error_Unsupported_feature, heif_suberror_Unsupported_image_type, sstr.str() };
+    return std::make_shared<ImageItem_Error>(item_type, id, err);
+#endif
+  }
+  else if (item_type == fourcc("j2k1")) {
+    return std::make_shared<ImageItem_JPEG2000>(ctx, id);
+  }
+  else if (item_type == fourcc("lhv1")) {
+    return std::make_shared<ImageItem_Error>(item_type, id,
+                                             Error{heif_error_Unsupported_feature,
+                                                   heif_suberror_Unsupported_image_type,
+                                                   "Layered HEVC images (lhv1) are not supported yet"});
+  }
+  else if (item_type == fourcc("mski")) {
+    return std::make_shared<ImageItem_mask>(ctx, id);
+  }
+  else if (item_type == fourcc("grid")) {
+    return std::make_shared<ImageItem_Grid>(ctx, id);
+  }
+  else if (item_type == fourcc("iovl")) {
+    return std::make_shared<ImageItem_Overlay>(ctx, id);
+  }
+  else if (item_type == fourcc("iden")) {
+    return std::make_shared<ImageItem_iden>(ctx, id);
+  }
+  else if (item_type == fourcc("tili")) {
+    return std::make_shared<ImageItem_Tiled>(ctx, id);
+  }
+  else {
+    // This item has an unknown type. It could be an image or anything else.
+    // Do not process the item.
+
+    return nullptr;
+  }
+}
+
+
+std::shared_ptr<ImageItem> ImageItem::alloc_for_compression_format(HeifContext* ctx, heif_compression_format format)
+{
+  switch (format) {
+    case heif_compression_JPEG:
+      return std::make_shared<ImageItem_JPEG>(ctx);
+    case heif_compression_HEVC:
+      return std::make_shared<ImageItem_HEVC>(ctx);
+    case heif_compression_AV1:
+      return std::make_shared<ImageItem_AVIF>(ctx);
+    case heif_compression_VVC:
+      return std::make_shared<ImageItem_VVC>(ctx);
+    case heif_compression_AVC:
+      return std::make_shared<ImageItem_AVC>(ctx);
+#if WITH_UNCOMPRESSED_CODEC
+    case heif_compression_uncompressed:
+      return std::make_shared<ImageItem_uncompressed>(ctx);
+#endif
+    case heif_compression_JPEG2000:
+    case heif_compression_HTJ2K:
+      return std::make_shared<ImageItem_JPEG2000>(ctx);
+    case heif_compression_mask:
+      return std::make_shared<ImageItem_mask>(ctx);
+    default:
+      assert(false);
+      return nullptr;
+  }
+}
+
+
+Result<Encoder::CodedImageData> ImageItem::encode_to_bitstream_and_boxes(const std::shared_ptr<HeifPixelImage>& image,
+                                                                           heif_encoder* encoder,
+                                                                           const heif_encoding_options& options,
+                                                                           heif_image_input_class input_class)
+{
+  // === generate compressed image bitstream
+
+  Result<Encoder::CodedImageData> encodeResult = encode(image, encoder, options, input_class);
+  if (!encodeResult) {
+    return encodeResult;
+  }
+
+  Encoder::CodedImageData& codedImage = *encodeResult;
+
+  // === generate properties
+
+  // --- choose which color profile to put into 'colr' box
+
+  auto colr_boxes = add_color_profile(image, options, input_class, options.output_nclx_profile);
+  codedImage.properties.insert(codedImage.properties.end(),
+                               colr_boxes.begin(),
+                               colr_boxes.end());
+
+
+  // --- ispe
+  // Note: 'ispe' must come before the transformation properties
+
+  uint32_t input_width, input_height;
+  input_width = image->get_width();
+  input_height = image->get_height();
+
+  // --- get the real size of the encoded image
+
+  // highest priority: codedImageData
+  uint32_t encoded_width = codedImage.encoded_image_width;
+  uint32_t encoded_height = codedImage.encoded_image_height;
+
+  // second priority: query plugin API
+  if (encoded_width == 0 &&
+      encoder->plugin->plugin_api_version >= 3 &&
+      encoder->plugin->query_encoded_size != nullptr) {
+
+    encoder->plugin->query_encoded_size(encoder->encoder,
+                                        input_width, input_height,
+                                        &encoded_width,
+                                        &encoded_height);
+  }
+  else if (encoded_width == 0) {
+    // fallback priority: use input size
+    encoded_width = input_width;
+    encoded_height = input_height;
+  }
+
+  auto ispe = std::make_shared<Box_ispe>();
+  ispe->set_size(encoded_width, encoded_height);
+  ispe->set_is_essential(is_ispe_essential());
+  codedImage.properties.push_back(ispe);
+
+
+  // --- clap (if needed)
+
+  if (input_width != encoded_width ||
+      input_height != encoded_height) {
+
+    auto clap = std::make_shared<Box_clap>();
+    clap->set(input_width, input_height, encoded_width, encoded_height);
+    codedImage.properties.push_back(clap);
+  }
+
+
+
+  // --- add common metadata properties (pixi, ...)
+
+  auto colorspace = image->get_colorspace();
+  auto chroma = image->get_chroma_format();
+
+
+  // --- write PIXI property
+
+  std::shared_ptr<Box_pixi> pixi = std::make_shared<Box_pixi>();
+  if (colorspace == heif_colorspace_filter_array) {
+    // Skip pixi for filter array images — bit depth info is in uncC
+  }
+  else if (colorspace == heif_colorspace_monochrome) {
+    pixi->add_channel_bits(image->get_bits_per_pixel(heif_channel_Y));
+  }
+  else if (colorspace == heif_colorspace_YCbCr) {
+    pixi->add_channel_bits(image->get_bits_per_pixel(heif_channel_Y));
+    pixi->add_channel_bits(image->get_bits_per_pixel(heif_channel_Cb));
+    pixi->add_channel_bits(image->get_bits_per_pixel(heif_channel_Cr));
+  }
+  else if (colorspace == heif_colorspace_RGB) {
+    if (chroma == heif_chroma_444) {
+      pixi->add_channel_bits(image->get_bits_per_pixel(heif_channel_R));
+      pixi->add_channel_bits(image->get_bits_per_pixel(heif_channel_G));
+      pixi->add_channel_bits(image->get_bits_per_pixel(heif_channel_B));
+    }
+    else if (chroma == heif_chroma_interleaved_RGB ||
+             chroma == heif_chroma_interleaved_RGBA ||
+             chroma == heif_chroma_interleaved_RRGGBB_LE ||
+             chroma == heif_chroma_interleaved_RRGGBB_BE ||
+             chroma == heif_chroma_interleaved_RRGGBBAA_LE ||
+             chroma == heif_chroma_interleaved_RRGGBBAA_BE) {
+      uint8_t bpp = image->get_bits_per_pixel(heif_channel_interleaved);
+      pixi->add_channel_bits(bpp);
+      pixi->add_channel_bits(bpp);
+      pixi->add_channel_bits(bpp);
+    }
+  }
+
+  if (pixi->get_num_channels() != 0) {
+    codedImage.properties.push_back(pixi);
+  }
+
+  // --- generate properties for image extra data
+
+  // copy over ImageExtraData into image item
+  *static_cast<ImageExtraData*>(this) = static_cast<ImageExtraData>(*image);
+
+  auto extra_data_properties = image->generate_property_boxes(false);
+  codedImage.properties.insert(codedImage.properties.end(),
+                               extra_data_properties.begin(),
+                               extra_data_properties.end());
+
+  return encodeResult;
+}
+
+
+Error ImageItem::encode_to_item(HeifContext* ctx,
+                                const std::shared_ptr<HeifPixelImage>& image,
+                                heif_encoder* encoder,
+                                const heif_encoding_options& options,
+                                heif_image_input_class input_class)
+{
+  uint32_t input_width = image->get_width();
+  uint32_t input_height = image->get_height();
+
+  set_size(input_width, input_height);
+
+
+  // compress image and assign data to item
+
+  Result<Encoder::CodedImageData> codingResult = encode_to_bitstream_and_boxes(image, encoder, options, input_class);
+  if (!codingResult) {
+    return codingResult.error();
+  }
+
+  Encoder::CodedImageData& codedImage = *codingResult;
+
+  auto infe_result = ctx->get_heif_file()->add_new_infe_box(get_infe_type());
+  if (!infe_result) {
+    return infe_result.error();
+  }
+  auto infe_box = *infe_result;
+  heif_item_id image_id = infe_box->get_item_ID();
+  set_id(image_id);
+
+  ctx->get_heif_file()->append_iloc_data(image_id, codedImage.bitstream, 0);
+
+
+  // set item properties
+
+  for (auto& propertyBox : codingResult->properties) {
+    bool essential = is_property_essential(propertyBox);
+
+    // TODO: can we simply use add_property() ?
+    int index = ctx->get_heif_file()->get_ipco_box()->find_or_append_child_box(propertyBox);
+    ctx->get_heif_file()->get_ipma_box()->add_property_for_item_ID(image_id, Box_ipma::PropertyAssociation{essential,
+                                                                                                           uint16_t(index + 1)});
+  }
+
+
+  // MIAF 7.3.6.7
+  // This is according to MIAF without Amd2. With Amd2, the restriction has been lifted and the image is MIAF compatible.
+  // However, since AVIF is based on MIAF, the whole image would be invalid in that case.
+
+  // We might remove this code at a later point in time when MIAF Amd2 is in wide use.
+
+  if (encoder->plugin->compression_format != heif_compression_AV1 &&
+      image->get_colorspace() == heif_colorspace_YCbCr) {
+    if (!is_integer_multiple_of_chroma_size(image->get_width(),
+                                            image->get_height(),
+                                            image->get_chroma_format())) {
+      mark_not_miaf_compatible();
+    }
+  }
+
+  // TODO: move this into encode_to_bistream_and_boxes()
+  ctx->get_heif_file()->add_orientation_properties(image_id, options.image_orientation);
+
+  return Error::Ok;
+}
+
+bool ImageItem::has_ispe_resolution() const
+{
+  return get_property<Box_ispe>() != nullptr;
+}
+
+uint32_t ImageItem::get_ispe_width() const
+{
+  auto ispe = get_property<Box_ispe>();
+  if (!ispe) {
+    return 0;
+  }
+  else {
+    return ispe->get_width();
+  }
+}
+
+
+uint32_t ImageItem::get_ispe_height() const
+{
+  auto ispe = get_property<Box_ispe>();
+  if (!ispe) {
+    return 0;
+  }
+  else {
+    return ispe->get_height();
+  }
+}
+
+
+void ImageItem::get_tile_size(uint32_t& w, uint32_t& h) const
+{
+  w = get_width();
+  h = get_height();
+}
+
+
+Error ImageItem::postprocess_coded_image_colorspace(heif_colorspace* inout_colorspace, heif_chroma* inout_chroma) const
+{
+#if 0
+  auto pixi = m_heif_context->get_heif_file()->get_property<Box_pixi>(id);
+  if (pixi && pixi->get_num_channels() == 1) {
+    *out_colorspace = heif_colorspace_monochrome;
+    *out_chroma = heif_chroma_monochrome;
+  }
+#endif
+
+  if (*inout_colorspace == heif_colorspace_YCbCr) {
+    auto nclx = get_color_profile_nclx();
+    if (nclx.get_matrix_coefficients() == 0) {
+      *inout_colorspace = heif_colorspace_RGB;
+      *inout_chroma = heif_chroma_444; // TODO: this or keep the original chroma?
+    }
+  }
+
+  return Error::Ok;
+}
+
+
+Error ImageItem::get_coded_image_colorspace(heif_colorspace* out_colorspace, heif_chroma* out_chroma) const
+{
+  auto decoderResult = get_decoder();
+  if (!decoderResult) {
+    return decoderResult.error();
+  }
+
+  auto decoder = *decoderResult;
+
+  Error err = decoder->get_coded_image_colorspace(out_colorspace, out_chroma);
+  if (err) {
+    return err;
+  }
+
+  postprocess_coded_image_colorspace(out_colorspace, out_chroma);
+
+  return Error::Ok;
+}
+
+
+int ImageItem::get_luma_bits_per_pixel() const
+{
+  auto decoderResult = get_decoder();
+  if (!decoderResult) {
+    return decoderResult.error();
+  }
+
+  auto decoder = *decoderResult;
+
+  return decoder->get_luma_bits_per_pixel();
+}
+
+
+int ImageItem::get_chroma_bits_per_pixel() const
+{
+  auto decoderResult = get_decoder();
+  if (!decoderResult) {
+    return decoderResult.error();
+  }
+
+  auto decoder = *decoderResult;
+
+  return decoder->get_chroma_bits_per_pixel();
+}
+
+
+Result<Encoder::CodedImageData> ImageItem::encode(const std::shared_ptr<HeifPixelImage>& image,
+                                                  heif_encoder* h_encoder,
+                                                  const heif_encoding_options& options,
+                                                  heif_image_input_class input_class)
+{
+  auto encoder = get_encoder();
+  return encoder->encode(image, h_encoder, options, input_class);
+}
+
+
+std::vector<std::shared_ptr<Box_colr> >
+ImageItem::add_color_profile(const std::shared_ptr<HeifPixelImage>& image,
+                             const heif_encoding_options& options,
+                             heif_image_input_class input_class,
+                             const heif_color_profile_nclx* target_heif_nclx)
+{
+  std::vector<std::shared_ptr<Box_colr> > colr_boxes;
+
+  if (input_class == heif_image_input_class_normal || input_class == heif_image_input_class_thumbnail) {
+    // No color profile for non-visual images (e.g. elevation data)
+    if (image->get_colorspace() == heif_colorspace_nonvisual) {
+      return colr_boxes;
+    }
+
+    auto icc_profile = image->get_color_profile_icc();
+    if (icc_profile) {
+      auto colr = std::make_shared<Box_colr>();
+      colr->set_color_profile(icc_profile);
+      colr_boxes.push_back(colr);
+    }
+
+
+    // save nclx profile
+
+    bool save_nclx_profile = (options.output_nclx_profile != nullptr);
+
+    // if there is an ICC profile, only save NCLX when we chose to save both profiles
+    if (icc_profile && !(options.version >= 3 &&
+                         options.save_two_colr_boxes_when_ICC_and_nclx_available)) {
+      save_nclx_profile = false;
+    }
+
+    // we might have turned off nclx completely because macOS/iOS cannot read it
+    if (options.version >= 4 && options.macOS_compatibility_workaround_no_nclx_profile) {
+      save_nclx_profile = false;
+    }
+
+    if (save_nclx_profile) {
+      auto target_nclx_profile = std::make_shared<color_profile_nclx>();
+      target_nclx_profile->set_from_heif_color_profile_nclx(target_heif_nclx);
+
+      auto colr = std::make_shared<Box_colr>();
+      colr->set_color_profile(target_nclx_profile);
+      colr_boxes.push_back(colr);
+    }
+  }
+
+  return colr_boxes;
+}
+
+
+Error ImageItem::transform_requested_tile_position_to_original_tile_position(uint32_t& tile_x, uint32_t& tile_y) const
+{
+  Result<std::vector<std::shared_ptr<Box>>> propertiesResult = get_properties();
+  if (!propertiesResult) {
+    return propertiesResult.error();
+  }
+
+  heif_image_tiling tiling = get_heif_image_tiling();
+
+  //for (auto& prop : std::ranges::reverse_view(propertiesResult.value)) {
+  for (auto propIter = propertiesResult->rbegin(); propIter != propertiesResult->rend(); propIter++) {
+    if (auto irot = std::dynamic_pointer_cast<Box_irot>(*propIter)) {
+      switch (irot->get_rotation_ccw()) {
+        case 90: {
+          uint32_t tx0 = tiling.num_columns - 1 - tile_y;
+          uint32_t ty0 = tile_x;
+          tile_y = ty0;
+          tile_x = tx0;
+          break;
+        }
+        case 270: {
+          uint32_t tx0 = tile_y;
+          uint32_t ty0 = tiling.num_rows - 1 - tile_x;
+          tile_y = ty0;
+          tile_x = tx0;
+          break;
+        }
+        case 180: {
+          tile_x = tiling.num_columns - 1 - tile_x;
+          tile_y = tiling.num_rows - 1 - tile_y;
+          break;
+        }
+        case 0:
+          break;
+        default:
+          assert(false);
+          break;
+      }
+    }
+
+    if (auto imir = std::dynamic_pointer_cast<Box_imir>(*propIter)) {
+      switch (imir->get_mirror_direction()) {
+        case heif_transform_mirror_direction_horizontal:
+          tile_x = tiling.num_columns - 1 - tile_x;
+          break;
+        case heif_transform_mirror_direction_vertical:
+          tile_y = tiling.num_rows - 1 - tile_y;
+          break;
+        default:
+          assert(false);
+          break;
+      }
+    }
+  }
+
+  return Error::Ok;
+}
+
+
+void ImageItem::set_clli(const heif_content_light_level& clli)
+{
+  ImageExtraData::set_clli(clli);
+  add_property(get_clli_box(), false);
+}
+
+
+void ImageItem::set_mdcv(const heif_mastering_display_colour_volume& mdcv)
+{
+  ImageExtraData::set_mdcv(mdcv);
+  add_property(get_mdcv_box(), false);
+}
+
+
+void ImageItem::set_pixel_ratio(uint32_t h, uint32_t v)
+{
+  ImageExtraData::set_pixel_ratio(h, v);
+  add_property(get_pasp_box(), false);
+}
+
+
+void ImageItem::set_color_profile_nclx(const nclx_profile& profile)
+{
+  ImageExtraData::set_color_profile_nclx(profile);
+  add_property(get_colr_box_nclx(), false);
+}
+
+
+void ImageItem::set_color_profile_icc(const std::shared_ptr<const color_profile_raw>& profile)
+{
+  ImageExtraData::set_color_profile_icc(profile);
+  add_property(get_colr_box_icc(), false);
+}
+
+#if HEIF_WITH_OMAF
+void ImageItem::set_omaf_image_projection(heif_omaf_image_projection projection)
+{
+  ImageExtraData::set_omaf_image_projection(projection);
+  add_property(get_prfr_box(), true);
+}
+#endif
+
+
+Result<std::shared_ptr<HeifPixelImage>> ImageItem::decode_image(const heif_decoding_options& options,
+                                                                bool decode_tile_only, uint32_t tile_x0, uint32_t tile_y0,
+                                                                std::set<heif_item_id> processed_ids) const
+{
+  // --- check whether image size (according to 'ispe') exceeds maximum
+
+  if (!decode_tile_only) {
+    auto ispe = get_property<Box_ispe>();
+    if (ispe) {
+      Error err = check_for_valid_image_size(get_context()->get_security_limits(), ispe->get_width(), ispe->get_height());
+      if (err) {
+        return err;
+      }
+    }
+  }
+
+
+  // --- transform tile position
+
+  if (decode_tile_only && options.ignore_transformations == false) {
+    if (Error error = transform_requested_tile_position_to_original_tile_position(tile_x0, tile_y0)) {
+      return error;
+    }
+  }
+
+  // --- decode image
+
+  Result<std::shared_ptr<HeifPixelImage>> decodingResult = decode_compressed_image(options, decode_tile_only, tile_x0, tile_y0, processed_ids);
+  if (!decodingResult) {
+    return decodingResult.error();
+  }
+
+  auto img = *decodingResult;
+  if (!img) {
+    // Can happen if missing tiled image is decoded in non-strict mode.
+    return Error(heif_error_Decoder_plugin_error, heif_suberror_Unspecified);
+  }
+
+  std::shared_ptr<HeifFile> file = m_heif_context->get_heif_file();
+
+
+  // --- apply image transformations
+
+  Error error;
+
+  if (options.ignore_transformations == false) {
+    Result<std::vector<std::shared_ptr<Box>>> propertiesResult = get_properties();
+    if (!propertiesResult) {
+      return propertiesResult.error();
+    }
+
+    const std::vector<std::shared_ptr<Box>>& properties = *propertiesResult;
+
+    for (const auto& property : properties) {
+      if (auto rot = std::dynamic_pointer_cast<Box_irot>(property)) {
+        auto rotateResult = img->rotate_ccw(rot->get_rotation_ccw(), m_heif_context->get_security_limits());
+        if (!rotateResult) {
+          return error;
+        }
+
+        img = *rotateResult;
+      }
+
+
+      if (auto mirror = std::dynamic_pointer_cast<Box_imir>(property)) {
+        auto mirrorResult = img->mirror_inplace(mirror->get_mirror_direction(),
+                                                get_context()->get_security_limits());
+        if (!mirrorResult) {
+          return error;
+        }
+        img = *mirrorResult;
+      }
+
+
+      if (!decode_tile_only) {
+        // For tiles decoding, we do not process the 'clap' because this is handled by a shift of the tiling grid.
+
+        if (auto clap = std::dynamic_pointer_cast<Box_clap>(property)) {
+          std::shared_ptr<HeifPixelImage> clap_img;
+
+          uint32_t img_width = img->get_width();
+          uint32_t img_height = img->get_height();
+
+          int left = clap->left_rounded(img_width);
+          int right = clap->right_rounded(img_width);
+          int top = clap->top_rounded(img_height);
+          int bottom = clap->bottom_rounded(img_height);
+
+          if (left < 0) { left = 0; }
+          if (top < 0) { top = 0; }
+
+          if ((uint32_t) right >= img_width) { right = img_width - 1; }
+          if ((uint32_t) bottom >= img_height) { bottom = img_height - 1; }
+
+          if (left > right ||
+              top > bottom) {
+            return Error(heif_error_Invalid_input,
+                         heif_suberror_Invalid_clean_aperture);
+          }
+
+          auto cropResult = img->crop(left, right, top, bottom, m_heif_context->get_security_limits());
+          if (!cropResult) {
+            return cropResult.error();
+          }
+
+          img = *cropResult;
+        }
+      }
+    }
+  }
+
+
+  // --- add alpha channel, if available
+
+  // TODO: this if statement is probably wrong. When we have a tiled image with alpha
+  // channel, then the alpha images should be associated with their respective tiles.
+  // However, the tile images are not part of the m_all_images list.
+  // Fix this, when we have a test image available.
+
+  std::shared_ptr<ImageItem> alpha_image = get_alpha_channel();
+  if (alpha_image) {
+    if (alpha_image->get_item_error()) {
+      return alpha_image->get_item_error();
+    }
+
+    auto alphaDecodingResult = alpha_image->decode_image(options, decode_tile_only, tile_x0, tile_y0, processed_ids);
+    if (!alphaDecodingResult) {
+      return alphaDecodingResult.error();
+    }
+
+    std::shared_ptr<HeifPixelImage> alpha = *alphaDecodingResult;
+
+    // TODO: check that sizes are the same and that we have an Y channel
+    // BUT: is there any indication in the standard that the alpha channel should have the same size?
+
+    // TODO: convert in case alpha is decoded as RGB interleaved
+
+    heif_channel channel;
+    switch (alpha->get_colorspace()) {
+      case heif_colorspace_YCbCr:
+      case heif_colorspace_monochrome:
+        channel = heif_channel_Y;
+        break;
+      case heif_colorspace_RGB:
+        channel = heif_channel_R;
+        break;
+      case heif_colorspace_undefined:
+      default:
+        return Error(heif_error_Invalid_input,
+                     heif_suberror_Unsupported_color_conversion);
+    }
+
+
+    // TODO: we should include a decoding option to control whether libheif should automatically scale the alpha channel, and if so, which scaling filter (enum: Off, NN, Bilinear, ...).
+    //       It might also be that a specific output format implies that alpha is scaled (RGBA32). That would favor an enum for the scaling filter option + a bool to switch auto-filtering on.
+    //       But we can only do this when libheif itself doesn't assume anymore that the alpha channel has the same resolution.
+
+    if ((alpha_image->get_width() != img->get_width()) || (alpha_image->get_height() != img->get_height())) {
+      std::shared_ptr<HeifPixelImage> scaled_alpha;
+      Error err = alpha->scale_nearest_neighbor(scaled_alpha, img->get_width(), img->get_height(), m_heif_context->get_security_limits());
+      if (err) {
+        return err;
+      }
+      alpha = std::move(scaled_alpha);
+    }
+    img->transfer_plane_from_image_as(alpha, channel, heif_channel_Alpha);
+
+    if (is_premultiplied_alpha()) {
+      img->set_premultiplied_alpha(true);
+    }
+  }
+
+
+  // --- set color profile
+
+  // If there is an NCLX profile in the HEIF/AVIF metadata, use this for the color conversion.
+  // Otherwise, use the profile that is stored in the image stream itself and then set the
+  // (non-NCLX) profile later.
+  auto nclx = get_color_profile_nclx();
+  if (!nclx.is_undefined()) {
+    img->set_color_profile_nclx(nclx);
+  }
+
+  auto icc = get_color_profile_icc();
+  if (icc) {
+    img->set_color_profile_icc(icc);
+  }
+
+
+  // --- attach metadata to image
+
+  {
+    auto ipco_box = file->get_ipco_box();
+    auto ipma_box = file->get_ipma_box();
+
+    // CLLI
+
+    auto clli = get_property<Box_clli>();
+    if (clli) {
+      img->set_clli(clli->clli);
+    }
+
+    // MDCV
+
+    auto mdcv = get_property<Box_mdcv>();
+    if (mdcv) {
+      img->set_mdcv(mdcv->mdcv);
+    }
+
+    // PASP
+
+    auto pasp = get_property<Box_pasp>();
+    if (pasp) {
+      img->set_pixel_ratio(pasp->hSpacing, pasp->vSpacing);
+    }
+
+    // TAI
+
+    auto itai = get_property<Box_itai>();
+    if (itai) {
+      img->set_tai_timestamp(itai->get_tai_timestamp_packet());
+    }
+
+    // GIMI content ID
+
+    auto gimi_content_id = get_property<Box_gimi_content_id>();
+    if (gimi_content_id) {
+      img->set_gimi_sample_content_id(gimi_content_id->get_content_id());
+    }
+
+#if HEIF_WITH_OMAF
+    // Image projection (OMAF)
+    auto prfr = get_property<Box_prfr>();
+    if (prfr) {
+      img->set_omaf_image_projection(prfr->get_omaf_image_projection());
+    }
+#endif
+  }
+
+
+  return img;
+}
+
+#if 0
+Result<std::vector<uint8_t>> ImageItem::read_bitstream_configuration_data_override(heif_item_id itemId, heif_compression_format format) const
+{
+  auto item_codec = ImageItem::alloc_for_compression_format(const_cast<HeifContext*>(get_context()), format);
+  assert(item_codec);
+
+  Error err = item_codec->init_decoder_from_item(itemId);
+  if (err) {
+    return err;
+  }
+
+  return item_codec->read_bitstream_configuration_data(itemId);
+}
+#endif
+
+Result<std::shared_ptr<HeifPixelImage>> ImageItem::decode_compressed_image(const heif_decoding_options& options,
+                                                                           bool decode_tile_only, uint32_t tile_x0, uint32_t tile_y0,
+                                                                           std::set<heif_item_id> processed_ids) const
+{
+  if (processed_ids.contains(m_id)) {
+    return Error{heif_error_Invalid_input,
+                 heif_suberror_Unspecified,
+                 "'iref' has cyclic references"};
+  }
+
+  processed_ids.insert(m_id);
+
+
+  DataExtent extent;
+  extent.set_from_image_item(get_file(), get_id());
+
+  auto decoderResult = get_decoder();
+  if (!decoderResult) {
+    return decoderResult.error();
+  }
+
+  auto decoder = *decoderResult;
+
+  decoder->set_data_extent(std::move(extent));
+
+  return decoder->decode_single_frame_from_compressed_data(options,
+                                                           get_context()->get_security_limits());
+}
+
+
+heif_image_tiling ImageItem::get_heif_image_tiling() const
+{
+  // --- Return a dummy tiling consisting of only a single tile for the whole image
+
+  heif_image_tiling tiling{};
+
+  tiling.version = 1;
+  tiling.num_columns = 1;
+  tiling.num_rows = 1;
+
+  tiling.tile_width = m_width;
+  tiling.tile_height = m_height;
+  tiling.image_width = m_width;
+  tiling.image_height = m_height;
+
+  tiling.top_offset = 0;
+  tiling.left_offset = 0;
+  tiling.number_of_extra_dimensions = 0;
+
+  for (uint32_t& s : tiling.extra_dimension_size) {
+    s = 0;
+  }
+
+  return tiling;
+}
+
+
+Result<std::vector<std::shared_ptr<Box>>> ImageItem::get_properties() const
+{
+  std::vector<std::shared_ptr<Box>> properties;
+  auto ipco_box = get_file()->get_ipco_box();
+  auto ipma_box = get_file()->get_ipma_box();
+  Error error = ipco_box->get_properties_for_item_ID(m_id, ipma_box, properties);
+  if (error) {
+    return error;
+  }
+
+  return properties;
+}
+
+
+bool ImageItem::has_essential_property_other_than(const std::set<uint32_t>& props) const
+{
+  Result<std::vector<std::shared_ptr<Box>>> propertiesResult = get_properties();
+  if (!propertiesResult) {
+    return false;
+  }
+
+  for (const auto& property : *propertiesResult) {
+    if (is_property_essential(property) &&
+        props.find(property->get_short_type()) == props.end()) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+
+Error ImageItem::process_image_transformations_on_tiling(heif_image_tiling& tiling) const
+{
+  Result<std::vector<std::shared_ptr<Box>>> propertiesResult = get_properties();
+  if (!propertiesResult) {
+    return propertiesResult.error();
+  }
+
+  const std::vector<std::shared_ptr<Box>>& properties = *propertiesResult;
+
+  uint32_t left_excess = 0;
+  uint32_t top_excess = 0;
+  uint32_t right_excess;
+  uint32_t bottom_excess;
+
+  // Prevent divide by zero.
+
+  if (tiling.tile_width != 0 && tiling.tile_height != 0) {
+    right_excess = tiling.image_width % tiling.tile_width;
+    bottom_excess = tiling.image_height % tiling.tile_height;
+  }
+  else {
+    right_excess = 0;
+    bottom_excess = 0;
+  }
+
+
+  for (const auto& property : properties) {
+
+    // --- rotation
+
+    if (auto rot = std::dynamic_pointer_cast<Box_irot>(property)) {
+      int angle = rot->get_rotation_ccw();
+      if (angle == 90 || angle == 270) {
+        std::swap(tiling.tile_width, tiling.tile_height);
+        std::swap(tiling.image_width, tiling.image_height);
+        std::swap(tiling.num_rows, tiling.num_columns);
+      }
+
+      switch (angle) {
+        case 0:
+          break;
+        case 180:
+          std::swap(left_excess, right_excess);
+          std::swap(top_excess, bottom_excess);
+          break;
+        case 90: {
+          uint32_t old_top_excess = top_excess;
+          top_excess = right_excess;
+          right_excess = bottom_excess;
+          bottom_excess = left_excess;
+          left_excess = old_top_excess;
+          break;
+        }
+        case 270: {
+          uint32_t old_top_excess = top_excess;
+          top_excess = left_excess;
+          left_excess = bottom_excess;
+          bottom_excess = right_excess;
+          right_excess = old_top_excess;
+          break;
+        }
+        default:
+          assert(false);
+          break;
+      }
+    }
+
+    // --- mirror
+
+    if (auto mirror = std::dynamic_pointer_cast<Box_imir>(property)) {
+      switch (mirror->get_mirror_direction()) {
+        case heif_transform_mirror_direction_horizontal:
+          std::swap(left_excess, right_excess);
+          break;
+        case heif_transform_mirror_direction_vertical:
+          std::swap(top_excess, bottom_excess);
+          break;
+        default:
+          assert(false);
+          break;
+      }
+    }
+
+    // --- crop
+
+    if (auto clap = std::dynamic_pointer_cast<Box_clap>(property)) {
+      std::shared_ptr<HeifPixelImage> clap_img;
+
+      int left = clap->left_rounded(tiling.image_width);
+      int right = clap->right_rounded(tiling.image_width);
+      int top = clap->top_rounded(tiling.image_height);
+      int bottom = clap->bottom_rounded(tiling.image_height);
+
+      if (left < 0) { left = 0; }
+      if (top < 0) { top = 0; }
+
+      if ((uint32_t)right >= tiling.image_width) { right = tiling.image_width - 1; }
+      if ((uint32_t)bottom >= tiling.image_height) { bottom = tiling.image_height - 1; }
+
+      if (left > right ||
+          top > bottom) {
+        return {heif_error_Invalid_input,
+                heif_suberror_Invalid_clean_aperture};
+      }
+
+      left_excess += left;
+      right_excess += right;
+      top_excess += top;
+      bottom_excess += bottom;
+    }
+  }
+
+  tiling.left_offset = left_excess;
+  tiling.top_offset = top_excess;
+
+  return Error::Ok;
+}
diff --git a/libheif/image-items/image_item.h b/libheif/image-items/image_item.h
new file mode 100644
index 0000000000..389ff74700
--- /dev/null
+++ b/libheif/image-items/image_item.h
@@ -0,0 +1,507 @@
+/*
+ * HEIF image base codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_IMAGEITEM_H
+#define LIBHEIF_IMAGEITEM_H
+
+#include "api/libheif/heif.h"
+#include "error.h"
+#include "nclx.h"
+#include <string>
+#include <vector>
+#include <memory>
+#include <utility>
+#include <set>
+
+#include "pixelimage.h"
+#include "api/libheif/heif_plugin.h"
+#include "codecs/encoder.h"
+
+
+class HeifContext;
+
+class HeifPixelImage;
+
+
+class ImageMetadata
+{
+public:
+  heif_item_id item_id;
+  std::string item_type;  // e.g. "Exif"
+  std::string content_type;
+  std::string item_uri_type;
+  std::vector<uint8_t> m_data;
+};
+
+
+class ImageItem : public ImageExtraData,
+                  public ErrorBuffer
+{
+public:
+  ImageItem(HeifContext* ctx);
+
+  ImageItem(HeifContext* ctx, heif_item_id id);
+
+  static std::shared_ptr<ImageItem> alloc_for_infe_box(HeifContext*, const std::shared_ptr<Box_infe>&);
+
+  static std::shared_ptr<ImageItem> alloc_for_compression_format(HeifContext*, heif_compression_format);
+
+  static heif_compression_format compression_format_from_fourcc_infe_type(uint32_t type);
+
+  static uint32_t compression_format_to_fourcc_infe_type(heif_compression_format);
+
+  virtual uint32_t get_infe_type() const { return 0; }
+
+  virtual const char* get_auxC_alpha_channel_type() const { return "urn:mpeg:mpegB:cicp:systems:auxiliary:alpha"; }
+
+  virtual bool is_ispe_essential() const { return false; }
+
+  bool is_property_essential(const std::shared_ptr<Box>& property) const;
+
+  virtual Error get_item_error() const { return Error::Ok; }
+
+  virtual heif_compression_format get_compression_format() const { return heif_compression_undefined; }
+
+  virtual Result<std::vector<uint8_t>> read_bitstream_configuration_data() const { return std::vector<uint8_t>{}; }
+
+  void clear()
+  {
+    m_thumbnails.clear();
+    m_alpha_channel.reset();
+    m_depth_channel.reset();
+    m_aux_images.clear();
+  }
+
+  HeifContext* get_context() { return m_heif_context; }
+
+  const HeifContext* get_context() const { return m_heif_context; }
+
+  std::shared_ptr<class HeifFile> get_file() const;
+
+  void set_properties(std::vector<std::shared_ptr<Box>> properties) {
+    m_properties = std::move(properties);
+  }
+
+  template<class BoxType>
+  std::shared_ptr<BoxType> get_property() const
+  {
+    for (auto& property : m_properties) {
+      if (auto box = std::dynamic_pointer_cast<BoxType>(property)) {
+        return box;
+      }
+    }
+
+    return nullptr;
+  }
+
+  template<class BoxType>
+  std::vector<std::shared_ptr<const BoxType>> get_all_properties() const
+  {
+    std::vector<std::shared_ptr<const BoxType>> result;
+    for (auto& property : m_properties) {
+      if (auto box = std::dynamic_pointer_cast<const BoxType>(property)) {
+        result.push_back(box);
+      }
+    }
+    return result;
+  }
+
+  heif_property_id add_property(std::shared_ptr<Box> property, bool essential);
+
+  heif_property_id add_property_without_deduplication(std::shared_ptr<Box> property, bool essential);
+
+  void set_resolution(uint32_t w, uint32_t h)
+  {
+    m_width = w;
+    m_height = h;
+  }
+
+  heif_item_id get_id() const { return m_id; }
+
+  void set_id(heif_item_id id) { m_id = id; }
+
+  void set_primary(bool flag = true) { m_is_primary = flag; }
+
+  bool is_primary() const { return m_is_primary; }
+
+  // 32bit limitation from `ispe`
+  uint32_t get_width() const { return m_width; }
+
+  uint32_t get_height() const { return m_height; }
+
+  bool has_ispe_resolution() const;
+
+  uint32_t get_ispe_width() const;
+
+  uint32_t get_ispe_height() const;
+
+  // Default behavior: forward call to Decoder
+  [[nodiscard]] virtual int get_luma_bits_per_pixel() const;
+
+  // Default behavior: forward call to Decoder
+  [[nodiscard]] virtual int get_chroma_bits_per_pixel() const;
+
+  void set_size(uint32_t w, uint32_t h)
+  {
+    m_width = w;
+    m_height = h;
+  }
+
+  virtual void get_tile_size(uint32_t& w, uint32_t& h) const;
+
+  virtual Error get_coded_image_colorspace(heif_colorspace* out_colorspace, heif_chroma* out_chroma) const;
+
+  Error postprocess_coded_image_colorspace(heif_colorspace* inout_colorspace, heif_chroma* inout_chroma) const;
+
+  virtual Error process_before_write() { return {}; }
+
+  // -- thumbnails
+
+  void set_is_thumbnail()
+  {
+    m_is_thumbnail = true;
+  }
+
+  void add_thumbnail(const std::shared_ptr<ImageItem>& img) { m_thumbnails.push_back(img); }
+
+  bool is_thumbnail() const { return m_is_thumbnail; }
+
+  const std::vector<std::shared_ptr<ImageItem>>& get_thumbnails() const { return m_thumbnails; }
+
+
+  // --- alpha channel
+
+  void set_is_alpha_channel()
+  {
+    m_is_alpha_channel = true;
+  }
+
+  void set_alpha_channel(std::shared_ptr<ImageItem> img) { m_alpha_channel = std::move(img); }
+
+  bool is_alpha_channel() const { return m_is_alpha_channel; }
+
+  const std::shared_ptr<ImageItem>& get_alpha_channel() const { return m_alpha_channel; }
+
+  void set_is_premultiplied_alpha(bool flag) { m_premultiplied_alpha = flag; }
+
+  bool is_premultiplied_alpha() const { return m_premultiplied_alpha; }
+
+  // Whether the image has an alpha channel coded in the main image (not as an auxiliary image)
+  virtual bool has_coded_alpha_channel() const { return false; }
+
+  // --- depth channel
+
+  void set_is_depth_channel()
+  {
+    m_is_depth_channel = true;
+  }
+
+  void set_depth_channel(std::shared_ptr<ImageItem> img) { m_depth_channel = std::move(img); }
+
+  bool is_depth_channel() const { return m_is_depth_channel; }
+
+  const std::shared_ptr<ImageItem>& get_depth_channel() const { return m_depth_channel; }
+
+
+  void set_depth_representation_info(heif_depth_representation_info& info)
+  {
+    m_has_depth_representation_info = true;
+    m_depth_representation_info = info;
+  }
+
+  bool has_depth_representation_info() const
+  {
+    return m_has_depth_representation_info;
+  }
+
+  const heif_depth_representation_info& get_depth_representation_info() const
+  {
+    return m_depth_representation_info;
+  }
+
+
+  // --- generic aux image
+
+  void set_is_aux_image(const std::string& aux_type)
+  {
+    m_is_aux_image = true;
+    m_aux_image_type = aux_type;
+  }
+
+  void add_aux_image(std::shared_ptr<ImageItem> img) { m_aux_images.push_back(std::move(img)); }
+
+  bool is_aux_image() const { return m_is_aux_image; }
+
+  const std::string& get_aux_type() const { return m_aux_image_type; }
+
+  std::vector<std::shared_ptr<ImageItem>> get_aux_images(int aux_image_filter = 0) const
+  {
+    if (aux_image_filter == 0) {
+      return m_aux_images;
+    }
+    else {
+      std::vector<std::shared_ptr<ImageItem>> auxImgs;
+      for (const auto& aux : m_aux_images) {
+        if ((aux_image_filter & LIBHEIF_AUX_IMAGE_FILTER_OMIT_ALPHA) && aux->is_alpha_channel()) {
+          continue;
+        }
+
+        if ((aux_image_filter & LIBHEIF_AUX_IMAGE_FILTER_OMIT_DEPTH) &&
+            aux->is_depth_channel()) {
+          continue;
+        }
+
+        auxImgs.push_back(aux);
+      }
+
+      return auxImgs;
+    }
+  }
+
+
+  // --- metadata
+
+  void add_metadata(std::shared_ptr<ImageMetadata> metadata)
+  {
+    m_metadata.push_back(std::move(metadata));
+  }
+
+  const std::vector<std::shared_ptr<ImageMetadata>>& get_metadata() const { return m_metadata; }
+
+
+
+  // --- ImageExtraData
+
+  void set_clli(const heif_content_light_level& clli) override;
+
+  void set_mdcv(const heif_mastering_display_colour_volume& mdcv) override;
+
+  void set_pixel_ratio(uint32_t h, uint32_t v) override;
+
+  void set_color_profile_nclx(const nclx_profile& profile) override;
+
+  void set_color_profile_icc(const std::shared_ptr<const color_profile_raw>& profile) override;
+
+#if HEIF_WITH_OMAF
+  void set_omaf_image_projection(heif_omaf_image_projection image_projection) override;
+#endif
+
+  // --- miaf
+
+  // TODO: we should have a function that checks all MIAF constraints and sets the compatibility flag.
+  void mark_not_miaf_compatible() { m_miaf_compatible = false; }
+
+  bool is_miaf_compatible() const { return m_miaf_compatible; }
+
+  // return 0 if we don't know the brand
+  virtual heif_brand2 get_compatible_brand() const { return 0; }
+
+  // === decoding ===
+
+  virtual Error initialize_decoder() { return Error::Ok; }
+
+  virtual void set_decoder_input_data() { }
+
+  virtual Result<std::shared_ptr<HeifPixelImage>> decode_image(const heif_decoding_options& options,
+                                                               bool decode_tile_only, uint32_t tile_x0,
+                                                               uint32_t tile_y0,
+                                                               std::set<heif_item_id> processed_ids) const;
+
+  virtual Result<std::shared_ptr<HeifPixelImage>> decode_compressed_image(const heif_decoding_options& options,
+                                                                          bool decode_tile_only, uint32_t tile_x0,
+                                                                          uint32_t tile_y0,
+                                                                          std::set<heif_item_id> processed_ids) const;
+
+  Result<std::vector<std::shared_ptr<Box>>> get_properties() const;
+
+  bool has_essential_property_other_than(const std::set<uint32_t>&) const;
+
+  // === encoding ===
+
+  Result<Encoder::CodedImageData> encode_to_bitstream_and_boxes(const std::shared_ptr<HeifPixelImage>& image,
+                                                                heif_encoder* encoder,
+                                                                const heif_encoding_options& options,
+                                                                heif_image_input_class input_class);
+
+  // Entry point for encoding pixel images.
+  Error encode_to_item(HeifContext* ctx,
+                       const std::shared_ptr<HeifPixelImage>& image,
+                       heif_encoder* encoder,
+                       const heif_encoding_options& options,
+                       heif_image_input_class input_class);
+
+  void set_intrinsic_matrix(const Box_cmin::RelativeIntrinsicMatrix& cmin) {
+    m_has_intrinsic_matrix = true;
+    m_intrinsic_matrix = cmin.to_absolute(get_ispe_width(), get_ispe_height());
+  }
+
+  bool has_intrinsic_matrix() const { return m_has_intrinsic_matrix; }
+
+  Box_cmin::AbsoluteIntrinsicMatrix& get_intrinsic_matrix() { return m_intrinsic_matrix; }
+
+  const Box_cmin::AbsoluteIntrinsicMatrix& get_intrinsic_matrix() const { return m_intrinsic_matrix; }
+
+
+  void set_extrinsic_matrix(const Box_cmex::ExtrinsicMatrix& cmex) {
+    m_has_extrinsic_matrix = true;
+    m_extrinsic_matrix = cmex;
+  }
+
+  bool has_extrinsic_matrix() const { return m_has_extrinsic_matrix; }
+
+  Box_cmex::ExtrinsicMatrix& get_extrinsic_matrix() { return m_extrinsic_matrix; }
+
+  const Box_cmex::ExtrinsicMatrix& get_extrinsic_matrix() const { return m_extrinsic_matrix; }
+
+
+  void add_region_item_id(heif_item_id id) { m_region_item_ids.push_back(id); }
+
+  const std::vector<heif_item_id>& get_region_item_ids() const { return m_region_item_ids; }
+
+
+  void add_decoding_warning(Error err) { m_decoding_warnings.emplace_back(std::move(err)); }
+
+  const std::vector<Error>& get_decoding_warnings() const { return m_decoding_warnings; }
+
+  virtual heif_image_tiling get_heif_image_tiling() const;
+
+  Error process_image_transformations_on_tiling(heif_image_tiling&) const;
+
+  Error transform_requested_tile_position_to_original_tile_position(uint32_t& tile_x, uint32_t& tile_y) const;
+
+  virtual Result<std::shared_ptr<class Decoder>> get_decoder() const
+  {
+    return Error{
+      heif_error_Unsupported_feature,
+      heif_suberror_No_matching_decoder_installed,
+      "No decoder for this image format"
+    };
+  }
+
+  virtual std::shared_ptr<class Encoder> get_encoder() const { return nullptr; }
+
+  void add_text_item_id(heif_item_id id) {
+    m_text_item_ids.push_back(id);
+  }
+
+  const std::vector<heif_item_id>& get_text_item_ids() const { return m_text_item_ids; }
+
+private:
+  HeifContext* m_heif_context;
+  std::vector<std::shared_ptr<Box>> m_properties;
+
+  heif_item_id m_id = 0;
+  uint32_t m_width = 0, m_height = 0;  // after all transformations have been applied
+  bool m_is_primary = false;
+
+  bool m_is_thumbnail = false;
+
+  std::vector<std::shared_ptr<ImageItem>> m_thumbnails;
+
+  bool m_is_alpha_channel = false;
+  bool m_premultiplied_alpha = false;
+  std::shared_ptr<ImageItem> m_alpha_channel;
+
+  bool m_is_depth_channel = false;
+  std::shared_ptr<ImageItem> m_depth_channel;
+
+  bool m_has_depth_representation_info = false;
+  heif_depth_representation_info m_depth_representation_info;
+
+  bool m_is_aux_image = false;
+  std::string m_aux_image_type;
+  std::vector<std::shared_ptr<ImageItem>> m_aux_images;
+
+  std::vector<std::shared_ptr<ImageMetadata>> m_metadata;
+
+  bool m_miaf_compatible = true;
+
+  std::vector<heif_item_id> m_region_item_ids;
+
+  bool m_has_intrinsic_matrix = false;
+  Box_cmin::AbsoluteIntrinsicMatrix m_intrinsic_matrix{};
+
+  bool m_has_extrinsic_matrix = false;
+  Box_cmex::ExtrinsicMatrix m_extrinsic_matrix{};
+
+  std::vector<Error> m_decoding_warnings;
+
+  std::vector<heif_item_id> m_text_item_ids;
+
+  void generate_property_boxes_for_ImageExtraData();
+
+protected:
+  // Result<std::vector<uint8_t>> read_bitstream_configuration_data_override(heif_item_id itemId, heif_compression_format format) const;
+
+  virtual Result<Encoder::CodedImageData> encode(const std::shared_ptr<HeifPixelImage>& image,
+                                                 heif_encoder* encoder,
+                                                 const heif_encoding_options& options,
+                                                 heif_image_input_class input_class);
+
+  // --- encoding utility functions
+
+  static std::vector<std::shared_ptr<Box_colr> >
+  add_color_profile(const std::shared_ptr<HeifPixelImage>& image,
+                    const heif_encoding_options& options,
+                    heif_image_input_class input_class,
+                    const heif_color_profile_nclx* target_heif_nclx);
+};
+
+
+class ImageItem_Error : public ImageItem
+{
+public:
+  // dummy ImageItem class that is a placeholder for unsupported item types
+
+  ImageItem_Error(uint32_t item_type, heif_item_id id, Error err)
+    : ImageItem(nullptr, id), m_item_type(item_type), m_item_error(err) {}
+
+  uint32_t get_infe_type() const override
+  {
+    return m_item_type;
+  }
+
+  Error get_item_error() const override { return m_item_error; }
+
+  Result<std::shared_ptr<HeifPixelImage>> decode_image(const heif_decoding_options& options,
+                                                       bool decode_tile_only, uint32_t tile_x0,
+                                                       uint32_t tile_y0,
+                                                       std::set<heif_item_id> processed_ids) const override
+  {
+    return m_item_error;
+  }
+
+  Result<std::shared_ptr<HeifPixelImage>> decode_compressed_image(const heif_decoding_options& options,
+                                                                  bool decode_tile_only, uint32_t tile_x0,
+                                                                  uint32_t tile_y0, std::set<heif_item_id> processed_ids) const override
+  {
+    return m_item_error;
+  }
+
+  [[nodiscard]] int get_luma_bits_per_pixel() const override { return -1; }
+
+  [[nodiscard]] int get_chroma_bits_per_pixel() const override { return -1; }
+
+private:
+  uint32_t m_item_type;
+  Error m_item_error;
+};
+
+#endif //LIBHEIF_IMAGEITEM_H
diff --git a/libheif/image-items/jpeg.cc b/libheif/image-items/jpeg.cc
new file mode 100644
index 0000000000..560f361377
--- /dev/null
+++ b/libheif/image-items/jpeg.cc
@@ -0,0 +1,86 @@
+/*
+ * HEIF JPEG codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "jpeg.h"
+#include "codecs/jpeg_dec.h"
+#include "codecs/jpeg_enc.h"
+#include "codecs/jpeg_boxes.h"
+#include "security_limits.h"
+#include "pixelimage.h"
+#include "api_structs.h"
+#include <cstring>
+#include <utility>
+
+
+ImageItem_JPEG::ImageItem_JPEG(HeifContext* ctx, heif_item_id id)
+    : ImageItem(ctx, id)
+{
+  m_encoder = std::make_shared<Encoder_JPEG>();
+}
+
+ImageItem_JPEG::ImageItem_JPEG(HeifContext* ctx)
+    : ImageItem(ctx)
+{
+  m_encoder = std::make_shared<Encoder_JPEG>();
+}
+
+
+Result<std::vector<uint8_t>> ImageItem_JPEG::read_bitstream_configuration_data() const
+{
+  return m_decoder->read_bitstream_configuration_data();
+}
+
+
+Result<std::shared_ptr<Decoder>> ImageItem_JPEG::get_decoder() const
+{
+  return {m_decoder};
+}
+
+
+std::shared_ptr<Encoder> ImageItem_JPEG::get_encoder() const
+{
+  return m_encoder;
+}
+
+
+Error ImageItem_JPEG::initialize_decoder()
+{
+  // Note: jpgC box is optional. NULL is a valid value.
+  auto jpgC_box = get_property<Box_jpgC>();
+
+  m_decoder = std::make_shared<Decoder_JPEG>(jpgC_box);
+
+  return Error::Ok;
+}
+
+
+void ImageItem_JPEG::set_decoder_input_data()
+{
+  DataExtent extent;
+  extent.set_from_image_item(get_context()->get_heif_file(), get_id());
+
+  m_decoder->set_data_extent(std::move(extent));
+}
+
+
+heif_brand2 ImageItem_JPEG::get_compatible_brand() const
+{
+  return heif_brand2_jpeg;
+}
diff --git a/libheif/image-items/jpeg.h b/libheif/image-items/jpeg.h
new file mode 100644
index 0000000000..ad54bc6ac6
--- /dev/null
+++ b/libheif/image-items/jpeg.h
@@ -0,0 +1,60 @@
+/*
+ * HEIF JPEG codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_JPEG_H
+#define LIBHEIF_JPEG_H
+
+#include "box.h"
+#include <string>
+#include <vector>
+#include "image_item.h"
+#include <memory>
+
+
+class ImageItem_JPEG : public ImageItem
+{
+public:
+  ImageItem_JPEG(HeifContext* ctx, heif_item_id id);
+
+  ImageItem_JPEG(HeifContext* ctx);
+
+  uint32_t get_infe_type() const override { return fourcc("jpeg"); }
+
+  heif_compression_format get_compression_format() const override { return heif_compression_JPEG; }
+
+  Error initialize_decoder() override;
+
+  void set_decoder_input_data() override;
+
+  heif_brand2 get_compatible_brand() const override;
+
+protected:
+  Result<std::shared_ptr<Decoder>> get_decoder() const override;
+
+  std::shared_ptr<Encoder> get_encoder() const override;
+
+  Result<std::vector<uint8_t>> read_bitstream_configuration_data() const override;
+
+private:
+  std::shared_ptr<class Decoder_JPEG> m_decoder;
+  std::shared_ptr<class Encoder_JPEG> m_encoder;
+};
+
+#endif // LIBHEIF_JPEG_H
diff --git a/libheif/image-items/jpeg2000.cc b/libheif/image-items/jpeg2000.cc
new file mode 100644
index 0000000000..406b4a1aeb
--- /dev/null
+++ b/libheif/image-items/jpeg2000.cc
@@ -0,0 +1,102 @@
+/*
+ * HEIF JPEG 2000 codec.
+ * Copyright (c) 2023 Brad Hards <bradh@frogmouth.net>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "jpeg2000.h"
+#include "api_structs.h"
+#include "codecs/jpeg2000_dec.h"
+#include "codecs/jpeg2000_enc.h"
+#include "codecs/jpeg2000_boxes.h"
+#include <cstdint>
+#include <utility>
+
+
+ImageItem_JPEG2000::ImageItem_JPEG2000(HeifContext* ctx, heif_item_id id)
+    : ImageItem(ctx, id)
+{
+  m_encoder = std::make_shared<Encoder_JPEG2000>();
+}
+
+
+ImageItem_JPEG2000::ImageItem_JPEG2000(HeifContext* ctx)
+    : ImageItem(ctx)
+{
+  m_encoder = std::make_shared<Encoder_JPEG2000>();
+}
+
+
+Result<std::vector<uint8_t>> ImageItem_JPEG2000::read_bitstream_configuration_data() const
+{
+  // --- get codec configuration
+
+  std::shared_ptr<Box_j2kH> j2kH_box = get_property<Box_j2kH>();
+  if (!j2kH_box)
+  {
+    // TODO - Correctly Find the j2kH box
+    //  return Error(heif_error_Invalid_input,
+    //               heif_suberror_Unspecified);
+  }
+  // else if (!j2kH_box->get_headers(data)) {
+  //   return Error(heif_error_Invalid_input,
+  //                heif_suberror_No_item_data);
+  // }
+
+  return std::vector<uint8_t>{};
+}
+
+
+Result<std::shared_ptr<Decoder>> ImageItem_JPEG2000::get_decoder() const
+{
+  return {m_decoder};
+}
+
+
+std::shared_ptr<class Encoder> ImageItem_JPEG2000::get_encoder() const
+{
+  return m_encoder;
+}
+
+
+Error ImageItem_JPEG2000::initialize_decoder()
+{
+  auto j2kH = get_property<Box_j2kH>();
+  if (!j2kH) {
+    return Error{heif_error_Invalid_input,
+                 heif_suberror_Unspecified,
+                 "No j2kH box found."};
+  }
+
+  m_decoder = std::make_shared<Decoder_JPEG2000>(j2kH);
+
+  return Error::Ok;
+}
+
+
+void ImageItem_JPEG2000::set_decoder_input_data()
+{
+  DataExtent extent;
+  extent.set_from_image_item(get_context()->get_heif_file(), get_id());
+
+  m_decoder->set_data_extent(std::move(extent));
+}
+
+heif_brand2 ImageItem_JPEG2000::get_compatible_brand() const
+{
+  return heif_brand2_j2ki;
+}
diff --git a/libheif/image-items/jpeg2000.h b/libheif/image-items/jpeg2000.h
new file mode 100644
index 0000000000..991e8c6a33
--- /dev/null
+++ b/libheif/image-items/jpeg2000.h
@@ -0,0 +1,63 @@
+/*
+ * HEIF JPEG 2000 codec.
+ * Copyright (c) 2023 Brad Hards <bradh@frogmouth.net>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_JPEG2000_H
+#define LIBHEIF_JPEG2000_H
+
+#include "box.h"
+#include "file.h"
+#include "context.h"
+#include <cstdint>
+#include <string>
+#include <vector>
+#include <memory>
+
+
+class ImageItem_JPEG2000 : public ImageItem
+{
+public:
+  ImageItem_JPEG2000(HeifContext* ctx, heif_item_id id);
+
+  ImageItem_JPEG2000(HeifContext* ctx);
+
+  uint32_t get_infe_type() const override { return fourcc("j2k1"); }
+
+  heif_compression_format get_compression_format() const override { return heif_compression_JPEG2000; }
+
+  heif_brand2 get_compatible_brand() const override;
+
+protected:
+  Result<std::vector<uint8_t>> read_bitstream_configuration_data() const override;
+
+  Result<std::shared_ptr<Decoder>> get_decoder() const override;
+
+  std::shared_ptr<Encoder> get_encoder() const override;
+
+public:
+  Error initialize_decoder() override;
+
+  void set_decoder_input_data() override;
+
+private:
+  std::shared_ptr<class Decoder_JPEG2000> m_decoder;
+  std::shared_ptr<class Encoder_JPEG2000> m_encoder;
+};
+
+#endif // LIBHEIF_JPEG2000_H
diff --git a/libheif/image-items/mask_image.cc b/libheif/image-items/mask_image.cc
new file mode 100644
index 0000000000..5492304d40
--- /dev/null
+++ b/libheif/image-items/mask_image.cc
@@ -0,0 +1,211 @@
+/*
+ * HEIF mask image codec.
+ *
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ * Copyright (c) 2023 Brad Hards <bradh@frogmouth.net>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <cstdint>
+#include <cstring>
+#include <algorithm>
+#include <map>
+#include <cstring>
+
+#include "libheif/heif.h"
+#include "logging.h"
+#include "mask_image.h"
+#include "image_item.h"
+#include "security_limits.h"
+
+
+Error Box_mskC::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  parse_full_box_header(range);
+  m_bits_per_pixel = range.read8();
+  return range.get_error();
+}
+
+std::string Box_mskC::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
+  sstr << indent << "bits_per_pixel: " << ((int)m_bits_per_pixel) << "\n";
+  return sstr.str();
+}
+
+Error Box_mskC::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+  writer.write8(m_bits_per_pixel);
+  prepend_header(writer, box_start);
+  return Error::Ok;
+}
+
+
+Error MaskImageCodec::decode_mask_image(const HeifContext* context,
+                                        heif_item_id ID,
+                                        std::shared_ptr<HeifPixelImage>& img,
+                                        const std::vector<uint8_t>& data)
+{
+  auto image = context->get_image(ID, false);
+  if (!image) {
+    return {heif_error_Invalid_input,
+            heif_suberror_Nonexisting_item_referenced};
+  }
+
+  std::shared_ptr<Box_ispe> ispe = image->get_property<Box_ispe>();
+  std::shared_ptr<Box_mskC> mskC = image->get_property<Box_mskC>();
+
+  if (!ispe || !mskC) {
+    return Error(heif_error_Unsupported_feature,
+                  heif_suberror_Unsupported_data_version,
+                  "Missing required box for mask codec");
+  }
+
+  uint32_t width = ispe->get_width();
+  uint32_t height = ispe->get_height();
+
+  Error error = check_for_valid_image_size(context->get_security_limits(), width, height);
+  if (error) {
+    return error;
+  }
+
+  if ((mskC->get_bits_per_pixel() != 8) && (mskC->get_bits_per_pixel() != 16))
+  {
+    return Error(heif_error_Unsupported_feature,
+                 heif_suberror_Unsupported_data_version,
+                 "Unsupported bit depth for mask item");
+  }
+
+  uint32_t bytes_per_pixel = (mskC->get_bits_per_pixel() + 7) / 8;
+
+  if (data.size() / (static_cast<size_t>(width) * bytes_per_pixel) < height) {
+    return {heif_error_Invalid_input,
+            heif_suberror_Unspecified,
+            "Mask image data is too short"};
+  }
+
+  img = std::make_shared<HeifPixelImage>();
+  img->create(width, height, heif_colorspace_monochrome, heif_chroma_monochrome);
+  auto err = img->add_plane(heif_channel_Y, width, height, mskC->get_bits_per_pixel(),
+                            context->get_security_limits());
+  if (err) {
+    return err;
+  }
+
+  size_t stride;
+  uint8_t* dst = img->get_plane(heif_channel_Y, &stride);
+  if (stride == static_cast<size_t>(width) * bytes_per_pixel) {
+    memcpy(dst, data.data(), static_cast<size_t>(width) * bytes_per_pixel * height);
+  }
+  else
+  {
+    for (size_t i = 0; i < height; i++)
+    {
+      memcpy(dst + i * stride, data.data() + i * width * bytes_per_pixel, width * bytes_per_pixel);
+    }
+  }
+  return Error::Ok;
+}
+
+
+Result<std::shared_ptr<HeifPixelImage>> ImageItem_mask::decode_compressed_image(const heif_decoding_options& options,
+                                                                                bool decode_tile_only, uint32_t tile_x0, uint32_t tile_y0,
+                                                                                std::set<heif_item_id> processed_ids) const
+{
+  std::shared_ptr<HeifPixelImage> img;
+
+  std::vector<uint8_t> data;
+
+  // image data, usually from 'mdat'
+
+  Error error = get_file()->append_data_from_iloc(get_id(), data);
+  if (error) {
+    return error;
+  }
+
+  Error err = MaskImageCodec::decode_mask_image(get_context(),
+                                                get_id(),
+                                                img,
+                                                data);
+  if (err) {
+    return err;
+  }
+  else {
+    return img;
+  }
+}
+
+
+Result<Encoder::CodedImageData> ImageItem_mask::encode(const std::shared_ptr<HeifPixelImage>& image,
+                                                       heif_encoder* encoder,
+                                                       const heif_encoding_options& options,
+                                                       heif_image_input_class input_class)
+{
+  Encoder::CodedImageData codedImageData;
+
+  if (image->get_colorspace() != heif_colorspace_monochrome)
+  {
+    return Error(heif_error_Unsupported_feature,
+                 heif_suberror_Unsupported_data_version,
+                 "Unsupported colourspace for mask region");
+  }
+
+  if (image->get_bits_per_pixel(heif_channel_Y) != 8)
+  {
+    return Error(heif_error_Unsupported_feature,
+                 heif_suberror_Unsupported_data_version,
+                 "Unsupported bit depth for mask region");
+  }
+
+  // TODO: we could add an option to lossless-compress this data
+  std::vector<uint8_t> data;
+  size_t src_stride;
+  uint8_t* src_data = image->get_plane(heif_channel_Y, &src_stride);
+
+  uint32_t w = image->get_width();
+  uint32_t h = image->get_height();
+
+  data.resize(w * h);
+
+  if (w == (uint32_t)src_stride) {
+    codedImageData.append(src_data, w*h);
+  }
+  else {
+    for (uint32_t y = 0; y < h; y++) {
+      codedImageData.append(src_data + y * src_stride, w);
+    }
+  }
+
+  std::shared_ptr<Box_mskC> mskC = std::make_shared<Box_mskC>();
+  mskC->set_bits_per_pixel(image->get_bits_per_pixel(heif_channel_Y));
+  codedImageData.properties.push_back(mskC);
+
+  return codedImageData;
+}
+
+
+int ImageItem_mask::get_luma_bits_per_pixel() const
+{
+  auto mskC = get_property<Box_mskC>();
+  if (!mskC) {
+    return -1;
+  }
+
+  return mskC->get_bits_per_pixel();
+}
diff --git a/libheif/image-items/mask_image.h b/libheif/image-items/mask_image.h
new file mode 100644
index 0000000000..5c94bf629b
--- /dev/null
+++ b/libheif/image-items/mask_image.h
@@ -0,0 +1,111 @@
+/*
+ * HEIF mask image codec.
+ *
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ * Copyright (c) 2023 Brad Hards <bradh@frogmouth.net>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef LIBHEIF_MASK_IMAGE_H
+#define LIBHEIF_MASK_IMAGE_H
+
+#include "box.h"
+#include "bitstream.h"
+#include "pixelimage.h"
+#include "file.h"
+#include "context.h"
+
+#include <memory>
+#include <string>
+#include <vector>
+#include <set>
+
+/**
+  * Mask Configuration Property (mskC).
+  *
+  * Each mask image item (mski) shall have an associated MaskConfigurationProperty
+  * that provides information required to generate the mask of the associated mask
+  * item.
+  */
+class Box_mskC : public FullBox
+{
+public:
+
+  Box_mskC()
+  {
+    set_short_type(fourcc("mskC"));
+  }
+
+  bool is_essential() const override { return true; }
+
+  std::string dump(Indent&) const override;
+
+  Error write(StreamWriter& writer) const override;
+
+  uint8_t get_bits_per_pixel() const
+  { return m_bits_per_pixel; }
+
+  void set_bits_per_pixel(uint8_t bits_per_pixel)
+  { m_bits_per_pixel = bits_per_pixel; }
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits* limits) override;
+
+private:
+  uint8_t m_bits_per_pixel = 0;
+};
+
+class MaskImageCodec
+{
+public:
+  static Error decode_mask_image(const HeifContext* context,
+                                  heif_item_id ID,
+                                  std::shared_ptr<HeifPixelImage>& img,
+                                  const std::vector<uint8_t>& data);
+};
+
+
+
+class ImageItem_mask : public ImageItem
+{
+public:
+  ImageItem_mask(HeifContext* ctx, heif_item_id id) : ImageItem(ctx, id) {}
+
+  ImageItem_mask(HeifContext* ctx) : ImageItem(ctx) {}
+
+  uint32_t get_infe_type() const override { return fourcc("mski"); }
+
+  heif_compression_format get_compression_format() const override { return heif_compression_mask; }
+
+  bool is_ispe_essential() const override { return true; }
+
+  int get_luma_bits_per_pixel() const override;
+
+  int get_chroma_bits_per_pixel() const override { return 0; }
+
+  Result<std::shared_ptr<HeifPixelImage>> decode_compressed_image(const heif_decoding_options& options,
+                                                                  bool decode_tile_only, uint32_t tile_x0, uint32_t tile_y0,
+                                                                  std::set<heif_item_id> processed_ids) const override;
+
+  Result<Encoder::CodedImageData> encode(const std::shared_ptr<HeifPixelImage>& image,
+                                         heif_encoder* encoder,
+                                         const heif_encoding_options& options,
+                                         heif_image_input_class input_class) override;
+};
+
+#endif //LIBHEIF_MASK_IMAGE_H
diff --git a/libheif/image-items/overlay.cc b/libheif/image-items/overlay.cc
new file mode 100644
index 0000000000..c45a0cebf4
--- /dev/null
+++ b/libheif/image-items/overlay.cc
@@ -0,0 +1,486 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "overlay.h"
+#include "context.h"
+#include "file.h"
+#include "color-conversion/colorconversion.h"
+#include "security_limits.h"
+
+
+template<typename I>
+void writevec(uint8_t* data, size_t& idx, I value, int len)
+{
+  for (int i = 0; i < len; i++) {
+    data[idx + i] = static_cast<uint8_t>((value >> (len - 1 - i) * 8) & 0xFF);
+  }
+
+  idx += len;
+}
+
+
+static int32_t readvec_signed(const std::vector<uint8_t>& data, int& ptr, int len)
+{
+  const uint32_t high_bit = UINT32_C(0x80) << ((len - 1) * 8);
+
+  uint32_t val = 0;
+  while (len--) {
+    val <<= 8;
+    val |= data[ptr++];
+  }
+
+  bool negative = (val & high_bit) != 0;
+
+  if (negative) {
+    return -static_cast<int32_t>((~val) & 0x7fffffff) -1;
+  }
+  else {
+    return static_cast<int32_t>(val);
+  }
+
+  return val;
+}
+
+
+static uint32_t readvec(const std::vector<uint8_t>& data, int& ptr, int len)
+{
+  uint32_t val = 0;
+  while (len--) {
+    val <<= 8;
+    val |= data[ptr++];
+  }
+
+  return val;
+}
+
+
+Error ImageOverlay::parse(size_t num_images, const std::vector<uint8_t>& data)
+{
+  Error eofError(heif_error_Invalid_input,
+                 heif_suberror_Invalid_overlay_data,
+                 "Overlay image data incomplete");
+
+  if (data.size() < 2 + 4 * 2) {
+    return eofError;
+  }
+
+  m_version = data[0];
+  if (m_version != 0) {
+    std::stringstream sstr;
+    sstr << "Overlay image data version " << ((int) m_version) << " is not implemented yet";
+
+    return {heif_error_Unsupported_feature,
+            heif_suberror_Unsupported_data_version,
+            sstr.str()};
+  }
+
+  m_flags = data[1];
+
+  int field_len = ((m_flags & 1) ? 4 : 2);
+  int ptr = 2;
+
+  if (ptr + 4 * 2 + 2 * field_len + num_images * 2 * field_len > data.size()) {
+    return eofError;
+  }
+
+  for (int i = 0; i < 4; i++) {
+    uint16_t color = static_cast<uint16_t>(readvec(data, ptr, 2));
+    m_background_color[i] = color;
+  }
+
+  m_width = readvec(data, ptr, field_len);
+  m_height = readvec(data, ptr, field_len);
+
+  if (m_width == 0 || m_height == 0) {
+    return {heif_error_Invalid_input,
+            heif_suberror_Invalid_overlay_data,
+            "Overlay image with zero width or height."};
+  }
+
+  m_offsets.resize(num_images);
+
+  for (size_t i = 0; i < num_images; i++) {
+    m_offsets[i].x = readvec_signed(data, ptr, field_len);
+    m_offsets[i].y = readvec_signed(data, ptr, field_len);
+  }
+
+  return Error::Ok;
+}
+
+
+std::vector<uint8_t> ImageOverlay::write() const
+{
+  assert(m_version == 0);
+
+  bool longFields = (m_width > 0xFFFF) || (m_height > 0xFFFF);
+  for (const auto& img : m_offsets) {
+    if (img.x > 0x7FFF || img.y > 0x7FFF || img.x < -32768 || img.y < -32768) {
+      longFields = true;
+      break;
+    }
+  }
+
+  std::vector<uint8_t> data;
+
+  data.resize(2 + 4 * 2 + (longFields ? 4 : 2) * (2 + m_offsets.size() * 2));
+
+  size_t idx = 0;
+  data[idx++] = m_version;
+  data[idx++] = (longFields ? 1 : 0); // flags
+
+  for (uint16_t color : m_background_color) {
+    writevec(data.data(), idx, color, 2);
+  }
+
+  writevec(data.data(), idx, m_width, longFields ? 4 : 2);
+  writevec(data.data(), idx, m_height, longFields ? 4 : 2);
+
+  for (const auto& img : m_offsets) {
+    writevec(data.data(), idx, img.x, longFields ? 4 : 2);
+    writevec(data.data(), idx, img.y, longFields ? 4 : 2);
+  }
+
+  assert(idx == data.size());
+
+  return data;
+}
+
+
+std::string ImageOverlay::dump() const
+{
+  std::stringstream sstr;
+
+  sstr << "version: " << ((int) m_version) << "\n"
+       << "flags: " << ((int) m_flags) << "\n"
+       << "background color: " << m_background_color[0]
+       << ";" << m_background_color[1]
+       << ";" << m_background_color[2]
+       << ";" << m_background_color[3] << "\n"
+       << "canvas size: " << m_width << "x" << m_height << "\n"
+       << "offsets: ";
+
+  for (const ImageWithOffset& offset : m_offsets) {
+    sstr << offset.x << ";" << offset.y << " ";
+  }
+  sstr << "\n";
+
+  return sstr.str();
+}
+
+
+void ImageOverlay::get_background_color(uint16_t col[4]) const
+{
+  for (int i = 0; i < 4; i++) {
+    col[i] = m_background_color[i];
+  }
+}
+
+
+void ImageOverlay::get_offset(size_t image_index, int32_t* x, int32_t* y) const
+{
+  assert(image_index < m_offsets.size());
+  assert(x && y);
+
+  *x = m_offsets[image_index].x;
+  *y = m_offsets[image_index].y;
+}
+
+
+
+ImageItem_Overlay::ImageItem_Overlay(HeifContext* ctx)
+    : ImageItem(ctx)
+{
+}
+
+
+ImageItem_Overlay::ImageItem_Overlay(HeifContext* ctx, heif_item_id id)
+    : ImageItem(ctx, id)
+{
+}
+
+
+Error ImageItem_Overlay::initialize_decoder()
+{
+  Error err = read_overlay_spec();
+  if (err) {
+    return err;
+  }
+
+  return Error::Ok;
+}
+
+
+Error ImageItem_Overlay::read_overlay_spec()
+{
+  auto heif_file = get_context()->get_heif_file();
+
+  auto iref_box = heif_file->get_iref_box();
+
+  if (!iref_box) {
+    return {heif_error_Invalid_input,
+            heif_suberror_No_iref_box,
+            "No iref box available, but needed for iovl image"};
+  }
+
+
+  m_overlay_image_ids = iref_box->get_references(get_id(), fourcc("dimg"));
+
+  /* TODO: probably, it is valid that an iovl image has no references ?
+
+  if (image_references.empty()) {
+    return Error(heif_error_Invalid_input,
+                 heif_suberror_Missing_grid_images,
+                 "'iovl' image with more than one reference image");
+  }
+  */
+
+
+  auto overlayDataResult = heif_file->get_uncompressed_item_data(get_id());
+  if (!overlayDataResult) {
+    return overlayDataResult.error();
+  }
+
+  Error err = m_overlay_spec.parse(m_overlay_image_ids.size(), *overlayDataResult);
+  if (err) {
+    return err;
+  }
+
+  if (m_overlay_image_ids.size() != m_overlay_spec.get_num_offsets()) {
+    return Error(heif_error_Invalid_input,
+                 heif_suberror_Invalid_overlay_data,
+                 "Number of image offsets does not match the number of image references");
+  }
+
+  return Error::Ok;
+}
+
+
+Result<std::shared_ptr<HeifPixelImage>> ImageItem_Overlay::decode_compressed_image(const heif_decoding_options& options,
+                                                                                   bool decode_tile_only, uint32_t tile_x0, uint32_t tile_y0,
+                                                                                   std::set<heif_item_id> processed_ids) const
+{
+  return decode_overlay_image(options, processed_ids);
+}
+
+
+Result<std::shared_ptr<HeifPixelImage>> ImageItem_Overlay::decode_overlay_image(const heif_decoding_options& options,
+                                                                                std::set<heif_item_id> processed_ids) const
+{
+  if (processed_ids.contains(get_id())) {
+    return Error{heif_error_Invalid_input,
+                 heif_suberror_Unspecified,
+                 "'iref' has cyclic references"};
+  }
+
+  processed_ids.insert(get_id());
+
+
+  std::shared_ptr<HeifPixelImage> img;
+
+  uint32_t w = m_overlay_spec.get_canvas_width();
+  uint32_t h = m_overlay_spec.get_canvas_height();
+
+  Error err = check_for_valid_image_size(get_context()->get_security_limits(), w, h);
+  if (err) {
+    return err;
+  }
+
+  // TODO: seems we always have to compose this in RGB since the background color is an RGB value
+  img = std::make_shared<HeifPixelImage>();
+  img->create(w, h,
+              heif_colorspace_RGB,
+              heif_chroma_444);
+  if (auto error = img->add_plane(heif_channel_R, w, h, 8, get_context()->get_security_limits())) { // TODO: other bit depths
+    return error;
+  }
+  if (auto error = img->add_plane(heif_channel_G, w, h, 8, get_context()->get_security_limits())) { // TODO: other bit depths
+    return error;
+  }
+  if (auto error = img->add_plane(heif_channel_B, w, h, 8, get_context()->get_security_limits())) { // TODO: other bit depths
+    return error;
+  }
+
+  uint16_t bkg_color[4];
+  m_overlay_spec.get_background_color(bkg_color);
+
+  err = img->fill_RGB_16bit(bkg_color[0], bkg_color[1], bkg_color[2], bkg_color[3]);
+  if (err) {
+    return err;
+  }
+
+  for (size_t i = 0; i < m_overlay_image_ids.size(); i++) {
+
+    // detect if 'iovl' is referencing itself
+
+    if (m_overlay_image_ids[i] == get_id()) {
+      return Error{heif_error_Invalid_input,
+                   heif_suberror_Unspecified,
+                   "Self-reference in 'iovl' image item."};
+    }
+
+    auto imgItem = get_context()->get_image(m_overlay_image_ids[i], true);
+    if (!imgItem) {
+      return Error(heif_error_Invalid_input, heif_suberror_Nonexisting_item_referenced, "'iovl' image references a non-existing item.");
+    }
+    if (auto error = imgItem->get_item_error()) {
+      return error;
+    }
+
+    auto decodeResult = imgItem->decode_image(options, false, 0,0, processed_ids);
+    if (!decodeResult) {
+      return decodeResult.error();
+    }
+
+    std::shared_ptr<HeifPixelImage> overlay_img = *decodeResult;
+
+
+    // process overlay in RGB space
+
+    if (overlay_img->get_colorspace() != heif_colorspace_RGB ||
+        overlay_img->get_chroma_format() != heif_chroma_444) {
+      auto overlay_img_result = convert_colorspace(overlay_img, heif_colorspace_RGB, heif_chroma_444,
+                                                   nclx_profile::undefined(),
+                                                   0, options.color_conversion_options, options.color_conversion_options_ext,
+                                                   get_context()->get_security_limits());
+      if (!overlay_img_result) {
+        return overlay_img_result.error();
+      }
+      else {
+        overlay_img = *overlay_img_result;
+      }
+    }
+
+    int32_t dx, dy;
+    m_overlay_spec.get_offset(i, &dx, &dy);
+
+    err = img->overlay(overlay_img, dx, dy);
+    if (err) {
+      if (err.error_code == heif_error_Invalid_input &&
+          err.sub_error_code == heif_suberror_Overlay_image_outside_of_canvas) {
+        // NOP, ignore this error
+      }
+      else {
+        return err;
+      }
+    }
+  }
+
+  return img;
+}
+
+
+int ImageItem_Overlay::get_luma_bits_per_pixel() const
+{
+  heif_item_id child;
+  Error err = get_context()->get_id_of_non_virtual_child_image(get_id(), child);
+  if (err) {
+    return -1;
+  }
+
+  auto image = get_context()->get_image(child, true);
+  return image->get_luma_bits_per_pixel();
+}
+
+
+int ImageItem_Overlay::get_chroma_bits_per_pixel() const
+{
+  heif_item_id child;
+  Error err = get_context()->get_id_of_non_virtual_child_image(get_id(), child);
+  if (err) {
+    return -1;
+  }
+
+  auto image = get_context()->get_image(child, true);
+  return image->get_chroma_bits_per_pixel();
+}
+
+
+Error ImageItem_Overlay::get_coded_image_colorspace(heif_colorspace* out_colorspace, heif_chroma* out_chroma) const
+{
+  *out_colorspace = heif_colorspace_RGB;
+  *out_chroma = heif_chroma_444;
+
+  return Error::Ok;
+}
+
+
+Result<std::shared_ptr<ImageItem_Overlay>> ImageItem_Overlay::add_new_overlay_item(HeifContext* ctx, const ImageOverlay& overlayspec)
+{
+  if (overlayspec.get_num_offsets() > 0xFFFF) {
+    return Error{heif_error_Usage_error,
+                 heif_suberror_Unspecified,
+                 "Too many overlay images (maximum: 65535)"};
+  }
+
+  std::vector<heif_item_id> ref_ids;
+
+  auto file = ctx->get_heif_file();
+
+  for (const auto& overlay : overlayspec.get_overlay_stack()) {
+    file->get_infe_box(overlay.image_id)->set_hidden_item(true); // only show the full overlay
+    ref_ids.push_back(overlay.image_id);
+  }
+
+
+  // Create ImageOverlay
+
+  std::vector<uint8_t> iovl_data = overlayspec.write();
+
+  // Create IOVL Item
+
+  auto iovl_id_result = file->add_new_image(fourcc("iovl"));
+  if (!iovl_id_result) {
+    return iovl_id_result.error();
+  }
+  heif_item_id iovl_id = *iovl_id_result;
+  std::shared_ptr<ImageItem_Overlay> iovl_image = std::make_shared<ImageItem_Overlay>(ctx, iovl_id);
+  ctx->insert_image_item(iovl_id, iovl_image);
+  const int construction_method = 1; // 0=mdat 1=idat
+  file->append_iloc_data(iovl_id, iovl_data, construction_method);
+
+  // Connect images to overlay
+  file->add_iref_reference(iovl_id, fourcc("dimg"), ref_ids);
+
+  // Add ISPE property
+  auto ispe = std::make_shared<Box_ispe>();
+  ispe->set_size(overlayspec.get_canvas_width(), overlayspec.get_canvas_height());
+  iovl_image->add_property(ispe, false);
+
+  // Add PIXI property (copy from first image) - According to MIAF, all images shall have the same color information.
+  auto pixi = file->get_property_for_item<Box_pixi>(ref_ids[0]);
+  iovl_image->add_property(pixi, true);
+
+  // Set Brands
+  //m_heif_file->set_brand(encoder->plugin->compression_format,
+  //                       out_grid_image->is_miaf_compatible());
+
+  return iovl_image;
+}
+
+heif_brand2 ImageItem_Overlay::get_compatible_brand() const
+{
+  if (m_overlay_image_ids.empty()) { return 0; }
+
+  heif_item_id child_id = m_overlay_image_ids[0];
+  auto child = get_context()->get_image(child_id, false);
+  if (!child) { return 0; }
+
+  return child->get_compatible_brand();
+}
diff --git a/libheif/image-items/overlay.h b/libheif/image-items/overlay.h
new file mode 100644
index 0000000000..e2a01eda6b
--- /dev/null
+++ b/libheif/image-items/overlay.h
@@ -0,0 +1,140 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_OVERLAY_H
+#define LIBHEIF_OVERLAY_H
+
+#include "image_item.h"
+#include <vector>
+#include <string>
+#include <memory>
+#include <set>
+
+
+class ImageOverlay
+{
+public:
+  Error parse(size_t num_images, const std::vector<uint8_t>& data);
+
+  std::vector<uint8_t> write() const;
+
+  std::string dump() const;
+
+  void get_background_color(uint16_t col[4]) const;
+
+  uint32_t get_canvas_width() const { return m_width; }
+
+  uint32_t get_canvas_height() const { return m_height; }
+
+  size_t get_num_offsets() const { return m_offsets.size(); }
+
+  void get_offset(size_t image_index, int32_t* x, int32_t* y) const;
+
+  void set_background_color(const uint16_t rgba_color[4])
+  {
+    for (int i = 0; i < 4; i++) {
+      m_background_color[i] = rgba_color[i];
+    }
+  }
+
+  void set_canvas_size(uint32_t width, uint32_t height)
+  {
+    m_width = width;
+    m_height = height;
+  }
+
+  void add_image_on_top(heif_item_id image_id, int32_t offset_x, int32_t offset_y)
+  {
+    m_offsets.emplace_back(ImageWithOffset{image_id, offset_x, offset_y});
+  }
+
+  struct ImageWithOffset
+  {
+    heif_item_id image_id;
+    int32_t x, y;
+  };
+
+  const std::vector<ImageWithOffset>& get_overlay_stack() const { return m_offsets; }
+
+private:
+  uint8_t m_version = 0;
+  uint8_t m_flags = 0;
+  uint16_t m_background_color[4]{0, 0, 0, 0};
+  uint32_t m_width = 0;
+  uint32_t m_height = 0;
+
+  std::vector<ImageWithOffset> m_offsets;
+};
+
+
+class ImageItem_Overlay : public ImageItem
+{
+public:
+  ImageItem_Overlay(HeifContext* ctx, heif_item_id id);
+
+  ImageItem_Overlay(HeifContext* ctx);
+
+  uint32_t get_infe_type() const override { return fourcc("iovl"); }
+
+  // TODO: nclx depends on contained format
+  // const heif_color_profile_nclx* get_forced_output_nclx() const override { return nullptr; }
+
+  // heif_compression_format get_compression_format() const override { return heif_compression_HEVC; }
+
+  Error initialize_decoder() override;
+
+  int get_luma_bits_per_pixel() const override;
+
+  int get_chroma_bits_per_pixel() const override;
+
+  Error get_coded_image_colorspace(heif_colorspace* out_colorspace, heif_chroma* out_chroma) const override;
+
+  heif_brand2 get_compatible_brand() const override;
+
+  Result<Encoder::CodedImageData> encode(const std::shared_ptr<HeifPixelImage>& image,
+                                         heif_encoder* encoder,
+                                         const heif_encoding_options& options,
+                                         heif_image_input_class input_class) override
+  {
+    return Error{heif_error_Unsupported_feature,
+                 heif_suberror_Unspecified, "Cannot encode image to 'iovl'"};
+  }
+
+  Result<std::shared_ptr<HeifPixelImage>> decode_compressed_image(const heif_decoding_options& options,
+                                                                  bool decode_tile_only, uint32_t tile_x0, uint32_t tile_y0,
+                                                                  std::set<heif_item_id> processed_ids) const override;
+
+
+  // --- iovl specific
+
+  static Result<std::shared_ptr<ImageItem_Overlay>> add_new_overlay_item(HeifContext* ctx, const ImageOverlay& overlayspec);
+
+private:
+  ImageOverlay m_overlay_spec;
+  std::vector<heif_item_id> m_overlay_image_ids;
+
+  Error read_overlay_spec();
+
+  Result<std::shared_ptr<HeifPixelImage>> decode_overlay_image(const heif_decoding_options& options,
+                                                               std::set<heif_item_id> processed_ids) const;
+};
+
+
+#endif //LIBHEIF_OVERLAY_H
diff --git a/libheif/image-items/tiled.cc b/libheif/image-items/tiled.cc
new file mode 100644
index 0000000000..4ae467efd8
--- /dev/null
+++ b/libheif/image-items/tiled.cc
@@ -0,0 +1,1041 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "tiled.h"
+#include "context.h"
+#include "file.h"
+#include <algorithm>
+#include "security_limits.h"
+#include "codecs/hevc_dec.h"
+#if WITH_UNCOMPRESSED_CODEC
+#include "codecs/uncompressed/unc_boxes.h"
+#endif
+#include "api_structs.h"
+
+
+static uint64_t readvec(const std::vector<uint8_t>& data, size_t& ptr, int len)
+{
+  uint64_t val = 0;
+  while (len--) {
+    val <<= 8;
+    val |= data[ptr++];
+  }
+
+  return val;
+}
+
+
+Result<uint64_t> number_of_tiles(const heif_tiled_image_parameters& params, const heif_security_limits* limits)
+{
+  uint64_t nTiles = nTiles_h(params) * static_cast<uint64_t>(nTiles_v(params));
+
+  for (int i = 0; i < params.number_of_extra_dimensions; i++) {
+    // We only support up to 8 extra dimensions
+    if (i == 8) {
+      break;
+    }
+
+    if (params.extra_dimensions[i] != 0 &&
+        nTiles > UINT64_MAX / params.extra_dimensions[i]) {
+        return Error{
+          heif_error_Unsupported_filetype,
+          heif_suberror_Unspecified,
+          "Number of tiles exceeds uint64 maximum."
+        };
+    }
+
+    if (params.extra_dimensions[i] == 0) {
+      return Error{
+        heif_error_Unsupported_filetype,
+        heif_suberror_Unspecified,
+        "Zero extra dimension size."
+      };
+    }
+
+    nTiles *= params.extra_dimensions[i];
+
+    if (limits && nTiles > limits->max_number_of_tiles) {
+      return Error{
+        heif_error_Unsupported_filetype,
+        heif_suberror_Security_limit_exceeded,
+        "Number of tiles exceeds security limit"
+      };
+    }
+  }
+
+  return nTiles;
+}
+
+
+uint32_t nTiles_h(const heif_tiled_image_parameters& params)
+{
+  return (params.image_width + params.tile_width - 1) / params.tile_width;
+}
+
+
+uint32_t nTiles_v(const heif_tiled_image_parameters& params)
+{
+  return (params.image_height + params.tile_height - 1) / params.tile_height;
+}
+
+
+void Box_tilC::init_heif_tiled_image_parameters(heif_tiled_image_parameters& params)
+{
+  params.version = 1;
+
+  params.image_width = 0;
+  params.image_height = 0;
+  params.tile_width = 0;
+  params.tile_height = 0;
+  params.compression_format_fourcc = 0;
+  params.offset_field_length = 40;
+  params.size_field_length = 24;
+  params.number_of_extra_dimensions = 0;
+
+  for (uint32_t& dim : params.extra_dimensions) {
+    dim = 0;
+  }
+
+  params.tiles_are_sequential = false;
+}
+
+
+void Box_tilC::derive_box_version()
+{
+  set_version(0);
+
+  uint8_t flags = 0;
+
+  switch (m_parameters.offset_field_length) {
+    case 32:
+      flags |= 0;
+      break;
+    case 40:
+      flags |= 0x01;
+      break;
+    case 48:
+      flags |= 0x02;
+      break;
+    case 64:
+      flags |= 0x03;
+      break;
+    default:
+      assert(false); // TODO: return error
+  }
+
+  switch (m_parameters.size_field_length) {
+    case 0:
+      flags |= 0;
+      break;
+    case 24:
+      flags |= 0x04;
+      break;
+    case 32:
+      flags |= 0x08;
+      break;
+    case 64:
+      flags |= 0x0c;
+      break;
+    default:
+      assert(false); // TODO: return error
+  }
+
+  if (m_parameters.tiles_are_sequential) {
+    flags |= 0x10;
+  }
+
+  set_flags(flags);
+}
+
+
+Error Box_tilC::write(StreamWriter& writer) const
+{
+  assert(m_parameters.version == 1);
+
+  size_t box_start = reserve_box_header_space(writer);
+
+  if (m_parameters.number_of_extra_dimensions > 8) {
+    assert(false); // currently not supported
+  }
+
+  writer.write32(m_parameters.tile_width);
+  writer.write32(m_parameters.tile_height);
+  writer.write32(m_parameters.compression_format_fourcc);
+
+  writer.write8(m_parameters.number_of_extra_dimensions);
+
+  for (int i = 0; i < m_parameters.number_of_extra_dimensions; i++) {
+    writer.write32(m_parameters.extra_dimensions[i]);
+  }
+
+  auto& tile_properties = m_children;
+  if (tile_properties.size() > 255) {
+    return {heif_error_Encoding_error,
+            heif_suberror_Unspecified,
+            "Cannot write more than 255 tile properties in tilC header"};
+  }
+
+  writer.write8(static_cast<uint8_t>(tile_properties.size()));
+  for (const auto& property : tile_properties) {
+    property->write(writer);
+  }
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+
+std::string Box_tilC::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+
+  sstr << BoxHeader::dump(indent);
+
+  sstr << indent << "version: " << ((int) get_version()) << "\n"
+       //<< indent << "image size: " << m_parameters.image_width << "x" << m_parameters.image_height << "\n"
+       << indent << "tile size: " << m_parameters.tile_width << "x" << m_parameters.tile_height << "\n"
+       << indent << "compression: " << fourcc_to_string(m_parameters.compression_format_fourcc) << "\n"
+       << indent << "tiles are sequential: " << (m_parameters.tiles_are_sequential ? "yes" : "no") << "\n"
+       << indent << "offset field length: " << ((int) m_parameters.offset_field_length) << " bits\n"
+       << indent << "size field length: " << ((int) m_parameters.size_field_length) << " bits\n"
+       << indent << "number of extra dimensions: " << ((int) m_parameters.number_of_extra_dimensions) << "\n";
+
+  sstr << indent << "tile properties:\n"
+       << dump_children(indent, true);
+
+  return sstr.str();
+
+}
+
+
+Error Box_tilC::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  parse_full_box_header(range);
+
+  // Note: actually, we should allow 0 only, but there are a few images around that use version 1.
+  if (get_version() > 1) {
+    std::stringstream sstr;
+    sstr << "'tili' image version " << ((int) get_version()) << " is not implemented yet";
+
+    return {heif_error_Unsupported_feature,
+            heif_suberror_Unsupported_data_version,
+            sstr.str()};
+  }
+
+  m_parameters.version = get_version();
+
+  uint32_t flags = get_flags();
+
+  switch (flags & 0x03) {
+    case 0:
+      m_parameters.offset_field_length = 32;
+      break;
+    case 1:
+      m_parameters.offset_field_length = 40;
+      break;
+    case 2:
+      m_parameters.offset_field_length = 48;
+      break;
+    case 3:
+      m_parameters.offset_field_length = 64;
+      break;
+  }
+
+  switch (flags & 0x0c) {
+    case 0x00:
+      m_parameters.size_field_length = 0;
+      break;
+    case 0x04:
+      m_parameters.size_field_length = 24;
+      break;
+    case 0x08:
+      m_parameters.size_field_length = 32;
+      break;
+    case 0x0c:
+      m_parameters.size_field_length = 64;
+      break;
+  }
+
+  m_parameters.tiles_are_sequential = !!(flags & 0x10);
+
+
+  m_parameters.tile_width = range.read32();
+  m_parameters.tile_height = range.read32();
+  m_parameters.compression_format_fourcc = range.read32();
+
+  if (m_parameters.tile_width == 0 || m_parameters.tile_height == 0) {
+    return {heif_error_Invalid_input,
+            heif_suberror_Unspecified,
+            "Tile with zero width or height."};
+  }
+
+
+  // --- extra dimensions
+
+  m_parameters.number_of_extra_dimensions = range.read8();
+
+  for (int i = 0; i < m_parameters.number_of_extra_dimensions; i++) {
+    uint32_t size = range.read32();
+
+    if (size == 0) {
+      return {heif_error_Invalid_input,
+              heif_suberror_Unspecified,
+              "'tili' extra dimension may not be zero."};
+    }
+
+    if (i < 8) {
+      m_parameters.extra_dimensions[i] = size;
+    }
+    else {
+      // TODO: error: too many dimensions (not supported)
+    }
+  }
+
+  // --- read tile properties
+
+  // Check version for backwards compatibility with old format.
+  // TODO: remove when spec is final and old test images have been converted
+  if (get_version() == 0) {
+    uint8_t num_properties = range.read8();
+
+    Error error = read_children(range, num_properties, limits);
+    if (error) {
+      return error;
+    }
+  }
+
+  return range.get_error();
+}
+
+
+Error TiledHeader::set_parameters(const heif_tiled_image_parameters& params)
+{
+  m_parameters = params;
+
+  Result<uint64_t> num_tiles_result = number_of_tiles(params, heif_get_global_security_limits());
+  if (auto err = num_tiles_result.error()) {
+    return err;
+  }
+
+  m_offsets.resize(*num_tiles_result);
+
+  for (auto& tile: m_offsets) {
+    tile.offset = TILD_OFFSET_NOT_LOADED;
+  }
+
+  return Error::Ok;
+}
+
+
+Error TiledHeader::read_full_offset_table(const std::shared_ptr<HeifFile>& file, heif_item_id tild_id, const heif_security_limits* limits)
+{
+  Result<uint64_t> nTiles_result = number_of_tiles(m_parameters, limits);
+  if (auto err = nTiles_result.error()) {
+    return err;
+  }
+
+  return read_offset_table_range(file, tild_id, 0, *nTiles_result);
+}
+
+
+Error TiledHeader::read_offset_table_range(const std::shared_ptr<HeifFile>& file, heif_item_id tild_id,
+                                           uint64_t start, uint64_t end)
+{
+  const Error eofError(heif_error_Invalid_input,
+                       heif_suberror_Unspecified,
+                       "Tili header data incomplete");
+
+  std::vector<uint8_t> data;
+
+
+
+  // --- load offsets
+
+  size_t size_to_read = (end - start) * (m_parameters.offset_field_length + m_parameters.size_field_length) / 8;
+  size_t start_offset = start * (m_parameters.offset_field_length + m_parameters.size_field_length) / 8;
+
+  // TODO: when we request a file range from the stream reader, it may return a larger range.
+  //       We should then also use this larger range to read more table entries.
+  //       But this is not easy since our data may span several iloc extents and we have to map this back to item addresses.
+  //       Maybe it is easier to just ignore the extra data and rely on the stream read to cache this data.
+
+  Error err = file->append_data_from_iloc(tild_id, data, start_offset, size_to_read);
+  if (err) {
+    return err;
+  }
+
+  size_t idx = 0;
+  for (uint64_t i = start; i < end; i++) {
+    m_offsets[i].offset = readvec(data, idx, m_parameters.offset_field_length / 8);
+
+    if (m_parameters.size_field_length) {
+      assert(m_parameters.size_field_length <= 32);
+      m_offsets[i].size = static_cast<uint32_t>(readvec(data, idx, m_parameters.size_field_length / 8));
+    }
+
+    // printf("[%zu] : offset/size: %zu %d\n", i, m_offsets[i].offset, m_offsets[i].size);
+  }
+
+  return Error::Ok;
+}
+
+
+size_t TiledHeader::get_header_size() const
+{
+  assert(m_header_size);
+  return m_header_size;
+}
+
+
+uint32_t TiledHeader::get_offset_table_entry_size() const
+{
+  return (m_parameters.offset_field_length + m_parameters.size_field_length) / 8;
+}
+
+
+std::pair<uint32_t, uint32_t> TiledHeader::get_tile_offset_table_range_to_read(uint32_t idx, uint32_t nEntries) const
+{
+  uint32_t start = idx;
+  uint32_t end = idx+1;
+
+  while (end < m_offsets.size() && end - idx < nEntries && m_offsets[end].offset == TILD_OFFSET_NOT_LOADED) {
+    end++;
+  }
+
+  while (start > 0 && idx - start < nEntries && m_offsets[start-1].offset == TILD_OFFSET_NOT_LOADED) {
+    start--;
+  }
+
+  // try to fill the smaller hole
+
+  if (end - start > nEntries) {
+    if (idx - start < end - idx) {
+      end = start + nEntries;
+    }
+    else {
+      start = end - nEntries;
+    }
+  }
+
+  return {start, end};
+}
+
+
+void TiledHeader::set_tild_tile_range(uint32_t tile_x, uint32_t tile_y, uint64_t offset, uint32_t size)
+{
+  uint64_t idx = uint64_t{tile_y} * nTiles_h(m_parameters) + tile_x;
+  m_offsets[idx].offset = offset;
+  m_offsets[idx].size = size;
+}
+
+
+template<typename I>
+void writevec(uint8_t* data, size_t& idx, I value, int len)
+{
+  for (int i = 0; i < len; i++) {
+    data[idx + i] = static_cast<uint8_t>((value >> (len - 1 - i) * 8) & 0xFF);
+  }
+
+  idx += len;
+}
+
+
+Result<std::vector<uint8_t>> TiledHeader::write_offset_table()
+{
+  Result<uint64_t> nTiles_result = number_of_tiles(m_parameters, nullptr);
+  if (auto err = nTiles_result.error()) {
+    return err;
+  }
+
+
+  int offset_entry_size = (m_parameters.offset_field_length + m_parameters.size_field_length) / 8;
+  uint64_t size = *nTiles_result * offset_entry_size;
+
+  std::vector<uint8_t> data;
+  data.resize(size);
+
+  size_t idx = 0;
+
+  for (const auto& offset: m_offsets) {
+    writevec(data.data(), idx, offset.offset, m_parameters.offset_field_length / 8);
+
+    if (m_parameters.size_field_length != 0) {
+      writevec(data.data(), idx, offset.size, m_parameters.size_field_length / 8);
+    }
+  }
+
+  assert(idx == data.size());
+
+  m_header_size = data.size();
+
+  return data;
+}
+
+
+std::string TiledHeader::dump() const
+{
+  std::stringstream sstr;
+
+  sstr << "offsets: ";
+
+  // TODO
+
+  for (const auto& offset: m_offsets) {
+    sstr << offset.offset << ", size: " << offset.size << "\n";
+  }
+
+  return sstr.str();
+}
+
+
+ImageItem_Tiled::ImageItem_Tiled(HeifContext* ctx)
+        : ImageItem(ctx)
+{
+  m_tile_encoding_options = heif_encoding_options_alloc();
+}
+
+
+ImageItem_Tiled::ImageItem_Tiled(HeifContext* ctx, heif_item_id id)
+        : ImageItem(ctx, id)
+{
+  m_tile_encoding_options = heif_encoding_options_alloc();
+}
+
+
+ImageItem_Tiled::~ImageItem_Tiled()
+{
+  heif_encoding_options_free(m_tile_encoding_options);
+}
+
+
+heif_compression_format ImageItem_Tiled::get_compression_format() const
+{
+  return compression_format_from_fourcc_infe_type(m_tild_header.get_parameters().compression_format_fourcc);
+}
+
+
+Error ImageItem_Tiled::initialize_decoder()
+{
+  auto heif_file = get_context()->get_heif_file();
+
+  auto tilC_box = get_property<Box_tilC>();
+  if (!tilC_box) {
+    return {heif_error_Invalid_input,
+            heif_suberror_Unspecified,
+            "Tiled image without 'tilC' property box."};
+  }
+
+  auto ispe_box = get_property<Box_ispe>();
+  if (!ispe_box) {
+    return {heif_error_Invalid_input,
+            heif_suberror_Unspecified,
+            "Tiled image without 'ispe' property box."};
+  }
+
+  heif_tiled_image_parameters parameters = tilC_box->get_parameters();
+  parameters.image_width = ispe_box->get_width();
+  parameters.image_height = ispe_box->get_height();
+
+  if (parameters.image_width == 0 || parameters.image_height == 0) {
+    return {heif_error_Invalid_input,
+            heif_suberror_Unspecified,
+            "'tili' image with zero width or height."};
+  }
+
+  if (Error err = m_tild_header.set_parameters(parameters)) {
+    return err;
+  }
+
+
+  // --- create a dummy image item for decoding tiles
+
+  heif_compression_format format = compression_format_from_fourcc_infe_type(m_tild_header.get_parameters().compression_format_fourcc);
+  m_tile_item = ImageItem::alloc_for_compression_format(get_context(), format);
+
+  // For backwards compatibility: copy over properties from `tili` item.
+  // TODO: remove when spec is final and old test images have been converted
+  if (tilC_box->get_version() == 1) {
+    auto propertiesResult = get_properties();
+    if (!propertiesResult) {
+      return propertiesResult.error();
+    }
+
+    // Filter out per-tile boxes incompatible with tili's shared template
+    auto props = *propertiesResult;
+#if WITH_UNCOMPRESSED_CODEC
+    for (const auto& box : props) {
+      if (box->get_short_type() == fourcc("icef")) {
+        auto icef = std::dynamic_pointer_cast<Box_icef>(box);
+        if (icef && icef->get_units().size() > 1) {
+          return {heif_error_Invalid_input,
+                  heif_suberror_Unspecified,
+                  "icef box with multiple units is incompatible with tili shared tile template."};
+        }
+      }
+    }
+    std::erase_if(props, [](const std::shared_ptr<Box>& box) {
+      uint32_t type = box->get_short_type();
+      return type == fourcc("icef") || type == fourcc("sbpm") || type == fourcc("snuc");
+    });
+#endif
+
+    m_tile_item->set_properties(props);
+  }
+  else {
+    // --- This is the new method
+
+    // Synthesize an ispe box if there was none in the file
+
+    auto tile_properties = tilC_box->get_all_child_boxes();
+
+    // Filter out per-tile boxes incompatible with tili's shared template
+#if WITH_UNCOMPRESSED_CODEC
+    for (const auto& box : tile_properties) {
+      if (box->get_short_type() == fourcc("icef")) {
+        auto icef = std::dynamic_pointer_cast<Box_icef>(box);
+        if (icef && icef->get_units().size() > 1) {
+          return {heif_error_Invalid_input,
+                  heif_suberror_Unspecified,
+                  "icef box with multiple units is incompatible with tili shared tile template."};
+        }
+      }
+    }
+    std::erase_if(tile_properties, [](const std::shared_ptr<Box>& box) {
+      uint32_t type = box->get_short_type();
+      return type == fourcc("icef") || type == fourcc("sbpm") || type == fourcc("snuc");
+    });
+#endif
+
+    bool have_ispe = false;
+    for (const auto& property : tile_properties) {
+      if (property->get_short_type() == fourcc("ispe")) {
+        have_ispe = true;
+        break;
+      }
+    }
+
+    if (!have_ispe) {
+      auto ispe = std::make_shared<Box_ispe>();
+      ispe->set_size(parameters.tile_width, parameters.tile_height);
+      tile_properties.emplace_back(std::move(ispe));
+    }
+
+    m_tile_item->set_properties(tile_properties);
+  }
+
+  m_tile_decoder = Decoder::alloc_for_infe_type(m_tile_item.get());
+  if (!m_tile_decoder) {
+    return {heif_error_Unsupported_feature,
+            heif_suberror_Unsupported_codec,
+            "'tili' image with unsupported compression format."};
+  }
+
+  if (m_preload_offset_table) {
+    if (Error err = m_tild_header.read_full_offset_table(heif_file, get_id(), get_context()->get_security_limits())) {
+      return err;
+    }
+  }
+
+
+  return Error::Ok;
+}
+
+
+Result<std::shared_ptr<ImageItem_Tiled>>
+ImageItem_Tiled::add_new_tiled_item(HeifContext* ctx, const heif_tiled_image_parameters* parameters,
+                                    const heif_encoder* encoder,
+                                    const heif_encoding_options* encoding_options)
+{
+  Result<uint64_t> num_tiles_result = number_of_tiles(*parameters, ctx->get_security_limits());
+  if (auto err = num_tiles_result.error()) {
+    return err;
+  }
+
+  // Create 'tili' Item
+
+  auto file = ctx->get_heif_file();
+
+  auto tild_id_result = ctx->get_heif_file()->add_new_image(fourcc("tili"));
+  if (!tild_id_result) {
+    return tild_id_result.error();
+  }
+  heif_item_id tild_id = *tild_id_result;
+  auto tild_image = std::make_shared<ImageItem_Tiled>(ctx, tild_id);
+  tild_image->set_resolution(parameters->image_width, parameters->image_height);
+  ctx->insert_image_item(tild_id, tild_image);
+
+  if (encoding_options) {
+    // encoding options for the tiles, but do not apply transformative properties
+    heif_encoding_options_copy(tild_image->m_tile_encoding_options, encoding_options);
+    tild_image->m_tile_encoding_options->image_orientation = heif_orientation_normal;
+
+    // orientation of the main image
+    tild_image->m_image_orientation = encoding_options->image_orientation;
+  }
+
+  // Create tilC box
+
+  auto tilC_box = std::make_shared<Box_tilC>();
+  tilC_box->set_parameters(*parameters);
+  tilC_box->set_compression_format(encoder->plugin->compression_format);
+  tild_image->add_property(tilC_box, true);
+
+  // Create header + offset table
+
+  TiledHeader tild_header;
+  tild_header.set_parameters(*parameters);
+  tild_header.set_compression_format(encoder->plugin->compression_format);
+
+  Result<std::vector<uint8_t>> header_data_result = tild_header.write_offset_table();
+  if (auto err = header_data_result.error()) {
+    return err;
+  }
+
+  const int construction_method = 0; // 0=mdat 1=idat
+  file->append_iloc_data(tild_id, *header_data_result, construction_method);
+
+
+  if (parameters->image_width > 0xFFFFFFFF || parameters->image_height > 0xFFFFFFFF) {
+    return {Error(heif_error_Usage_error, heif_suberror_Invalid_image_size,
+                  "'ispe' only supports image sized up to 4294967295 pixels per dimension")};
+  }
+
+  // Add ISPE property
+  auto ispe = std::make_shared<Box_ispe>();
+  ispe->set_size(static_cast<uint32_t>(parameters->image_width),
+                 static_cast<uint32_t>(parameters->image_height));
+  tild_image->add_property(ispe, true);
+
+#if 0
+  // TODO
+
+  // Add PIXI property (copy from first tile)
+  auto pixi = m_heif_file->get_property<Box_pixi>(tile_ids[0]);
+  m_heif_file->add_property(grid_id, pixi, true);
+#endif
+
+  tild_image->set_tild_header(tild_header);
+  tild_image->set_next_tild_position(header_data_result->size());
+
+  // Set Brands
+  //m_heif_file->set_brand(encoder->plugin->compression_format,
+  //                       out_grid_image->is_miaf_compatible());
+
+  return {tild_image};
+}
+
+
+Error ImageItem_Tiled::add_image_tile(uint32_t tile_x, uint32_t tile_y,
+                                     const std::shared_ptr<HeifPixelImage>& image,
+                                     heif_encoder* encoder)
+{
+  auto item = ImageItem::alloc_for_compression_format(get_context(), encoder->plugin->compression_format);
+
+  Result<std::shared_ptr<HeifPixelImage>> colorConversionResult;
+  colorConversionResult = item->get_encoder()->convert_colorspace_for_encoding(image, encoder,
+                                                                               m_tile_encoding_options->output_nclx_profile,
+                                                                               &m_tile_encoding_options->color_conversion_options,
+                                                                               get_context()->get_security_limits());
+  if (!colorConversionResult) {
+    return colorConversionResult.error();
+  }
+
+  std::shared_ptr<HeifPixelImage> colorConvertedImage = *colorConversionResult;
+
+  Result<Encoder::CodedImageData> encodeResult = item->encode_to_bitstream_and_boxes(colorConvertedImage, encoder, *m_tile_encoding_options, heif_image_input_class_normal);
+
+  if (!encodeResult) {
+    return encodeResult.error();
+  }
+
+  const int construction_method = 0; // 0=mdat 1=idat
+  get_file()->append_iloc_data(get_id(), encodeResult->bitstream, construction_method);
+
+  auto& header = m_tild_header;
+
+  if (image->get_width() != header.get_parameters().tile_width ||
+      image->get_height() != header.get_parameters().tile_height) {
+    return {heif_error_Usage_error,
+            heif_suberror_Unspecified,
+            "Tile image size does not match the specified tile size."};
+  }
+
+  uint64_t offset = get_next_tild_position();
+  size_t dataSize = encodeResult->bitstream.size();
+  if (dataSize > 0xFFFFFFFF) {
+    return {heif_error_Encoding_error, heif_suberror_Unspecified, "Compressed tile size exceeds maximum tile size."};
+  }
+  header.set_tild_tile_range(tile_x, tile_y, offset, static_cast<uint32_t>(dataSize));
+  set_next_tild_position(offset + encodeResult->bitstream.size());
+
+  auto tilC = get_property<Box_tilC>();
+  assert(tilC);
+
+  std::vector<std::shared_ptr<Box>>& tile_properties = tilC->get_tile_properties();
+
+  for (auto& propertyBox : encodeResult->properties) {
+
+    // we do not have to save ispe boxes in the tile properties as this is automatically synthesized
+
+    if (propertyBox->get_short_type() == fourcc("ispe")) {
+      continue;
+    }
+
+#if WITH_UNCOMPRESSED_CODEC
+    // icef/sbpm/snuc contain per-tile data incompatible with tili's shared tile template
+    uint32_t ptype = propertyBox->get_short_type();
+
+    if (ptype == fourcc("icef")) {
+      auto icef = std::dynamic_pointer_cast<Box_icef>(propertyBox);
+      if (icef && icef->get_units().size() > 1) {
+        return {heif_error_Usage_error,
+                heif_suberror_Unspecified,
+                "icef box with multiple units is incompatible with tili shared tile template."};
+      }
+      // Single-unit icef can be safely skipped
+      continue;
+    }
+
+    if (ptype == fourcc("sbpm") || ptype == fourcc("snuc")) {
+      return {heif_error_Usage_error,
+              heif_suberror_Unspecified,
+              "Cannot store per-tile property (" + fourcc_to_string(ptype) + ") in tili shared tile template."};
+    }
+#endif
+
+    // skip properties that exist already
+
+    bool exists = std::any_of(tile_properties.begin(),
+                              tile_properties.end(),
+                              [&propertyBox](const std::shared_ptr<Box>& p) { return p->get_short_type() == propertyBox->get_short_type();});
+    if (exists) {
+      continue;
+    }
+
+    tile_properties.emplace_back(propertyBox);
+
+    // some tile properties are also added to the tili image
+
+    switch (propertyBox->get_short_type()) {
+      case fourcc("pixi"):
+        get_file()->add_property(get_id(), propertyBox, propertyBox->is_essential());
+        break;
+    }
+
+    get_file()->add_orientation_properties(get_id(), m_image_orientation);
+  }
+
+  //get_file()->set_brand(encoder->plugin->compression_format,
+  //                      true); // TODO: out_grid_image->is_miaf_compatible());
+
+  return Error::Ok;
+}
+
+
+Error ImageItem_Tiled::process_before_write()
+{
+  // overwrite offsets
+
+  const int construction_method = 0; // 0=mdat 1=idat
+
+  Result<std::vector<uint8_t>> header_data_result = m_tild_header.write_offset_table();
+  if (auto err = header_data_result.error()) {
+    return err;
+  }
+
+  get_file()->replace_iloc_data(get_id(), 0, *header_data_result, construction_method);
+  return {};
+}
+
+
+Result<std::shared_ptr<HeifPixelImage>>
+ImageItem_Tiled::decode_compressed_image(const heif_decoding_options& options,
+                                         bool decode_tile_only, uint32_t tile_x0, uint32_t tile_y0,
+                                         std::set<heif_item_id> processed_ids) const
+{
+  if (decode_tile_only) {
+    return decode_grid_tile(options, tile_x0, tile_y0);
+  }
+  else {
+    return Error{heif_error_Unsupported_feature, heif_suberror_Unspecified,
+                 "'tili' images can only be accessed per tile"};
+  }
+}
+
+
+Error ImageItem_Tiled::append_compressed_tile_data(std::vector<uint8_t>& data, uint32_t tx, uint32_t ty) const
+{
+  uint32_t idx = (uint32_t) (ty * nTiles_h(m_tild_header.get_parameters()) + tx);
+
+  if (!m_tild_header.is_tile_offset_known(idx)) {
+    Error err = const_cast<ImageItem_Tiled*>(this)->load_tile_offset_entry(idx);
+    if (err) {
+      return err;
+    }
+  }
+
+  uint64_t offset = m_tild_header.get_tile_offset(idx);
+  uint64_t size = m_tild_header.get_tile_size(idx);
+
+  Error err = get_file()->append_data_from_iloc(get_id(), data, offset, size);
+  if (err.error_code) {
+    return err;
+  }
+
+  return Error::Ok;
+}
+
+
+Result<DataExtent>
+ImageItem_Tiled::get_compressed_data_for_tile(uint32_t tx, uint32_t ty) const
+{
+  // --- get compressed data
+
+  Error err = m_tile_item->initialize_decoder();
+  if (err) {
+    return err;
+  }
+
+  Result<std::vector<uint8_t>> dataResult = m_tile_item->read_bitstream_configuration_data();
+  if (!dataResult) {
+    return dataResult.error();
+  }
+
+  std::vector<uint8_t> data = std::move(*dataResult);
+  err = append_compressed_tile_data(data, tx, ty);
+  if (err) {
+    return err;
+  }
+
+  // --- decode
+
+  DataExtent extent;
+  extent.m_raw = data;
+
+  return extent;
+}
+
+
+Result<std::shared_ptr<HeifPixelImage>>
+ImageItem_Tiled::decode_grid_tile(const heif_decoding_options& options, uint32_t tx, uint32_t ty) const
+{
+  Result<DataExtent> extentResult = get_compressed_data_for_tile(tx, ty);
+  if (!extentResult) {
+    return extentResult.error();
+  }
+
+  m_tile_decoder->set_data_extent(std::move(*extentResult));
+
+  return m_tile_decoder->decode_single_frame_from_compressed_data(options,
+                                                                  get_context()->get_security_limits());
+}
+
+
+Error ImageItem_Tiled::load_tile_offset_entry(uint32_t idx)
+{
+  uint32_t nEntries = mReadChunkSize_bytes / m_tild_header.get_offset_table_entry_size();
+  std::pair<uint32_t, uint32_t> range = m_tild_header.get_tile_offset_table_range_to_read(idx, nEntries);
+
+  return m_tild_header.read_offset_table_range(get_file(), get_id(), range.first, range.second);
+}
+
+
+heif_image_tiling ImageItem_Tiled::get_heif_image_tiling() const
+{
+  heif_image_tiling tiling{};
+
+  tiling.num_columns = nTiles_h(m_tild_header.get_parameters());
+  tiling.num_rows = nTiles_v(m_tild_header.get_parameters());
+
+  tiling.tile_width = m_tild_header.get_parameters().tile_width;
+  tiling.tile_height = m_tild_header.get_parameters().tile_height;
+
+  tiling.image_width = m_tild_header.get_parameters().image_width;
+  tiling.image_height = m_tild_header.get_parameters().image_height;
+  tiling.number_of_extra_dimensions = m_tild_header.get_parameters().number_of_extra_dimensions;
+  for (int i = 0; i < std::min(tiling.number_of_extra_dimensions, uint8_t(8)); i++) {
+    tiling.extra_dimension_size[i] = m_tild_header.get_parameters().extra_dimensions[i];
+  }
+
+  return tiling;
+}
+
+
+void ImageItem_Tiled::get_tile_size(uint32_t& w, uint32_t& h) const
+{
+  w = m_tild_header.get_parameters().tile_width;
+  h = m_tild_header.get_parameters().tile_height;
+}
+
+
+Error ImageItem_Tiled::get_coded_image_colorspace(heif_colorspace* out_colorspace, heif_chroma* out_chroma) const
+{
+  uint32_t tx=0, ty=0; // TODO: find a tile that is defined.
+
+  Result<DataExtent> extentResult = get_compressed_data_for_tile(tx, ty);
+  if (!extentResult) {
+    return extentResult.error();
+  }
+
+  m_tile_decoder->set_data_extent(std::move(*extentResult));
+
+  Error err = m_tile_decoder->get_coded_image_colorspace(out_colorspace, out_chroma);
+  if (err) {
+    return err;
+  }
+
+  postprocess_coded_image_colorspace(out_colorspace, out_chroma);
+
+  return Error::Ok;
+}
+
+
+int ImageItem_Tiled::get_luma_bits_per_pixel() const
+{
+  DataExtent any_tile_extent;
+  append_compressed_tile_data(any_tile_extent.m_raw, 0,0); // TODO: use tile that is already loaded
+  m_tile_decoder->set_data_extent(std::move(any_tile_extent));
+
+  return m_tile_decoder->get_luma_bits_per_pixel();
+}
+
+int ImageItem_Tiled::get_chroma_bits_per_pixel() const
+{
+  DataExtent any_tile_extent;
+  append_compressed_tile_data(any_tile_extent.m_raw, 0,0); // TODO: use tile that is already loaded
+  m_tile_decoder->set_data_extent(std::move(any_tile_extent));
+
+  return m_tile_decoder->get_chroma_bits_per_pixel();
+}
+
+heif_brand2 ImageItem_Tiled::get_compatible_brand() const
+{
+  return 0;
+
+  // TODO: it is not clear to me what brand to use here.
+
+  /*
+  switch (m_tild_header.get_parameters().compression_format_fourcc) {
+    case heif_compression_HEVC:
+      return heif_brand2_heic;
+  }
+   */
+}
diff --git a/libheif/image-items/tiled.h b/libheif/image-items/tiled.h
new file mode 100644
index 0000000000..6ced023ad5
--- /dev/null
+++ b/libheif/image-items/tiled.h
@@ -0,0 +1,231 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_TILED_H
+#define LIBHEIF_TILED_H
+
+#include "image_item.h"
+#include "codecs/decoder.h"
+#include "box.h"
+#include <vector>
+#include <string>
+#include <memory>
+#include <utility>
+#include "libheif/heif_experimental.h"
+#include "libheif/heif_encoding.h"
+#include <set>
+
+
+Result<uint64_t> number_of_tiles(const heif_tiled_image_parameters& params, const heif_security_limits* limits);
+
+uint32_t nTiles_h(const heif_tiled_image_parameters& params);
+
+uint32_t nTiles_v(const heif_tiled_image_parameters& params);
+
+
+class Box_tilC : public FullBox
+{
+  /*
+   * Flags:
+   * bit 0-1 - number of bits for offsets   (0: 32, 1: 40, 2: 48, 3: 64)
+   * bit 2-3 - number of bits for tile size (0:  0, 1: 24; 2: 32, 3: 64)
+   * bit 4   - sequential ordering hint
+   * bit 5   - use 64 bit dimensions (currently unused because ispe is limited to 32 bit)
+   */
+public:
+  Box_tilC()
+  {
+    set_short_type(fourcc("tilC"));
+
+    init_heif_tiled_image_parameters(m_parameters);
+  }
+
+  bool is_essential() const override { return true; }
+
+  void derive_box_version() override;
+
+  void set_parameters(const heif_tiled_image_parameters& params) { m_parameters = params; }
+
+  void set_compression_format(heif_compression_format format) { m_parameters.compression_format_fourcc = ImageItem::compression_format_to_fourcc_infe_type(format); }
+
+  const heif_tiled_image_parameters& get_parameters() const { return m_parameters; }
+
+  Error write(StreamWriter& writer) const override;
+
+  std::string dump(Indent&) const override;
+
+  std::vector<std::shared_ptr<Box>>& get_tile_properties() { return m_children; }
+
+  const std::vector<std::shared_ptr<Box>>& get_tile_properties() const { return m_children; }
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits* limits) override;
+
+private:
+  heif_tiled_image_parameters m_parameters;
+
+  static void init_heif_tiled_image_parameters(heif_tiled_image_parameters& params);
+};
+
+
+#define TILD_OFFSET_NOT_AVAILABLE 0
+#define TILD_OFFSET_SEE_LOWER_RESOLUTION_LAYER 1
+#define TILD_OFFSET_NOT_LOADED 10
+
+class TiledHeader
+{
+public:
+  Error set_parameters(const heif_tiled_image_parameters& params);
+
+  const heif_tiled_image_parameters& get_parameters() const { return m_parameters; }
+
+  void set_compression_format(heif_compression_format format) { m_parameters.compression_format_fourcc = ImageItem::compression_format_to_fourcc_infe_type(format); }
+
+  Error read_full_offset_table(const std::shared_ptr<HeifFile>& file, heif_item_id tild_id, const heif_security_limits* limits);
+
+  Error read_offset_table_range(const std::shared_ptr<HeifFile>& file, heif_item_id tild_id,
+                                uint64_t start, uint64_t end);
+
+  Result<std::vector<uint8_t>> write_offset_table();
+
+  std::string dump() const;
+
+  void set_tild_tile_range(uint32_t tile_x, uint32_t tile_y, uint64_t offset, uint32_t size);
+
+  size_t get_header_size() const;
+
+  uint64_t get_tile_offset(uint32_t idx) const { return m_offsets[idx].offset; }
+
+  uint32_t get_tile_size(uint32_t idx) const { return m_offsets[idx].size; }
+
+  bool is_tile_offset_known(uint32_t idx) const { return m_offsets[idx].offset != TILD_OFFSET_NOT_LOADED; }
+
+  uint32_t get_offset_table_entry_size() const;
+
+  // Assuming that we have to read offset table 'idx', but we'd like to read more entries at once to reduce
+  // the load of small network transfers (preferred: 'nEntries'). Return a range of indices to read.
+  // This may be less than 'nEntries'. The returned range is [start, end)
+  [[nodiscard]] std::pair<uint32_t, uint32_t> get_tile_offset_table_range_to_read(uint32_t idx, uint32_t nEntries) const;
+
+private:
+  heif_tiled_image_parameters m_parameters;
+
+  struct TileOffset {
+    uint64_t offset = TILD_OFFSET_NOT_LOADED;
+    uint32_t size = 0;
+  };
+
+  // TODO uint64_t m_start_of_offset_table_in_file = 0;
+  std::vector<TileOffset> m_offsets;
+
+  // TODO size_t m_offset_table_start = 0; // start of offset table (= number of bytes in header)
+  size_t m_header_size = 0; // including offset table
+};
+
+
+class ImageItem_Tiled : public ImageItem
+{
+public:
+  ImageItem_Tiled(HeifContext* ctx, heif_item_id id);
+
+  ImageItem_Tiled(HeifContext* ctx);
+
+  ~ImageItem_Tiled() override;
+
+  uint32_t get_infe_type() const override { return fourcc("tili"); }
+
+  // TODO: nclx depends on contained format
+  // const heif_color_profile_nclx* get_forced_output_nclx() const override { return nullptr; }
+
+  heif_compression_format get_compression_format() const override;
+
+  static Result<std::shared_ptr<ImageItem_Tiled>> add_new_tiled_item(HeifContext* ctx, const heif_tiled_image_parameters* parameters,
+                                                                     const heif_encoder* encoder,
+                                                                     const heif_encoding_options* encoding_options);
+
+  Error add_image_tile(uint32_t tile_x, uint32_t tile_y,
+                       const std::shared_ptr<HeifPixelImage>& image,
+                       struct heif_encoder* encoder);
+
+
+  Error initialize_decoder() override;
+
+  Error process_before_write() override;
+
+  Error get_coded_image_colorspace(heif_colorspace* out_colorspace, heif_chroma* out_chroma) const override;
+
+  int get_luma_bits_per_pixel() const override;
+
+  int get_chroma_bits_per_pixel() const override;
+
+  Result<Encoder::CodedImageData> encode(const std::shared_ptr<HeifPixelImage>& image,
+                                         heif_encoder* encoder,
+                                         const heif_encoding_options& options,
+                                         heif_image_input_class input_class) override
+  {
+    return Error{heif_error_Unsupported_feature,
+                 heif_suberror_Unspecified, "Cannot encode image to 'tild'"};
+  }
+
+  Result<std::shared_ptr<HeifPixelImage>> decode_compressed_image(const heif_decoding_options& options,
+                                                                  bool decode_tile_only, uint32_t tile_x0, uint32_t tile_y0,
+                                                                  std::set<heif_item_id> processed_ids) const override;
+
+  heif_brand2 get_compatible_brand() const override;
+
+  // --- tild
+
+  void set_tild_header(const TiledHeader& header) { m_tild_header = header; }
+
+  TiledHeader& get_tild_header() { return m_tild_header; }
+
+  uint64_t get_next_tild_position() const { return m_next_tild_position; }
+
+  void set_next_tild_position(uint64_t pos) { m_next_tild_position = pos; }
+
+  heif_image_tiling get_heif_image_tiling() const override;
+
+  void get_tile_size(uint32_t& w, uint32_t& h) const override;
+
+private:
+  TiledHeader m_tild_header;
+  uint64_t m_next_tild_position = 0;
+
+  heif_orientation m_image_orientation = heif_orientation_normal;
+  heif_encoding_options* m_tile_encoding_options = nullptr;
+
+  uint32_t mReadChunkSize_bytes = 64*1024; // 64 kiB
+  bool m_preload_offset_table = false;
+
+  std::shared_ptr<ImageItem> m_tile_item;
+  std::shared_ptr<Decoder> m_tile_decoder;
+
+  Result<DataExtent>
+  get_compressed_data_for_tile(uint32_t tx, uint32_t ty) const;
+
+  Result<std::shared_ptr<HeifPixelImage>> decode_grid_tile(const heif_decoding_options& options, uint32_t tx, uint32_t ty) const;
+
+  Error load_tile_offset_entry(uint32_t idx);
+
+  Error append_compressed_tile_data(std::vector<uint8_t>& data, uint32_t tx, uint32_t ty) const;
+};
+
+
+#endif //LIBHEIF_TILED_H
diff --git a/libheif/image-items/unc_image.cc b/libheif/image-items/unc_image.cc
new file mode 100644
index 0000000000..d0cba6a46f
--- /dev/null
+++ b/libheif/image-items/unc_image.cc
@@ -0,0 +1,355 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <cstdint>
+#include <cstring>
+#include <algorithm>
+#include <map>
+#include <iostream>
+#include <cassert>
+#include <utility>
+
+#include "common_utils.h"
+#include "context.h"
+#include "compression.h"
+#include "error.h"
+#include "libheif/heif.h"
+#include "codecs/uncompressed/unc_types.h"
+#include "codecs/uncompressed/unc_boxes.h"
+#include "unc_image.h"
+#include "codecs/uncompressed/unc_dec.h"
+#include "codecs/uncompressed/unc_enc.h"
+#include "codecs/uncompressed/unc_codec.h"
+#include "image_item.h"
+#include "codecs/uncompressed/unc_encoder.h"
+
+
+struct unciHeaders;
+
+ImageItem_uncompressed::ImageItem_uncompressed(HeifContext* ctx, heif_item_id id)
+    : ImageItem(ctx, id)
+{
+  m_encoder = std::make_shared<Encoder_uncompressed>();
+}
+
+ImageItem_uncompressed::ImageItem_uncompressed(HeifContext* ctx)
+    : ImageItem(ctx)
+{
+  m_encoder = std::make_shared<Encoder_uncompressed>();
+}
+
+
+Result<std::shared_ptr<HeifPixelImage>> ImageItem_uncompressed::decode_compressed_image(const heif_decoding_options& options,
+                                                                                bool decode_tile_only, uint32_t tile_x0, uint32_t tile_y0,
+                                                                                std::set<heif_item_id> processed_ids) const
+{
+  std::shared_ptr<HeifPixelImage> img;
+
+  std::vector<uint8_t> data;
+
+  Error err;
+
+  if (decode_tile_only) {
+    err = UncompressedImageCodec::decode_uncompressed_image_tile(get_context(),
+                                                                 get_id(),
+                                                                 img,
+                                                                 tile_x0, tile_y0);
+  }
+  else {
+    err = UncompressedImageCodec::decode_uncompressed_image(get_context(),
+                                                            get_id(),
+                                                            img);
+  }
+
+  if (err) {
+    return err;
+  }
+  else {
+    return img;
+  }
+}
+
+
+Result<Encoder::CodedImageData> ImageItem_uncompressed::encode(const std::shared_ptr<HeifPixelImage>& src_image,
+                                                                 heif_encoder* encoder,
+                                                                 const heif_encoding_options& options,
+                                                                 heif_image_input_class input_class)
+{
+  Result<std::unique_ptr<const unc_encoder>> uncEncoder = unc_encoder_factory::get_unc_encoder(src_image, options);
+  if (!uncEncoder) {
+    return {uncEncoder.error()};
+  }
+
+  return (*uncEncoder)->encode(src_image, options);
+}
+
+
+Result<std::shared_ptr<ImageItem_uncompressed>> ImageItem_uncompressed::add_unci_item(HeifContext* ctx,
+                                                                                      const heif_unci_image_parameters* parameters,
+                                                                                      const heif_encoding_options* encoding_options,
+                                                                                      const std::shared_ptr<const HeifPixelImage>& prototype)
+{
+  assert(encoding_options != nullptr);
+
+  // Check input parameters
+
+  if (parameters->image_width % parameters->tile_width != 0 ||
+      parameters->image_height % parameters->tile_height != 0) {
+    return Error{heif_error_Usage_error,
+                 heif_suberror_Invalid_parameter_value,
+                 "ISO 23001-17 image size must be an integer multiple of the tile size."};
+  }
+
+
+  Result<std::unique_ptr<const unc_encoder>> uncEncoder = unc_encoder_factory::get_unc_encoder(prototype, *encoding_options);
+  if (!uncEncoder) {
+    return {uncEncoder.error()};
+  }
+
+
+  // Create 'unci' Item
+
+  auto file = ctx->get_heif_file();
+
+  auto unci_id_result = ctx->get_heif_file()->add_new_image(fourcc("unci"));
+  if (!unci_id_result) {
+    return unci_id_result.error();
+  }
+  heif_item_id unci_id = *unci_id_result;
+  auto unci_image = std::make_shared<ImageItem_uncompressed>(ctx, unci_id);
+  unci_image->set_resolution(parameters->image_width, parameters->image_height);
+  unci_image->m_unc_encoder = std::move(*uncEncoder);
+  unci_image->m_tile_encoding_options = *encoding_options;
+  unci_image->m_tile_encoding_options.image_orientation = heif_orientation_normal;
+
+  ctx->insert_image_item(unci_id, unci_image);
+
+
+  // Generate headers
+
+  // --- generate configuration property boxes
+
+  auto uncC = unci_image->m_unc_encoder->get_uncC();
+
+  uncC->set_number_of_tile_columns(parameters->image_width / parameters->tile_width);
+  uncC->set_number_of_tile_rows(parameters->image_height / parameters->tile_height);
+
+  unci_image->add_property(uncC, true);
+  if (!uncC->is_minimized()) {
+    unci_image->add_property(unci_image->m_unc_encoder->get_cmpd(), true);
+  }
+
+
+  // Add cpat property if Bayer pattern is set
+  if (unci_image->m_unc_encoder->get_cpat()) {
+    unci_image->add_property(unci_image->m_unc_encoder->get_cpat(), true);
+  }
+
+  // Add `ispe` property
+
+  auto ispe = std::make_shared<Box_ispe>();
+  ispe->set_size(static_cast<uint32_t>(parameters->image_width),
+                 static_cast<uint32_t>(parameters->image_height));
+  unci_image->add_property(ispe, true);
+
+  if (parameters->compression != heif_unci_compression_off) {
+    auto cmpC = std::make_shared<Box_cmpC>();
+    cmpC->set_compression_type(unci_compression_to_fourcc(parameters->compression));
+    cmpC->set_compressed_unit_type(heif_cmpC_compressed_unit_type_image_tile);
+
+    unci_image->add_property(cmpC, true);
+
+    auto icef = std::make_shared<Box_icef>();
+    unci_image->add_property_without_deduplication(icef, true); // icef is empty. A normal add_property() would lead to a wrong deduplication.
+  }
+
+  // Add transformative properties
+
+  ctx->get_heif_file()->add_orientation_properties(unci_id, encoding_options->image_orientation);
+
+
+  // Create empty image. If we use compression, we append the data piece by piece.
+
+  if (parameters->compression == heif_unci_compression_off) {
+    uint64_t tile_size = unci_image->m_unc_encoder->compute_tile_data_size_bytes(parameters->image_width / uncC->get_number_of_tile_columns(),
+                                                                                 parameters->image_height / uncC->get_number_of_tile_rows());
+
+    std::vector<uint8_t> dummydata;
+    dummydata.resize(tile_size);
+
+    uint32_t nTiles = (parameters->image_width / parameters->tile_width) * (parameters->image_height / parameters->tile_height);
+
+    for (uint64_t i = 0; i < nTiles; i++) {
+      const int construction_method = 0; // 0=mdat 1=idat
+      file->append_iloc_data(unci_id, dummydata, construction_method);
+    }
+  }
+
+  // Set Brands
+  //ctx->get_heif_file()->set_brand(heif_compression_uncompressed, unci_image->is_miaf_compatible());
+
+  return {unci_image};
+}
+
+
+Error ImageItem_uncompressed::add_image_tile(uint32_t tile_x, uint32_t tile_y, const std::shared_ptr<const HeifPixelImage>& image, bool save_alpha)
+{
+  std::shared_ptr<Box_uncC> uncC = get_property<Box_uncC>();
+  assert(uncC);
+
+  uint32_t tile_width = image->get_width();
+  uint32_t tile_height = image->get_height();
+
+  uint32_t tile_idx = tile_y * uncC->get_number_of_tile_columns() + tile_x;
+
+  if (tile_y >= uncC->get_number_of_tile_rows() ||
+      tile_x >= uncC->get_number_of_tile_columns()) {
+    return Error{heif_error_Usage_error,
+                 heif_suberror_Invalid_parameter_value,
+                 "tile_x and/or tile_y are out of range."};
+  }
+
+
+  if (image->has_alpha() && !save_alpha) {
+    // TODO: drop alpha
+  }
+
+  Result<std::vector<uint8_t>> codedBitstreamResult = m_unc_encoder->encode_tile(image);
+  if (!codedBitstreamResult) {
+    return codedBitstreamResult.error();
+  }
+
+  std::shared_ptr<Box_cmpC> cmpC = get_property<Box_cmpC>();
+  std::shared_ptr<Box_icef> icef = get_property<Box_icef>();
+
+  if (!icef || !cmpC) {
+    assert(!icef);
+    assert(!cmpC);
+
+    // uncompressed
+
+    uint64_t tile_data_size = m_unc_encoder->compute_tile_data_size_bytes(tile_width, tile_height);
+
+    get_file()->replace_iloc_data(get_id(), tile_idx * tile_data_size, *codedBitstreamResult, 0);
+  }
+  else {
+    const std::vector<uint8_t>& raw_data = *codedBitstreamResult;
+
+    auto compressed = compress_unci_fourcc(cmpC->get_compression_type(),
+                                            raw_data.data(), raw_data.size());
+    if (!compressed) {
+      return compressed.error();
+    }
+
+    get_file()->append_iloc_data(get_id(), *compressed, 0);
+
+    Box_icef::CompressedUnitInfo unit_info;
+    unit_info.unit_offset = m_next_tile_write_pos;
+    unit_info.unit_size = compressed->size();
+    icef->set_component(tile_idx, unit_info);
+
+    m_next_tile_write_pos += compressed->size();
+  }
+
+  return Error::Ok;
+}
+
+
+void ImageItem_uncompressed::get_tile_size(uint32_t& w, uint32_t& h) const
+{
+  auto ispe = get_property<Box_ispe>();
+  auto uncC = get_property<Box_uncC>();
+
+  if (!ispe || !uncC) {
+    w = h = 0;
+  }
+  else {
+    w = ispe->get_width() / uncC->get_number_of_tile_columns();
+    h = ispe->get_height() / uncC->get_number_of_tile_rows();
+  }
+}
+
+
+heif_image_tiling ImageItem_uncompressed::get_heif_image_tiling() const
+{
+  heif_image_tiling tiling{};
+
+  auto ispe = get_property<Box_ispe>();
+  auto uncC = get_property<Box_uncC>();
+  assert(ispe && uncC);
+
+  tiling.num_columns = uncC->get_number_of_tile_columns();
+  tiling.num_rows = uncC->get_number_of_tile_rows();
+
+  tiling.tile_width = ispe->get_width() / tiling.num_columns;
+  tiling.tile_height = ispe->get_height() / tiling.num_rows;
+
+  tiling.image_width = ispe->get_width();
+  tiling.image_height = ispe->get_height();
+  tiling.number_of_extra_dimensions = 0;
+
+  return tiling;
+}
+
+Result<std::shared_ptr<Decoder>> ImageItem_uncompressed::get_decoder() const
+{
+  return {m_decoder};
+}
+
+std::shared_ptr<Encoder> ImageItem_uncompressed::get_encoder() const
+{
+  return m_encoder;
+}
+
+Error ImageItem_uncompressed::initialize_decoder()
+{
+  std::shared_ptr<Box_cmpd> cmpd = get_property<Box_cmpd>();
+  std::shared_ptr<Box_uncC> uncC = get_property<Box_uncC>();
+  std::shared_ptr<Box_ispe> ispe = get_property<Box_ispe>();
+
+  if (!uncC) {
+    return Error{heif_error_Invalid_input,
+                 heif_suberror_Unspecified,
+                 "No 'uncC' box found."};
+  }
+
+  m_decoder = std::make_shared<Decoder_uncompressed>(uncC, cmpd, ispe);
+
+  return Error::Ok;
+}
+
+void ImageItem_uncompressed::set_decoder_input_data()
+{
+  DataExtent extent;
+  extent.set_from_image_item(get_context()->get_heif_file(), get_id());
+
+  m_decoder->set_data_extent(std::move(extent));
+}
+
+
+bool ImageItem_uncompressed::has_coded_alpha_channel() const
+{
+  return m_decoder->has_alpha_component();
+}
+
+heif_brand2 ImageItem_uncompressed::get_compatible_brand() const
+{
+  return 0; // TODO: not clear to me what to use
+}
diff --git a/libheif/image-items/unc_image.h b/libheif/image-items/unc_image.h
new file mode 100644
index 0000000000..69c5c7f782
--- /dev/null
+++ b/libheif/image-items/unc_image.h
@@ -0,0 +1,114 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef LIBHEIF_UNC_IMAGE_H
+#define LIBHEIF_UNC_IMAGE_H
+
+#include "pixelimage.h"
+#include "file.h"
+#include "context.h"
+#include "libheif/heif_uncompressed.h"
+
+#include <cstdint>
+#include <string>
+#include <vector>
+#include <memory>
+#include <set>
+#include "codecs/uncompressed/unc_encoder.h"
+
+class unc_encoder;
+class HeifContext;
+
+
+class ImageItem_uncompressed : public ImageItem
+{
+public:
+  ImageItem_uncompressed(HeifContext* ctx, heif_item_id id);
+
+  ImageItem_uncompressed(HeifContext* ctx);
+
+  uint32_t get_infe_type() const override { return fourcc("unci"); }
+
+  heif_compression_format get_compression_format() const override { return heif_compression_uncompressed; }
+
+  // Instead of storing alpha in a separate unci, this is put into the main image item
+  const char* get_auxC_alpha_channel_type() const override { return nullptr; }
+
+  bool has_coded_alpha_channel() const override;
+
+  // const heif_color_profile_nclx* get_forced_output_nclx() const override { return nullptr; }
+
+  bool is_ispe_essential() const override { return true; }
+
+  void get_tile_size(uint32_t& w, uint32_t& h) const override;
+
+  // Code from encode_uncompressed_image() has been moved to here.
+
+  Result<std::shared_ptr<HeifPixelImage>> decode_compressed_image(const heif_decoding_options& options,
+                                                                  bool decode_tile_only, uint32_t tile_x0, uint32_t tile_y0,
+                                                                  std::set<heif_item_id> processed_ids) const override;
+
+  heif_image_tiling get_heif_image_tiling() const override;
+
+  Error initialize_decoder() override;
+
+  void set_decoder_input_data() override;
+
+  heif_brand2 get_compatible_brand() const override;
+
+public:
+
+  // --- encoding
+
+  Result<Encoder::CodedImageData> encode(const std::shared_ptr<HeifPixelImage>& image,
+                                         heif_encoder* encoder,
+                                         const heif_encoding_options& options,
+                                         heif_image_input_class input_class) override;
+
+  static Result<std::shared_ptr<ImageItem_uncompressed> > add_unci_item(HeifContext* ctx,
+                                                                        const heif_unci_image_parameters* parameters,
+                                                                        const heif_encoding_options* encoding_options,
+                                                                        const std::shared_ptr<const HeifPixelImage>& prototype);
+
+  Error add_image_tile(uint32_t tile_x, uint32_t tile_y, const std::shared_ptr<const HeifPixelImage>& image, bool save_alpha);
+
+protected:
+  Result<std::shared_ptr<Decoder>> get_decoder() const override;
+
+  std::shared_ptr<Encoder> get_encoder() const override;
+
+private:
+  std::shared_ptr<class Decoder_uncompressed> m_decoder;
+  std::shared_ptr<class Encoder_uncompressed> m_encoder;
+
+  std::unique_ptr<const unc_encoder> m_unc_encoder;
+  heif_encoding_options m_tile_encoding_options;
+
+  /*
+  Result<ImageItem::CodedImageData> generate_headers(const std::shared_ptr<const HeifPixelImage>& src_image,
+                                                     const heif_unci_image_parameters* parameters,
+                                                     const struct heif_encoding_options* options);
+                                                     */
+
+  uint64_t m_next_tile_write_pos = 0;
+};
+
+#endif //LIBHEIF_UNC_IMAGE_H
diff --git a/libheif/image-items/vvc.cc b/libheif/image-items/vvc.cc
new file mode 100644
index 0000000000..ee2e66a5e1
--- /dev/null
+++ b/libheif/image-items/vvc.cc
@@ -0,0 +1,102 @@
+/*
+ * HEIF VVC codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "vvc.h"
+#include "codecs/vvc_dec.h"
+#include "codecs/vvc_enc.h"
+#include "codecs/vvc_boxes.h"
+#include <cstring>
+#include <string>
+#include <cassert>
+#include "api_structs.h"
+#include <utility>
+
+
+ImageItem_VVC::ImageItem_VVC(HeifContext* ctx, heif_item_id id) : ImageItem(ctx, id)
+{
+  m_encoder = std::make_shared<Encoder_VVC>();
+}
+
+ImageItem_VVC::ImageItem_VVC(HeifContext* ctx) : ImageItem(ctx)
+{
+  m_encoder = std::make_shared<Encoder_VVC>();
+}
+
+
+Result<std::vector<uint8_t>> ImageItem_VVC::read_bitstream_configuration_data() const
+{
+  // --- get codec configuration
+
+  std::shared_ptr<Box_vvcC> vvcC_box = get_property<Box_vvcC>();
+  if (!vvcC_box)
+  {
+    assert(false);
+    return Error(heif_error_Invalid_input,
+                 heif_suberror_No_vvcC_box);
+  }
+
+  std::vector<uint8_t> data;
+  if (!vvcC_box->get_headers(&data))
+  {
+    return Error(heif_error_Invalid_input,
+                 heif_suberror_No_item_data);
+  }
+
+  return data;
+}
+
+
+Result<std::shared_ptr<Decoder>> ImageItem_VVC::get_decoder() const
+{
+  return {m_decoder};
+}
+
+
+std::shared_ptr<class Encoder> ImageItem_VVC::get_encoder() const
+{
+  return m_encoder;
+}
+
+
+Error ImageItem_VVC::initialize_decoder()
+{
+  auto vvcC_box = get_property<Box_vvcC>();
+  if (!vvcC_box) {
+    return Error{heif_error_Invalid_input,
+                 heif_suberror_No_av1C_box};
+  }
+
+  m_decoder = std::make_shared<Decoder_VVC>(vvcC_box);
+
+  return Error::Ok;
+}
+
+void ImageItem_VVC::set_decoder_input_data()
+{
+  DataExtent extent;
+  extent.set_from_image_item(get_context()->get_heif_file(), get_id());
+
+  m_decoder->set_data_extent(std::move(extent));
+}
+
+heif_brand2 ImageItem_VVC::get_compatible_brand() const
+{
+  return heif_brand2_vvic;
+}
diff --git a/libheif/image-items/vvc.h b/libheif/image-items/vvc.h
new file mode 100644
index 0000000000..d5a82d6fac
--- /dev/null
+++ b/libheif/image-items/vvc.h
@@ -0,0 +1,62 @@
+/*
+ * HEIF VVC codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_VVC_H
+#define LIBHEIF_VVC_H
+
+#include "box.h"
+#include <string>
+#include <vector>
+#include "image_item.h"
+#include <memory>
+
+
+class ImageItem_VVC : public ImageItem
+{
+public:
+  ImageItem_VVC(HeifContext* ctx, heif_item_id id);
+
+  ImageItem_VVC(HeifContext* ctx);
+
+  uint32_t get_infe_type() const override { return fourcc("vvc1"); }
+
+  const char* get_auxC_alpha_channel_type() const override { return "urn:mpeg:mpegB:cicp:systems:auxiliary:alpha"; }
+
+  heif_compression_format get_compression_format() const override { return heif_compression_VVC; }
+
+  Error initialize_decoder() override;
+
+  void set_decoder_input_data() override;
+
+  std::shared_ptr<Encoder> get_encoder() const override;
+
+  heif_brand2 get_compatible_brand() const override;
+
+protected:
+  Result<std::shared_ptr<Decoder>> get_decoder() const override;
+
+  Result<std::vector<uint8_t>> read_bitstream_configuration_data() const override;
+
+private:
+  std::shared_ptr<class Decoder_VVC> m_decoder;
+  std::shared_ptr<class Encoder_VVC> m_encoder;
+};
+
+#endif // LIBHEIF_VVC_H
diff --git a/libheif/init.cc b/libheif/init.cc
new file mode 100644
index 0000000000..2dcf598772
--- /dev/null
+++ b/libheif/init.cc
@@ -0,0 +1,449 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2022 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "init.h"
+#include "libheif/heif.h"
+#include "error.h"
+#include "plugin_registry.h"
+#include "common_utils.h"
+#include "color-conversion/colorconversion.h"
+
+#if ENABLE_MULTITHREADING_SUPPORT
+
+#include <mutex>
+
+#endif
+
+#if defined(_WIN32)
+#include "plugins_windows.h"
+#else
+
+#include "plugins_unix.h"
+
+#endif
+
+#define STRINGIFY2(x) #x
+#define STRINGIFY(x) STRINGIFY2(x)
+
+void heif_unload_all_plugins();
+
+#if ENABLE_PLUGIN_LOADING
+
+void heif_unregister_encoder_plugin(const heif_encoder_plugin* plugin);
+
+std::vector<std::string> get_plugin_paths()
+{
+  std::vector<std::string> plugin_paths;
+
+#if defined(_WIN32)
+  plugin_paths = get_plugin_directories_from_environment_variable_windows();
+#else
+  plugin_paths = get_plugin_directories_from_environment_variable_unix();
+#endif
+
+  if (plugin_paths.empty()) {
+    plugin_paths.push_back(LIBHEIF_PLUGIN_DIRECTORY);
+  }
+
+  return plugin_paths;
+}
+
+std::vector<std::string> list_all_potential_plugins_in_directory(const char* directory)
+{
+#if defined(_WIN32)
+  return list_all_potential_plugins_in_directory_windows(directory);
+#else
+  return list_all_potential_plugins_in_directory_unix(directory);
+#endif
+}
+
+#else
+std::vector<std::string> get_plugin_paths()
+{
+  return {};
+}
+#endif
+
+
+static int heif_library_initialization_count = 0;
+static bool default_plugins_registered = true; // because they are implicitly registered at startup
+
+
+#if ENABLE_MULTITHREADING_SUPPORT
+
+static std::recursive_mutex& heif_init_mutex()
+{
+  static std::recursive_mutex init_mutex;
+  return init_mutex;
+}
+
+#endif
+
+
+void load_plugins_if_not_initialized_yet()
+{
+  if (heif_library_initialization_count == 0) {
+    heif_init(nullptr);
+  }
+}
+
+
+heif_error heif_init(heif_init_params*)
+{
+#if ENABLE_MULTITHREADING_SUPPORT
+  std::lock_guard<std::recursive_mutex> lock(heif_init_mutex());
+#endif
+
+  if (heif_library_initialization_count == 0) {
+
+    ColorConversionPipeline::init_ops();
+
+    // --- initialize builtin plugins
+
+    if (!default_plugins_registered) {
+      register_default_plugins();
+    }
+
+#if ENABLE_PLUGIN_LOADING
+    struct heif_error err{};
+    std::vector<std::string> plugin_paths = get_plugin_paths();
+
+    for (const auto& dir : plugin_paths) {
+      err = heif_load_plugins(dir.c_str(), nullptr, nullptr, 0);
+      if (err.code != 0) {
+        return err;
+      }
+    }
+#endif
+  }
+
+  // Note: it is important that we increase the counter AFTER initialization such that
+  // 'load_plugins_if_not_initialized_yet()' can check this without having to lock the mutex.
+  heif_library_initialization_count++;
+
+  return {heif_error_Ok, heif_suberror_Unspecified, Error::kSuccess};
+}
+
+
+void heif_deinit()
+{
+#if ENABLE_MULTITHREADING_SUPPORT
+  std::lock_guard<std::recursive_mutex> lock(heif_init_mutex());
+#endif
+
+  if (heif_library_initialization_count == 0) {
+    // This case should never happen (heif_deinit() is called more often than heif_init()).
+    return;
+  }
+
+  if (heif_library_initialization_count == 1) {
+    heif_unregister_decoder_plugins();
+    heif_unregister_encoder_plugins();
+    default_plugins_registered = false;
+
+    heif_unload_all_plugins();
+
+    ColorConversionPipeline::release_ops();
+  }
+
+  // Note: contrary to heif_init() I think it does not matter whether we decrease the counter before or after deinitialization.
+  // If the client application calls heif_deinit() in parallel to some other libheif function, it is really broken.
+  heif_library_initialization_count--;
+}
+
+
+// This could be inside ENABLE_PLUGIN_LOADING, but the "include-what-you-use" checker cannot process this.
+#include <vector>
+#include <string>
+#include <cstring>
+
+#if ENABLE_PLUGIN_LOADING
+
+#if defined(_WIN32)
+typedef PluginLibrary_Windows PluginLibrary_SysDep;
+#else
+typedef PluginLibrary_Unix PluginLibrary_SysDep;
+#endif
+
+
+struct loaded_plugin
+{
+  PluginLibrary_SysDep plugin_library_handle;
+  struct heif_plugin_info* info = nullptr;
+  int openCnt = 0;
+};
+
+static std::vector<loaded_plugin> sLoadedPlugins;
+
+MAYBE_UNUSED heif_error error_dlopen{heif_error_Plugin_loading_error, heif_suberror_Plugin_loading_error, "Cannot open plugin (dlopen)."};
+MAYBE_UNUSED heif_error error_plugin_not_loaded{heif_error_Plugin_loading_error, heif_suberror_Plugin_is_not_loaded, "Trying to remove a plugin that is not loaded."};
+MAYBE_UNUSED heif_error error_cannot_read_plugin_directory{heif_error_Plugin_loading_error, heif_suberror_Cannot_read_plugin_directory, "Cannot read plugin directory."};
+
+MAYBE_UNUSED static void unregister_plugin(const heif_plugin_info* info)
+{
+  switch (info->type) {
+    case heif_plugin_type_encoder: {
+      auto* encoder_plugin = static_cast<const heif_encoder_plugin*>(info->plugin);
+      heif_unregister_encoder_plugin(encoder_plugin);
+      break;
+    }
+    case heif_plugin_type_decoder: {
+      // TODO
+    }
+  }
+}
+
+
+struct heif_error heif_load_plugin(const char* filename, struct heif_plugin_info const** out_plugin)
+{
+#if ENABLE_MULTITHREADING_SUPPORT
+  std::lock_guard<std::recursive_mutex> lock(heif_init_mutex());
+#endif
+
+  PluginLibrary_SysDep plugin;
+  auto err = plugin.load_from_file(filename);
+  if (err.code) {
+    return err;
+  }
+
+  heif_plugin_info* plugin_info = plugin.get_plugin_info();
+
+  // --- check whether the plugin is already loaded
+  // If yes, return pointer to existing plugin.
+
+  for (auto& p : sLoadedPlugins) {
+    if (p.plugin_library_handle == plugin) {
+      if (out_plugin) {
+        *out_plugin = p.info;
+        p.openCnt++;
+        return heif_error_ok;
+      }
+    }
+  }
+
+  loaded_plugin loadedPlugin;
+  loadedPlugin.plugin_library_handle = plugin;
+  loadedPlugin.openCnt = 1;
+  loadedPlugin.info = plugin_info;
+  sLoadedPlugins.push_back(loadedPlugin);
+
+  *out_plugin = plugin_info;
+
+  switch (loadedPlugin.info->type) {
+    case heif_plugin_type_encoder: {
+      auto* encoder_plugin = static_cast<const heif_encoder_plugin*>(plugin_info->plugin);
+      if (encoder_plugin->plugin_api_version < heif_encoder_plugin_minimum_version) {
+        return {heif_error_Plugin_loading_error,
+                heif_suberror_Unsupported_plugin_version,
+                "Encoder plugin needs to be at least version " STRINGIFY(heif_encoder_plugin_latest_version)
+        };
+      }
+
+      if (encoder_plugin->plugin_api_version >= 4 &&
+          encoder_plugin->minimum_required_libheif_version > heif_get_version_number()) {
+        return {
+          heif_error_Plugin_loading_error,
+          heif_suberror_Unsupported_plugin_version,
+          "Encoder plugin requires at least libheif version " LIBHEIF_VERSION
+        };
+      }
+
+      struct heif_error err = heif_register_encoder_plugin(encoder_plugin);
+      if (err.code) {
+        return err;
+      }
+      break;
+    }
+
+    case heif_plugin_type_decoder: {
+      auto* decoder_plugin = static_cast<const heif_decoder_plugin*>(plugin_info->plugin);
+      if (decoder_plugin->plugin_api_version < heif_decoder_plugin_minimum_version) {
+        return {heif_error_Plugin_loading_error,
+                heif_suberror_Unsupported_plugin_version,
+                "Decoder plugin needs to be at least version " STRINGIFY(heif_decoder_plugin_latest_version)
+        };
+      }
+
+      if (decoder_plugin->plugin_api_version >= 4 &&
+          decoder_plugin->minimum_required_libheif_version > heif_get_version_number()) {
+        return {
+          heif_error_Plugin_loading_error,
+          heif_suberror_Unsupported_plugin_version,
+          "Decoder plugin requires at least libheif version " LIBHEIF_VERSION
+        };
+      }
+
+      struct heif_error err = heif_register_decoder_plugin(decoder_plugin);
+      if (err.code) {
+        return err;
+      }
+      break;
+    }
+  }
+
+  return heif_error_ok;
+}
+
+struct heif_error heif_unload_plugin(const struct heif_plugin_info* plugin)
+{
+#if ENABLE_MULTITHREADING_SUPPORT
+  std::lock_guard<std::recursive_mutex> lock(heif_init_mutex());
+#endif
+
+  for (size_t i = 0; i < sLoadedPlugins.size(); i++) {
+    auto& p = sLoadedPlugins[i];
+
+    if (p.info == plugin) {
+      p.plugin_library_handle.release();
+      p.openCnt--;
+
+      if (p.openCnt == 0) {
+        unregister_plugin(plugin);
+
+        sLoadedPlugins[i] = sLoadedPlugins.back();
+        sLoadedPlugins.pop_back();
+      }
+
+      return heif_error_ok;
+    }
+  }
+
+  return error_plugin_not_loaded;
+}
+
+void heif_unload_all_plugins()
+{
+#if ENABLE_MULTITHREADING_SUPPORT
+  std::lock_guard<std::recursive_mutex> lock(heif_init_mutex());
+#endif
+
+  for (auto& p : sLoadedPlugins) {
+    unregister_plugin(p.info);
+
+    for (int i = 0; i < p.openCnt; i++) {
+      p.plugin_library_handle.release();
+    }
+  }
+
+  sLoadedPlugins.clear();
+}
+
+
+struct heif_error heif_load_plugins(const char* directory,
+                                    const struct heif_plugin_info** out_plugins,
+                                    int* out_nPluginsLoaded,
+                                    int output_array_size)
+{
+  auto libraryFiles = list_all_potential_plugins_in_directory(directory);
+
+  int nPlugins = 0;
+
+  // Loading the plugins may return several errors, but we can only return one of them,
+  // which is remembered here.
+  heif_error err_result = heif_error_ok;
+
+  for (const auto& filename : libraryFiles) {
+    const struct heif_plugin_info* info = nullptr;
+    auto err = heif_load_plugin(filename.c_str(), &info);
+    if (err.code == 0) {
+      if (out_plugins) {
+        if (nPlugins == output_array_size) {
+          break;
+        }
+
+        out_plugins[nPlugins] = info;
+      }
+
+      nPlugins++;
+    }
+    else {
+      // remember error
+      err_result = err;
+    }
+  }
+
+  if (nPlugins < output_array_size && out_plugins) {
+    out_plugins[nPlugins] = nullptr;
+  }
+
+  if (out_nPluginsLoaded) {
+    *out_nPluginsLoaded = nPlugins;
+  }
+
+  return err_result;
+}
+
+#else
+static heif_error heif_error_plugins_unsupported{heif_error_Unsupported_feature, heif_suberror_Unspecified, "Plugins are not supported"};
+
+struct heif_error heif_load_plugin(const char* filename, struct heif_plugin_info const** out_plugin)
+{
+  return heif_error_plugins_unsupported;
+}
+
+
+struct heif_error heif_unload_plugin(const struct heif_plugin_info* plugin)
+{
+  return heif_error_plugins_unsupported;
+}
+
+
+void heif_unload_all_plugins() {}
+
+struct heif_error heif_load_plugins(const char* directory,
+                                    const struct heif_plugin_info** out_plugins,
+                                    int* out_nPluginsLoaded,
+                                    int output_array_size)
+{
+  if (out_nPluginsLoaded) {
+    *out_nPluginsLoaded = 0;
+  }
+
+  return heif_error_plugins_unsupported;
+}
+
+#endif
+
+
+const char* const* heif_get_plugin_directories()
+{
+  auto plugin_paths = get_plugin_paths();
+  size_t n = plugin_paths.size();
+
+  auto out_paths = new char* [n + 1];
+  for (size_t i = 0; i < n; i++) {
+    out_paths[i] = new char[plugin_paths[i].size() + 1];
+    strcpy(out_paths[i], plugin_paths[i].c_str());
+  }
+
+  out_paths[n] = nullptr;
+
+  return out_paths;
+}
+
+
+void heif_free_plugin_directories(const char* const* paths)
+{
+  for (int i = 0; paths[i]; i++) {
+    delete[] paths[i];
+  }
+
+  delete[] paths;
+}
diff --git a/libheif/init.h b/libheif/init.h
new file mode 100644
index 0000000000..80aa431670
--- /dev/null
+++ b/libheif/init.h
@@ -0,0 +1,54 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2022 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef LIBHEIF_INIT_H
+#define LIBHEIF_INIT_H
+
+#include "libheif/heif.h"
+#include <string>
+#include <vector>
+
+extern heif_error error_dlopen;
+extern heif_error error_plugin_not_loaded;
+extern heif_error error_cannot_read_plugin_directory;
+
+// TODO: later, we might defer the default plugin initialization to when they are actually used for the first time.
+// That would prevent them from being initialized every time at program start, even when the application software uses heif_init() later on.
+
+// Note: the loaded plugin is not released automatically then the class is released, because this would require that
+// we reference-count the handle. We do not really need this since releasing the library explicitly with release() is simple enough.
+class PluginLibrary
+{
+public:
+  virtual heif_error load_from_file(const char*) = 0;
+
+  virtual void release() = 0;
+
+  virtual heif_plugin_info* get_plugin_info() = 0;
+};
+
+
+std::vector<std::string> get_plugin_paths();
+
+// This is for implicit initialization when heif_init() is not called.
+void load_plugins_if_not_initialized_yet();
+
+#endif //LIBHEIF_INIT_H
diff --git a/libheif/logging.cc b/libheif/logging.cc
new file mode 100644
index 0000000000..2c2dd9fb73
--- /dev/null
+++ b/libheif/logging.cc
@@ -0,0 +1,75 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "logging.h"
+#include <sstream>
+#include <iomanip>
+
+
+std::string Indent::get_string() const
+{
+  std::stringstream sstr;
+
+  for (int i = 0; i < get_indent(); i++) {
+    sstr << "| ";
+  }
+
+  return sstr.str();
+}
+
+
+std::string write_raw_data_as_hex(const uint8_t* data, size_t len,
+                                  const std::string& firstLineIndent,
+                                  const std::string& remainingLinesIndent)
+{
+  std::stringstream sstr;
+
+  sstr << std::hex << std::setfill('0');
+
+  for (size_t i = 0; i < len; i++) {
+    if (i % 16 == 0) {
+      // start of line
+
+      if (i == 0) {
+        sstr << firstLineIndent;
+      }
+      else {
+        sstr << remainingLinesIndent;
+      }
+      sstr << std::setw(4) << i << ": "; // address
+    }
+    else if (i % 16 == 8) {
+      // space in middle
+      sstr << "  ";
+    }
+    else {
+      // space between bytes
+      sstr << " ";
+    }
+
+    sstr << std::setw(2) << ((int) data[i]);
+
+    if (i % 16 == 15 || i == len - 1) {
+      sstr << "\n";
+    }
+  }
+
+  return sstr.str();
+}
diff --git a/libheif/logging.h b/libheif/logging.h
index b370763f63..555fe6209c 100644
--- a/libheif/logging.h
+++ b/libheif/logging.h
@@ -1,6 +1,6 @@
 /*
  * HEIF codec.
- * Copyright (c) 2017 struktur AG, Dirk Farin <farin@struktur.de>
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
  *
  * This file is part of libheif.
  *
@@ -21,10 +21,6 @@
 #ifndef LIBHEIF_LOGGING_H
 #define LIBHEIF_LOGGING_H
 
-#if defined(HAVE_CONFIG_H)
-#include "config.h"
-#endif
-
 #include <cinttypes>
 #include <cstddef>
 
@@ -35,39 +31,36 @@
 #include <istream>
 
 
-namespace heif {
+class Indent
+{
+public:
+  Indent() = default;
 
-  class Indent
-  {
-  public:
-    Indent() : m_indent(0)
-    {}
+  int get_indent() const { return m_indent; }
 
-    int get_indent() const
-    { return m_indent; }
+  void operator++(int) { m_indent++; }
 
-    void operator++(int)
-    { m_indent++; }
-
-    void operator--(int)
-    {
-      m_indent--;
-      if (m_indent < 0) m_indent = 0;
-    }
+  void operator--(int)
+  {
+    m_indent--;
+    if (m_indent < 0) m_indent = 0;
+  }
 
-  private:
-    int m_indent;
-  };
+  std::string get_string() const;
 
+private:
+  int m_indent = 0;
+};
 
-  inline std::ostream& operator<<(std::ostream& ostr, const Indent& indent)
-  {
-    for (int i = 0; i < indent.get_indent(); i++) {
-      ostr << "| ";
-    }
 
-    return ostr;
-  }
+inline std::ostream& operator<<(std::ostream& ostr, const Indent& indent)
+{
+  ostr << indent.get_string();
+  return ostr;
 }
 
+std::string write_raw_data_as_hex(const uint8_t* data, size_t len,
+                                  const std::string& firstLineIndent,
+                                  const std::string& remainingLinesIndent);
+
 #endif
diff --git a/libheif/mdat_data.h b/libheif/mdat_data.h
new file mode 100644
index 0000000000..53feabe696
--- /dev/null
+++ b/libheif/mdat_data.h
@@ -0,0 +1,65 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_MDAT_DATA_H
+#define LIBHEIF_MDAT_DATA_H
+
+#include <cstdint>
+#include <vector>
+#include <cassert>
+#include <algorithm>
+
+
+class MdatData
+{
+public:
+  virtual ~MdatData() = default;
+
+  // returns the start position of the appended data
+  virtual size_t append_data(const std::vector<uint8_t>& data) = 0;
+
+  virtual size_t get_data_size() const = 0;
+
+  virtual Error write(StreamWriter&) = 0;
+};
+
+
+class MdatData_Memory : public MdatData
+{
+public:
+  size_t append_data(const std::vector<uint8_t>& data) override {
+    size_t startPos = m_data.size();
+    m_data.insert(m_data.end(), data.begin(), data.end());
+    return startPos;
+  }
+
+  size_t get_data_size() const override { return m_data.size(); }
+
+  Error write(StreamWriter& writer) override
+  {
+    writer.write(m_data);
+    return Error::Ok;
+  }
+
+private:
+  std::vector<uint8_t> m_data;
+};
+
+#endif //LIBHEIF_MDAT_DATA_H
diff --git a/libheif/mini.cc b/libheif/mini.cc
new file mode 100644
index 0000000000..dc689b1803
--- /dev/null
+++ b/libheif/mini.cc
@@ -0,0 +1,1033 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Brad Hards <bradh@frogmouth.net>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "mini.h"
+#include "file.h"
+#include "codecs/avif_boxes.h"
+#include "codecs/hevc_boxes.h"
+
+#include <cmath>
+#include <cstddef>
+#include <memory>
+#include <string>
+#include <vector>
+#include <utility>
+
+
+Error Box_mini::parse(BitstreamRange &range, const heif_security_limits *limits)
+{
+  uint64_t start_offset = range.get_istream()->get_position();
+  std::size_t length = range.get_remaining_bytes();
+  std::vector<uint8_t> mini_data(length);
+  range.read(mini_data.data(), mini_data.size());
+  BitReader bits(mini_data.data(), (int)(mini_data.size()));
+  m_version = bits.get_bits8(2);
+  m_explicit_codec_types_flag = bits.get_flag();
+  m_float_flag = bits.get_flag();
+  m_full_range_flag = bits.get_flag();
+  m_alpha_flag = bits.get_flag();
+  m_explicit_cicp_flag = bits.get_flag();
+  m_hdr_flag = bits.get_flag();
+  m_icc_flag = bits.get_flag();
+  m_exif_flag = bits.get_flag();
+  m_xmp_flag = bits.get_flag();
+  m_chroma_subsampling = bits.get_bits8(2);
+  m_orientation = bits.get_bits8(3) + 1;
+  bool small_dimensions_flag = bits.get_flag();
+  if (small_dimensions_flag)
+  {
+    m_width = 1 + bits.get_bits32(7);
+    m_height = 1 + bits.get_bits32(7);
+  }
+  else
+  {
+    m_width = 1 + bits.get_bits32(15);
+    m_height = 1 + bits.get_bits32(15);
+  }
+  if ((m_chroma_subsampling == 1) || (m_chroma_subsampling == 2))
+  {
+    m_chroma_is_horizontally_centred = bits.get_flag();
+  }
+  if (m_chroma_subsampling == 1)
+  {
+    m_chroma_is_vertically_centred = bits.get_flag();
+  }
+
+  bool high_bit_depth_flag = false;
+  if (m_float_flag)
+  {
+    uint8_t bit_depth_log2_minus4 = bits.get_bits8(2);
+    m_bit_depth = (uint8_t)powl(2, (bit_depth_log2_minus4 + 4));
+  }
+  else
+  {
+    high_bit_depth_flag = bits.get_flag();
+    if (high_bit_depth_flag)
+    {
+      m_bit_depth = 9 + bits.get_bits8(3);
+    }
+  }
+
+  if (m_alpha_flag)
+  {
+    m_alpha_is_premultiplied = bits.get_flag();
+  }
+
+  if (m_explicit_cicp_flag)
+  {
+    m_colour_primaries = bits.get_bits8(8);
+    m_transfer_characteristics = bits.get_bits8(8);
+    if (m_chroma_subsampling != 0)
+    {
+      m_matrix_coefficients = bits.get_bits8(8);
+    }
+    else
+    {
+      m_matrix_coefficients = 2;
+    }
+  }
+  else
+  {
+    m_colour_primaries = m_icc_flag ? 2 : 1;
+    m_transfer_characteristics = m_icc_flag ? 2 : 13;
+    m_matrix_coefficients = (m_chroma_subsampling == 0) ? 2 : 6;
+  }
+
+  if (m_explicit_codec_types_flag)
+  {
+    m_infe_type = bits.get_bits32(32);
+    m_codec_config_type = bits.get_bits32(32);
+  }
+  if (m_hdr_flag)
+  {
+    m_gainmap_flag = bits.get_flag();
+    if (m_gainmap_flag)
+    {
+      uint32_t gainmap_width_minus1 = bits.get_bits32(small_dimensions_flag ? 7 : 15);
+      m_gainmap_width = gainmap_width_minus1 + 1;
+      uint32_t gainmap_height_minus1 = bits.get_bits32(small_dimensions_flag ? 7 : 15);
+      m_gainmap_height = gainmap_height_minus1 + 1;
+      m_gainmap_matrix_coefficients = bits.get_bits8(8);
+      m_gainmap_full_range_flag = bits.get_flag();
+      m_gainmap_chroma_subsampling = bits.get_bits8(2);
+      if ((m_gainmap_chroma_subsampling == 1) || (m_gainmap_chroma_subsampling == 2))
+      {
+        m_gainmap_chroma_is_horizontally_centred = bits.get_flag();
+      }
+      if (m_gainmap_chroma_subsampling == 1)
+      {
+        m_gainmap_chroma_is_vertically_centred = bits.get_flag();
+      }
+      m_gainmap_float_flag = bits.get_flag();
+
+      bool gainmap_high_bit_depth_flag = false;
+      if (m_gainmap_float_flag)
+      {
+        uint8_t bit_depth_log2_minus4 = bits.get_bits8(2);
+        m_gainmap_bit_depth = (uint8_t)powl(2, (bit_depth_log2_minus4 + 4));
+      }
+      else
+      {
+        gainmap_high_bit_depth_flag = bits.get_flag();
+        if (gainmap_high_bit_depth_flag)
+        {
+          m_gainmap_bit_depth = 9 + bits.get_bits8(3);
+        }
+      }
+      m_tmap_icc_flag = bits.get_flag();
+      m_tmap_explicit_cicp_flag = bits.get_flag();
+      if (m_tmap_explicit_cicp_flag)
+      {
+        m_tmap_colour_primaries = bits.get_bits8(8);
+        m_tmap_transfer_characteristics = bits.get_bits8(8);
+        m_tmap_matrix_coefficients = bits.get_bits8(8);
+        m_tmap_full_range_flag = bits.get_flag();
+      }
+      else
+      {
+        m_tmap_colour_primaries = 1;
+        m_tmap_transfer_characteristics = 13;
+        m_tmap_matrix_coefficients = 6;
+        m_tmap_full_range_flag = true;
+      }
+    }
+
+    bool clli_flag = bits.get_flag();
+    bool mdcv_flag = bits.get_flag();
+    bool cclv_flag = bits.get_flag();
+    bool amve_flag = bits.get_flag();
+    m_reve_flag = bits.get_flag();
+    m_ndwt_flag = bits.get_flag();
+
+    if (clli_flag)
+    {
+      m_clli = std::make_shared<Box_clli>();
+      m_clli->clli.max_content_light_level = bits.get_bits16(16);
+      m_clli->clli.max_pic_average_light_level = bits.get_bits16(16);
+    }
+
+    if (mdcv_flag)
+    {
+      m_mdcv = std::make_shared<Box_mdcv>();
+      for (int c = 0; c < 3; c++)
+      {
+        m_mdcv->mdcv.display_primaries_x[c] = bits.get_bits16(16);
+        m_mdcv->mdcv.display_primaries_y[c] = bits.get_bits16(16);
+      }
+
+      m_mdcv->mdcv.white_point_x = bits.get_bits16(16);
+      m_mdcv->mdcv.white_point_y = bits.get_bits16(16);
+      m_mdcv->mdcv.max_display_mastering_luminance = bits.get_bits32(32);
+      m_mdcv->mdcv.min_display_mastering_luminance = bits.get_bits32(32);
+    }
+
+    if (cclv_flag)
+    {
+      m_cclv = std::make_shared<Box_cclv>();
+      bits.skip_bits(2);
+      bool ccv_primaries_present_flag = bits.get_flag();
+      bool ccv_min_luminance_value_present_flag = bits.get_flag();
+      bool ccv_max_luminance_value_present_flag = bits.get_flag();
+      bool ccv_avg_luminance_value_present_flag = bits.get_flag();
+      bits.skip_bits(2);
+      if (ccv_primaries_present_flag)
+      {
+        int32_t x0 = bits.get_bits32s();
+        int32_t y0 = bits.get_bits32s();
+        int32_t x1 = bits.get_bits32s();
+        int32_t y1 = bits.get_bits32s();
+        int32_t x2 = bits.get_bits32s();
+        int32_t y2 = bits.get_bits32s();
+        m_cclv->set_primaries(x0, y0, x1, y1, x2, y2);
+      }
+      if (ccv_min_luminance_value_present_flag)
+      {
+        m_cclv->set_min_luminance(bits.get_bits32(32));
+      }
+      if (ccv_max_luminance_value_present_flag)
+      {
+        m_cclv->set_max_luminance(bits.get_bits32(32));
+      }
+      if (ccv_avg_luminance_value_present_flag)
+      {
+        m_cclv->set_avg_luminance(bits.get_bits32(32));
+      }
+    }
+
+    if (amve_flag)
+    {
+      m_amve = std::make_shared<Box_amve>();
+      m_amve->amve.ambient_illumination = bits.get_bits32(32);
+      m_amve->amve.ambient_light_x = bits.get_bits16(16);
+      m_amve->amve.ambient_light_y = bits.get_bits16(16);
+    }
+
+    if (m_reve_flag)
+    {
+      // TODO: ReferenceViewingEnvironment isn't published yet
+      bits.skip_bits(32);
+      bits.skip_bits(16);
+      bits.skip_bits(16);
+      bits.skip_bits(32);
+      bits.skip_bits(16);
+      bits.skip_bits(16);
+    }
+
+    if (m_ndwt_flag)
+    {
+      // TODO: NominalDiffuseWhite isn't published yet
+      bits.skip_bits(32);
+    }
+
+    if (m_gainmap_flag)
+    {
+      bool tmap_clli_flag = bits.get_flag();
+      bool tmap_mdcv_flag = bits.get_flag();
+      bool tmap_cclv_flag = bits.get_flag();
+      bool tmap_amve_flag = bits.get_flag();
+      m_tmap_reve_flag = bits.get_flag();
+      m_tmap_ndwt_flag = bits.get_flag();
+
+      if (tmap_clli_flag)
+      {
+        m_tmap_clli = std::make_shared<Box_clli>();
+        m_tmap_clli->clli.max_content_light_level = (uint16_t)bits.get_bits32(16);
+        m_tmap_clli->clli.max_pic_average_light_level = (uint16_t)bits.get_bits32(16);
+      }
+
+      if (tmap_mdcv_flag)
+      {
+        m_tmap_mdcv = std::make_shared<Box_mdcv>();
+        for (int c = 0; c < 3; c++)
+        {
+          m_tmap_mdcv->mdcv.display_primaries_x[c] = bits.get_bits16(16);
+          m_tmap_mdcv->mdcv.display_primaries_y[c] = bits.get_bits16(16);
+        }
+
+        m_tmap_mdcv->mdcv.white_point_x = bits.get_bits16(16);
+        m_tmap_mdcv->mdcv.white_point_y = bits.get_bits16(16);
+        m_tmap_mdcv->mdcv.max_display_mastering_luminance = bits.get_bits32(32);
+        m_tmap_mdcv->mdcv.min_display_mastering_luminance = bits.get_bits32(32);
+      }
+
+      if (tmap_cclv_flag)
+      {
+        m_tmap_cclv = std::make_shared<Box_cclv>();
+        bits.skip_bits(2); // skip ccv_cancel_flag and ccv_persistence_flag
+        bool ccv_primaries_present_flag = bits.get_flag();
+        bool ccv_min_luminance_value_present_flag = bits.get_flag();
+        bool ccv_max_luminance_value_present_flag = bits.get_flag();
+        bool ccv_avg_luminance_value_present_flag = bits.get_flag();
+        bits.skip_bits(2);
+        if (ccv_primaries_present_flag)
+        {
+          int32_t x0 = bits.get_bits32s();
+          int32_t y0 = bits.get_bits32s();
+          int32_t x1 = bits.get_bits32s();
+          int32_t y1 = bits.get_bits32s();
+          int32_t x2 = bits.get_bits32s();
+          int32_t y2 = bits.get_bits32s();
+          m_tmap_cclv->set_primaries(x0, y0, x1, y1, x2, y2);
+        }
+        if (ccv_min_luminance_value_present_flag)
+        {
+          m_tmap_cclv->set_min_luminance(bits.get_bits32(32));
+        }
+        if (ccv_max_luminance_value_present_flag)
+        {
+          m_tmap_cclv->set_max_luminance(bits.get_bits32(32));
+        }
+        if (ccv_avg_luminance_value_present_flag)
+        {
+          m_tmap_cclv->set_avg_luminance(bits.get_bits32(32));
+        }
+      }
+
+      if (tmap_amve_flag)
+      {
+        m_tmap_amve = std::make_shared<Box_amve>();
+        m_tmap_amve->amve.ambient_illumination = bits.get_bits32(32);
+        m_tmap_amve->amve.ambient_light_x = bits.get_bits16(16);
+        m_tmap_amve->amve.ambient_light_y = bits.get_bits16(16);
+      }
+
+      if (m_tmap_reve_flag)
+      {
+        // TODO: ReferenceViewingEnvironment isn't published yet
+        bits.skip_bits(32);
+        bits.skip_bits(16);
+        bits.skip_bits(16);
+        bits.skip_bits(32);
+        bits.skip_bits(16);
+        bits.skip_bits(16);
+      }
+
+      if (m_tmap_ndwt_flag)
+      {
+        // TODO: NominalDiffuseWhite isn't published yet
+        bits.skip_bits(32);
+      }
+    }
+  }
+
+  // Chunk sizes
+  bool few_metadata_bytes_flag = false;
+  if (m_icc_flag || m_exif_flag || m_xmp_flag || (m_hdr_flag && m_gainmap_flag))
+  {
+    few_metadata_bytes_flag = bits.get_flag();
+  }
+  bool few_codec_config_bytes_flag = bits.get_flag();
+  bool few_item_data_bytes_flag = bits.get_flag();
+
+  uint32_t icc_data_size = 0;
+  if (m_icc_flag)
+  {
+    icc_data_size = bits.get_bits32(few_metadata_bytes_flag ? 10 : 20) + 1;
+  }
+  uint32_t tmap_icc_data_size = 0;
+  if (m_hdr_flag && m_gainmap_flag && m_tmap_icc_flag)
+  {
+    tmap_icc_data_size = bits.get_bits32(few_metadata_bytes_flag ? 10 : 20) + 1;
+  }
+  uint32_t gainmap_metadata_size = 0;
+  if (m_hdr_flag && m_gainmap_flag)
+  {
+    gainmap_metadata_size = bits.get_bits32(few_metadata_bytes_flag ? 10 : 20);
+  }
+  if (m_hdr_flag && m_gainmap_flag)
+  {
+    m_gainmap_item_data_size = bits.get_bits32(few_item_data_bytes_flag ? 15 : 28);
+  }
+  uint32_t gainmap_item_codec_config_size = 0;
+  if (m_hdr_flag && m_gainmap_flag && (m_gainmap_item_data_size > 0))
+  {
+    gainmap_item_codec_config_size = bits.get_bits32(few_codec_config_bytes_flag ? 3 : 12);
+  }
+
+  uint32_t main_item_codec_config_size = bits.get_bits32(few_codec_config_bytes_flag ? 3 : 12);
+  m_main_item_data_size = bits.get_bits32(few_item_data_bytes_flag ? 15 : 28) + 1;
+
+  if (m_alpha_flag)
+  {
+    m_alpha_item_data_size = bits.get_bits32(few_item_data_bytes_flag ? 15 : 28);
+  }
+  uint32_t alpha_item_codec_config_size = 0;
+  if (m_alpha_flag && (m_alpha_item_data_size > 0))
+  {
+    alpha_item_codec_config_size = bits.get_bits32(few_codec_config_bytes_flag ? 3 : 12);
+  }
+
+  if (m_exif_flag)
+  {
+    m_exif_item_data_size = bits.get_bits32(few_metadata_bytes_flag ? 10 : 20) + 1;
+  }
+  if (m_xmp_flag)
+  {
+    m_xmp_item_data_size = bits.get_bits32(few_metadata_bytes_flag ? 10 : 20) + 1;
+  }
+
+  bits.skip_to_byte_boundary();
+
+  // Chunks
+  if (m_alpha_flag && (m_alpha_item_data_size > 0) && (alpha_item_codec_config_size > 0))
+  {
+    m_alpha_item_codec_config = bits.read_bytes(alpha_item_codec_config_size);
+  }
+  if (m_hdr_flag && m_gainmap_flag && (gainmap_item_codec_config_size > 0))
+  {
+    m_gainmap_item_codec_config = bits.read_bytes(gainmap_item_codec_config_size);
+  }
+  if (main_item_codec_config_size > 0)
+  {
+    m_main_item_codec_config = bits.read_bytes(main_item_codec_config_size);
+  }
+
+  if (m_icc_flag)
+  {
+    m_icc_data = bits.read_bytes(icc_data_size);
+  }
+  if (m_hdr_flag && m_gainmap_flag && m_tmap_icc_flag)
+  {
+    m_tmap_icc_data = bits.read_bytes(tmap_icc_data_size);
+  }
+  if (m_hdr_flag && m_gainmap_flag && (gainmap_metadata_size > 0))
+  {
+    m_gainmap_metadata = bits.read_bytes(gainmap_metadata_size);
+  }
+
+  if (m_alpha_flag && (m_alpha_item_data_size > 0))
+  {
+    m_alpha_item_data_offset = bits.get_current_byte_index() + start_offset;
+    bits.skip_bytes(m_alpha_item_data_size);
+  }
+  if (m_alpha_flag && m_gainmap_flag && (m_gainmap_item_data_size > 0))
+  {
+    m_gainmap_item_data_offset = bits.get_current_byte_index() + start_offset;
+    bits.skip_bits(m_gainmap_item_data_size);
+  }
+
+  m_main_item_data_offset = bits.get_current_byte_index() + start_offset;
+  bits.skip_bytes(m_main_item_data_size);
+
+  if (m_exif_flag)
+  {
+    m_exif_item_data_offset = bits.get_current_byte_index() + start_offset;
+    bits.skip_bytes(m_exif_item_data_size);
+  }
+  if (m_xmp_flag)
+  {
+    m_xmp_item_data_offset = bits.get_current_byte_index() + start_offset;
+    bits.skip_bytes(m_xmp_item_data_size);
+  }
+  return range.get_error();
+}
+
+std::string Box_mini::dump(Indent &indent) const
+{
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
+  sstr << indent << "version: " << (int)m_version << "\n";
+
+  sstr << indent << "explicit_codec_types_flag: " << m_explicit_codec_types_flag << "\n";
+  sstr << indent << "float_flag: " << m_float_flag << "\n";
+  sstr << indent << "full_range_flag: " << m_full_range_flag << "\n";
+  sstr << indent << "alpha_flag: " << m_alpha_flag << "\n";
+  sstr << indent << "explicit_cicp_flag: " << m_explicit_cicp_flag << "\n";
+  sstr << indent << "hdr_flag: " << m_hdr_flag << "\n";
+  sstr << indent << "icc_flag: " << m_icc_flag << "\n";
+  sstr << indent << "exif_flag: " << m_exif_flag << "\n";
+  sstr << indent << "xmp_flag: " << m_xmp_flag << "\n";
+
+  sstr << indent << "chroma_subsampling: " << (int)m_chroma_subsampling << "\n";
+  sstr << indent << "orientation: " << (int)m_orientation << "\n";
+
+  sstr << indent << "width: " << m_width << "\n";
+  sstr << indent << "height: " << m_height << "\n";
+
+  if ((m_chroma_subsampling == 1) || (m_chroma_subsampling == 2))
+  {
+    sstr << indent << "chroma_is_horizontally_centered: " << m_chroma_is_horizontally_centred << "\n";
+  }
+  if (m_chroma_subsampling == 1)
+  {
+    sstr << indent << "chroma_is_vertically_centered: " << m_chroma_is_vertically_centred << "\n";
+  }
+
+  sstr << "bit_depth: " << (int)m_bit_depth << "\n";
+
+  if (m_alpha_flag)
+  {
+    sstr << "alpha_is_premultiplied: " << m_alpha_is_premultiplied << "\n";
+  }
+
+  sstr << "colour_primaries: " << (int)m_colour_primaries << "\n";
+  sstr << "transfer_characteristics: " << (int)m_transfer_characteristics << "\n";
+  sstr << "matrix_coefficients: " << (int)m_matrix_coefficients << "\n";
+
+  if (m_explicit_codec_types_flag)
+  {
+    sstr << "infe_type: " << fourcc_to_string(m_infe_type) << " (" << m_infe_type << ")" << "\n";
+    sstr << "codec_config_type: " << fourcc_to_string(m_codec_config_type) << " (" << m_codec_config_type << ")" << "\n";
+  }
+
+  if (m_hdr_flag)
+  {
+    sstr << indent << "gainmap_flag: " << m_gainmap_flag << "\n";
+    if (m_gainmap_flag)
+    {
+      sstr << indent << "gainmap_width: " << m_gainmap_width << "\n";
+      sstr << indent << "gainmap_height: " << m_gainmap_height << "\n";
+      sstr << indent << "gainmap_matrix_coefficients: " << (int)m_gainmap_matrix_coefficients << "\n";
+      sstr << indent << "gainmap_full_range_flag: " << m_gainmap_full_range_flag << "\n";
+      sstr << indent << "gainmap_chroma_subsampling: " << (int)m_gainmap_chroma_subsampling << "\n";
+      if ((m_gainmap_chroma_subsampling == 1) || (m_gainmap_chroma_subsampling == 2))
+      {
+        sstr << indent << "gainmap_chroma_is_horizontally_centred: " << m_gainmap_chroma_is_horizontally_centred << "\n";
+      }
+      if (m_gainmap_chroma_subsampling == 1)
+      {
+        sstr << indent << "gainmap_chroma_is_vertically_centred: " << m_gainmap_chroma_is_vertically_centred << "\n";
+      }
+      sstr << indent << "gainmap_float_flag: " << m_gainmap_float_flag << "\n";
+      sstr << "gainmap_bit_depth: " << (int)m_gainmap_bit_depth << "\n";
+      sstr << indent << "tmap_icc_flag: " << m_tmap_icc_flag << "\n";
+      sstr << indent << "tmap_explicit_cicp_flag: " << m_tmap_explicit_cicp_flag << "\n";
+      if (m_tmap_explicit_cicp_flag)
+      {
+        sstr << "tmap_colour_primaries: " << (int)m_tmap_colour_primaries << "\n";
+        sstr << "tmap_transfer_characteristics: " << (int)m_tmap_transfer_characteristics << "\n";
+        sstr << "tmap_matrix_coefficients: " << (int)m_tmap_matrix_coefficients << "\n";
+        sstr << "tmap_full_range_flag: " << m_tmap_full_range_flag << "\n";
+      }
+    }
+
+    if (m_clli)
+    {
+      sstr << indent << "ccli.max_content_light_level: " << m_clli->clli.max_content_light_level << "\n";
+      sstr << indent << "ccli.max_pic_average_light_level: " << m_clli->clli.max_pic_average_light_level << "\n";
+    }
+    else {
+      sstr << indent << "clli: ---\n";
+    }
+
+    if (m_mdcv)
+    {
+      sstr << indent << "mdcv.display_primaries (x,y): ";
+      sstr << "(" << m_mdcv->mdcv.display_primaries_x[0] << ";" << m_mdcv->mdcv.display_primaries_y[0] << "), ";
+      sstr << "(" << m_mdcv->mdcv.display_primaries_x[1] << ";" << m_mdcv->mdcv.display_primaries_y[1] << "), ";
+      sstr << "(" << m_mdcv->mdcv.display_primaries_x[2] << ";" << m_mdcv->mdcv.display_primaries_y[2] << ")\n";
+
+      sstr << indent << "mdcv.white point (x,y): (" << m_mdcv->mdcv.white_point_x << ";" << m_mdcv->mdcv.white_point_y << ")\n";
+      sstr << indent << "mdcv.max display mastering luminance: " << m_mdcv->mdcv.max_display_mastering_luminance << "\n";
+      sstr << indent << "mdcv.min display mastering luminance: " << m_mdcv->mdcv.min_display_mastering_luminance << "\n";
+    }
+    else {
+      sstr << indent << "mdcv: ---\n";
+    }
+
+    if (m_cclv)
+    {
+      sstr << indent << "cclv.ccv_primaries_present_flag: " << m_cclv->ccv_primaries_are_valid() << "\n";
+      sstr << indent << "cclv.ccv_min_luminance_value_present_flag: " << m_cclv->min_luminance_is_valid() << "\n";
+      sstr << indent << "cclv.ccv_max_luminance_value_present_flag: " << m_cclv->max_luminance_is_valid() << "\n";
+      sstr << indent << "cclv.ccv_avg_luminance_value_present_flag: " << m_cclv->avg_luminance_is_valid() << "\n";
+      if (m_cclv->ccv_primaries_are_valid())
+      {
+        sstr << indent << "cclv.ccv_primaries (x,y): ";
+        sstr << "(" << m_cclv->get_ccv_primary_x0() << ";" << m_cclv->get_ccv_primary_y0() << "), ";
+        sstr << "(" << m_cclv->get_ccv_primary_x1() << ";" << m_cclv->get_ccv_primary_y1() << "), ";
+        sstr << "(" << m_cclv->get_ccv_primary_x2() << ";" << m_cclv->get_ccv_primary_y2() << ")\n";
+      }
+      if (m_cclv->min_luminance_is_valid())
+      {
+        sstr << indent << "cclv.ccv_min_luminance_value: " << m_cclv->get_min_luminance() << "\n";
+      }
+      if (m_cclv->max_luminance_is_valid())
+      {
+        sstr << indent << "cclv.ccv_max_luminance_value: " << m_cclv->get_max_luminance() << "\n";
+      }
+      if (m_cclv->avg_luminance_is_valid())
+      {
+        sstr << indent << "cclv.ccv_avg_luminance_value: " << m_cclv->get_avg_luminance() << "\n";
+      }
+    }
+    else {
+      sstr << indent << "cclv: ---\n";
+    }
+
+    if (m_amve)
+    {
+      sstr << indent << "amve.ambient_illumination: " << m_amve->amve.ambient_illumination << "\n";
+      sstr << indent << "amve.ambient_light_x: " << m_amve->amve.ambient_light_x << "\n";
+      sstr << indent << "amve.ambient_light_y: " << m_amve->amve.ambient_light_y << "\n";
+    }
+    else {
+      sstr << indent << "amve: ---\n";
+    }
+
+    sstr << indent << "reve_flag: " << m_reve_flag << "\n";
+    sstr << indent << "ndwt_flag: " << m_ndwt_flag << "\n";
+
+    if (m_reve_flag)
+    {
+      // TODO - this isn't published yet
+    }
+    if (m_ndwt_flag)
+    {
+      // TODO - this isn't published yet
+    }
+
+    if (m_gainmap_flag)
+    {
+      if (m_tmap_clli)
+      {
+        sstr << indent << "tmap_clli.max_content_light_level: " << m_tmap_clli->clli.max_content_light_level << "\n";
+        sstr << indent << "tmap_clli.max_pic_average_light_level: " << m_tmap_clli->clli.max_pic_average_light_level << "\n";
+      }
+      else {
+        sstr << indent << "tmap_clli: ---\n";
+      }
+
+      if (m_tmap_mdcv)
+      {
+        sstr << indent << "tmap_mdcv.display_primaries (x,y): ";
+        sstr << "(" << m_tmap_mdcv->mdcv.display_primaries_x[0] << ";" << m_tmap_mdcv->mdcv.display_primaries_y[0] << "), ";
+        sstr << "(" << m_tmap_mdcv->mdcv.display_primaries_x[1] << ";" << m_tmap_mdcv->mdcv.display_primaries_y[1] << "), ";
+        sstr << "(" << m_tmap_mdcv->mdcv.display_primaries_x[2] << ";" << m_tmap_mdcv->mdcv.display_primaries_y[2] << ")\n";
+
+        sstr << indent << "tmap_mdcv.white point (x,y): (" << m_tmap_mdcv->mdcv.white_point_x << ";" << m_tmap_mdcv->mdcv.white_point_y << ")\n";
+        sstr << indent << "tmap_mdcv.max display mastering luminance: " << m_tmap_mdcv->mdcv.max_display_mastering_luminance << "\n";
+        sstr << indent << "tmap_mdcv.min display mastering luminance: " << m_tmap_mdcv->mdcv.min_display_mastering_luminance << "\n";
+      }
+      else {
+        sstr << indent << "tmap_mdcv: ---\n";
+      }
+
+      if (m_tmap_cclv)
+      {
+        sstr << indent << "tmap_cclv.ccv_primaries_present_flag: " << m_tmap_cclv->ccv_primaries_are_valid() << "\n";
+        sstr << indent << "tmap_cclv.ccv_min_luminance_value_present_flag: " << m_tmap_cclv->min_luminance_is_valid() << "\n";
+        sstr << indent << "tmap_cclv.ccv_max_luminance_value_present_flag: " << m_tmap_cclv->max_luminance_is_valid() << "\n";
+        sstr << indent << "tmap_cclv.ccv_avg_luminance_value_present_flag: " << m_tmap_cclv->avg_luminance_is_valid() << "\n";
+        if (m_tmap_cclv->ccv_primaries_are_valid())
+        {
+          sstr << indent << "tmap_cclv.ccv_primaries (x,y): ";
+          sstr << "(" << m_tmap_cclv->get_ccv_primary_x0() << ";" << m_tmap_cclv->get_ccv_primary_y0() << "), ";
+          sstr << "(" << m_tmap_cclv->get_ccv_primary_x1() << ";" << m_tmap_cclv->get_ccv_primary_y1() << "), ";
+          sstr << "(" << m_tmap_cclv->get_ccv_primary_x2() << ";" << m_tmap_cclv->get_ccv_primary_y2() << ")\n";
+        }
+        if (m_tmap_cclv->min_luminance_is_valid())
+        {
+          sstr << indent << "tmap_cclv.ccv_min_luminance_value: " << m_tmap_cclv->get_min_luminance() << "\n";
+        }
+        if (m_tmap_cclv->max_luminance_is_valid())
+        {
+          sstr << indent << "tmap_cclv.ccv_max_luminance_value: " << m_tmap_cclv->get_max_luminance() << "\n";
+        }
+        if (m_tmap_cclv->avg_luminance_is_valid())
+        {
+          sstr << indent << "tmap_cclv.ccv_avg_luminance_value: " << m_tmap_cclv->get_avg_luminance() << "\n";
+        }
+      }
+      else {
+        sstr << indent << "tmap_cclv: ---\n";
+      }
+
+      if (m_tmap_amve)
+      {
+        sstr << indent << "tmap_amve.ambient_illumination: " << m_tmap_amve->amve.ambient_illumination << "\n";
+        sstr << indent << "tmap_amve.ambient_light_x: " << m_tmap_amve->amve.ambient_light_x << "\n";
+        sstr << indent << "tmap_amve.ambient_light_y: " << m_tmap_amve->amve.ambient_light_y << "\n";
+      }
+      else {
+        sstr << indent << "tmap_amve: ---\n";
+      }
+
+      sstr << indent << "tmap_reve_flag: " << m_tmap_reve_flag << "\n";
+      sstr << indent << "tmap_ndwt_flag: " << m_tmap_ndwt_flag << "\n";
+
+      if (m_tmap_reve_flag)
+      {
+        // TODO - this isn't published yet
+      }
+      if (m_tmap_ndwt_flag)
+      {
+        // TODO - this isn't published yet
+      }
+    }
+  }
+
+  if (m_alpha_flag && (m_alpha_item_data_size > 0) && (m_alpha_item_codec_config.size() > 0))
+  {
+    sstr << "alpha_item_code_config size: " << m_alpha_item_codec_config.size() << "\n";
+  }
+  if (m_hdr_flag && m_gainmap_flag && m_gainmap_item_codec_config.size() > 0)
+  {
+    sstr << "gainmap_item_codec_config size: " << m_gainmap_item_codec_config.size() << "\n";
+  }
+  if (m_main_item_codec_config.size() > 0)
+  {
+    sstr << "main_item_code_config size: " << m_main_item_codec_config.size() << "\n";
+  }
+
+  if (m_icc_flag)
+  {
+    sstr << "icc_data size: " << m_icc_data.size() << "\n";
+  }
+  if (m_hdr_flag && m_gainmap_flag && m_tmap_icc_flag)
+  {
+    sstr << "tmap_icc_data size: " << m_tmap_icc_data.size() << "\n";
+  }
+  if (m_hdr_flag && m_gainmap_flag && m_gainmap_metadata.size() > 0)
+  {
+    sstr << "gainmap_metadata size: " << m_gainmap_metadata.size() << "\n";
+  }
+
+  if (m_alpha_flag && (m_alpha_item_data_size > 0))
+  {
+    sstr << "alpha_item_data offset: " << m_alpha_item_data_offset << ", size: " << m_alpha_item_data_size << "\n";
+  }
+  if (m_hdr_flag && m_gainmap_flag && (m_gainmap_item_data_size > 0))
+  {
+    sstr << "gainmap_item_data offset: " << m_gainmap_item_data_offset << ", size: " << m_gainmap_item_data_size << "\n";
+  }
+
+  sstr << "main_item_data offset: " << m_main_item_data_offset << ", size: " << m_main_item_data_size << "\n";
+
+  if (m_exif_flag)
+  {
+    sstr << "exif_data offset: " << m_exif_item_data_offset << ", size: " << m_exif_item_data_size << "\n";
+  }
+  if (m_xmp_flag)
+  {
+    sstr << "xmp_data offset: " << m_xmp_item_data_offset << ", size: " << m_xmp_item_data_size << "\n";
+  }
+  return sstr.str();
+}
+
+
+static uint32_t get_item_type_for_brand(const heif_brand2 brand)
+{
+  switch(brand) {
+    case heif_brand2_avif:
+      return fourcc("av01");
+    case heif_brand2_heic:
+      return fourcc("hvc1");
+    default:
+      return 0;
+  }
+}
+
+
+Error Box_mini::create_expanded_boxes(class HeifFile* file)
+{
+  file->init_meta_box();
+
+  auto hdlr_box = std::make_shared<Box_hdlr>();
+  hdlr_box->set_handler_type(fourcc("pict"));
+  file->set_hdlr_box(hdlr_box);
+
+  file->set_primary_item_id(1);
+
+  std::shared_ptr<Box_infe> primary_infe_box = std::make_shared<Box_infe>();
+  primary_infe_box->set_version(2);
+  primary_infe_box->set_item_ID(1);
+
+  // TODO: check explicit codec flag
+  uint32_t minor_version = file->get_ftyp_box()->get_minor_version();
+  heif_brand2 mini_brand = minor_version;
+  uint32_t infe_type = get_item_type_for_brand(mini_brand);
+  if (infe_type == 0) {
+    // not found
+    std::stringstream sstr;
+    sstr << "Minimised file requires brand " << fourcc_to_string(mini_brand) << " but this is not yet supported.";
+    return Error(heif_error_Unsupported_filetype,
+                 heif_suberror_Unspecified,
+                 sstr.str());
+  }
+  primary_infe_box->set_item_type_4cc(infe_type);
+  file->add_infe_box(1, primary_infe_box);
+
+  if (get_alpha_item_data_size() != 0) {
+    std::shared_ptr<Box_infe> alpha_infe_box = std::make_shared<Box_infe>();
+    alpha_infe_box->set_version(2);
+    alpha_infe_box->set_flags(1);
+    alpha_infe_box->set_item_ID(2);
+    alpha_infe_box->set_item_type_4cc(infe_type);
+    file->add_infe_box(2, alpha_infe_box);
+  }
+
+  if (get_exif_flag()) {
+    std::shared_ptr<Box_infe> exif_infe_box = std::make_shared<Box_infe>();
+    exif_infe_box->set_version(2);
+    exif_infe_box->set_flags(1);
+    exif_infe_box->set_item_ID(6);
+    exif_infe_box->set_item_type_4cc(fourcc("Exif"));
+    file->add_infe_box(6, exif_infe_box);
+  }
+
+  if (get_xmp_flag()) {
+    std::shared_ptr<Box_infe> xmp_infe_box = std::make_shared<Box_infe>();
+    xmp_infe_box->set_version(2);
+    xmp_infe_box->set_flags(1);
+    xmp_infe_box->set_item_ID(7);
+    xmp_infe_box->set_item_type_4cc(fourcc("mime"));
+    xmp_infe_box->set_content_type("application/rdf+xml");
+    file->add_infe_box(7, xmp_infe_box);
+  }
+
+  auto ipco_box = std::make_shared<Box_ipco>();
+  file->set_ipco_box(ipco_box);
+
+  if (get_main_item_codec_config().size() != 0) {
+    std::shared_ptr<StreamReader> istr = std::make_shared<StreamReader_memory>(
+        get_main_item_codec_config().data(),
+        get_main_item_codec_config().size(),
+        false
+    );
+    BitstreamRange codec_range(istr, get_main_item_codec_config().size(), nullptr);
+
+    std::shared_ptr<Box> main_item_codec_prop;
+    if (infe_type == fourcc("av01")) {
+      std::shared_ptr<Box_av1C> codec_prop = std::make_shared<Box_av1C>();
+      codec_prop->parse(codec_range, heif_get_global_security_limits());
+      main_item_codec_prop = std::move(codec_prop);
+    } else if (infe_type == fourcc("hvc1")) {
+      std::shared_ptr<Box_hvcC> codec_prop = std::make_shared<Box_hvcC>();
+      codec_prop->parse(codec_range, heif_get_global_security_limits());
+      main_item_codec_prop = std::move(codec_prop);
+    } else {
+      // not found
+      std::stringstream sstr;
+      sstr << "Minimised file requires infe support for " << fourcc_to_string(infe_type) << " but this is not yet supported.";
+      return Error(heif_error_Unsupported_filetype,
+                   heif_suberror_Unspecified,
+                   sstr.str());
+    }
+    ipco_box->append_child_box(main_item_codec_prop); // entry 1
+  } else {
+    ipco_box->append_child_box(std::make_shared<Box_free>()); // placeholder for entry 1
+  }
+
+  std::shared_ptr<Box_ispe> ispe = std::make_shared<Box_ispe>();
+  ispe->set_size(get_width(), get_height());
+  ipco_box->append_child_box(ispe); // entry 2
+
+  std::shared_ptr<Box_pixi> pixi = std::make_shared<Box_pixi>();
+  pixi->set_version(0);
+  // pixi->set_version(1); // TODO: when we support version 1
+  // TODO: there is more when we do version 1, and anything other than RGB
+  pixi->add_channel_bits(get_bit_depth());
+  pixi->add_channel_bits(get_bit_depth());
+  pixi->add_channel_bits(get_bit_depth());
+  ipco_box->append_child_box(pixi); // entry 3
+
+  std::shared_ptr<Box_colr> colr = std::make_shared<Box_colr>();
+  nclx_profile colorProfile;
+  colorProfile.set_colour_primaries(get_colour_primaries());
+  colorProfile.set_transfer_characteristics(get_transfer_characteristics());
+  colorProfile.set_matrix_coefficients(get_matrix_coefficients());
+  colorProfile.set_full_range_flag(get_full_range_flag());
+  std::shared_ptr<color_profile_nclx> nclx = std::make_shared<color_profile_nclx>(colorProfile);
+  colr->set_color_profile(nclx);
+  ipco_box->append_child_box(colr); // entry 4
+
+  if (get_icc_flag()) {
+    std::shared_ptr<Box_colr> colr_icc = std::make_shared<Box_colr>();
+    std::shared_ptr<color_profile_raw> icc = std::make_shared<color_profile_raw>(fourcc("prof"), get_icc_data());
+    colr_icc->set_color_profile(icc);
+    ipco_box->append_child_box(colr_icc); // entry 5
+  } else {
+    ipco_box->append_child_box(std::make_shared<Box_free>()); // placeholder for entry 5
+  }
+
+  if (get_alpha_item_codec_config().size() != 0) {
+    std::shared_ptr<StreamReader> istr = std::make_shared<StreamReader_memory>(
+        get_alpha_item_codec_config().data(),
+        get_alpha_item_codec_config().size(),
+        false
+    );
+    BitstreamRange alpha_codec_range(istr, get_alpha_item_codec_config().size(), nullptr);
+    std::shared_ptr<Box> alpha_item_codec_prop;
+    if (infe_type == fourcc("av01")) {
+      std::shared_ptr<Box_av1C> codec_prop = std::make_shared<Box_av1C>();
+      codec_prop->parse(alpha_codec_range, heif_get_global_security_limits());
+      alpha_item_codec_prop = std::move(codec_prop);
+    } else if (infe_type == fourcc("hvc1")) {
+      std::shared_ptr<Box_hvcC> codec_prop = std::make_shared<Box_hvcC>();
+      codec_prop->parse(alpha_codec_range, heif_get_global_security_limits());
+      alpha_item_codec_prop = std::move(codec_prop);
+    } else {
+      // not found
+      std::stringstream sstr;
+      sstr << "Minimised file requires infe support for " << fourcc_to_string(infe_type) << " but this is not yet supported.";
+      return Error(heif_error_Unsupported_filetype,
+                   heif_suberror_Unspecified,
+                   sstr.str());
+    }
+    ipco_box->append_child_box(alpha_item_codec_prop); // entry 6
+  } else {
+    ipco_box->append_child_box(std::make_shared<Box_free>()); // placeholder for entry 6
+  }
+
+  if (get_alpha_item_data_size() != 0) {
+    std::shared_ptr<Box_auxC> aux_type = std::make_shared<Box_auxC>();
+    aux_type->set_aux_type("urn:mpeg:mpegB:cicp:systems:auxiliary:alpha");
+    ipco_box->append_child_box(aux_type); // entry 7
+  } else {
+    ipco_box->append_child_box(std::make_shared<Box_free>()); // placeholder for entry 7
+  }
+
+  // TODO: replace this placeholder with pixi box version 1 once that is supported
+  ipco_box->append_child_box(std::make_shared<Box_free>()); // placeholder for entry 8
+
+  if (get_orientation() == 2) {
+    std::shared_ptr<Box_irot> irot = std::make_shared<Box_irot>();
+    irot->set_rotation_ccw(2 * 90);
+    ipco_box->append_child_box(irot); // entry 9
+  } else if ((get_orientation() == 4) || (get_orientation() == 6) || (get_orientation() == 7)) {
+    std::shared_ptr<Box_irot> irot = std::make_shared<Box_irot>();
+    irot->set_rotation_ccw(1 * 90);
+    ipco_box->append_child_box(irot); // entry 9
+  } else if (get_orientation() == 5) {
+    std::shared_ptr<Box_irot> irot = std::make_shared<Box_irot>();
+    irot->set_rotation_ccw(3 * 90);
+    ipco_box->append_child_box(irot); // entry 9
+  } else {
+    ipco_box->append_child_box(std::make_shared<Box_free>()); // placeholder for entry 9
+  }
+
+  if ((get_orientation() == 1) || (get_orientation() == 6)) {
+    std::shared_ptr<Box_imir> imir = std::make_shared<Box_imir>();
+    imir->set_mirror_direction(heif_transform_mirror_direction_horizontal);
+    ipco_box->append_child_box(imir); // entry 10
+  } else if ((get_orientation() == 3) || (get_orientation() == 4)) {
+    std::shared_ptr<Box_imir> imir = std::make_shared<Box_imir>();
+    imir->set_mirror_direction(heif_transform_mirror_direction_vertical);
+    ipco_box->append_child_box(imir); // entry 10
+  } else {
+    ipco_box->append_child_box(std::make_shared<Box_free>()); // placeholder for entry 10
+  }
+
+  auto ipma_box = std::make_shared<Box_ipma>();
+  file->set_ipma_box(ipma_box);
+  ipma_box->add_property_for_item_ID(1, Box_ipma::PropertyAssociation{true, uint16_t(1)});
+  ipma_box->add_property_for_item_ID(1, Box_ipma::PropertyAssociation{false, uint16_t(2)});
+  ipma_box->add_property_for_item_ID(1, Box_ipma::PropertyAssociation{false, uint16_t(3)});
+  ipma_box->add_property_for_item_ID(1, Box_ipma::PropertyAssociation{true, uint16_t(4)});
+  ipma_box->add_property_for_item_ID(1, Box_ipma::PropertyAssociation{true, uint16_t(5)});
+  ipma_box->add_property_for_item_ID(1, Box_ipma::PropertyAssociation{true, uint16_t(9)});
+  ipma_box->add_property_for_item_ID(1, Box_ipma::PropertyAssociation{true, uint16_t(10)});
+
+  if (get_alpha_item_data_size() != 0) {
+    ipma_box->add_property_for_item_ID(2, Box_ipma::PropertyAssociation{true, uint16_t(6)});
+    ipma_box->add_property_for_item_ID(2, Box_ipma::PropertyAssociation{false, uint16_t(2)});
+    ipma_box->add_property_for_item_ID(2, Box_ipma::PropertyAssociation{true, uint16_t(7)});
+    ipma_box->add_property_for_item_ID(2, Box_ipma::PropertyAssociation{false, uint16_t(8)});
+    ipma_box->add_property_for_item_ID(2, Box_ipma::PropertyAssociation{true, uint16_t(9)});
+    ipma_box->add_property_for_item_ID(2, Box_ipma::PropertyAssociation{true, uint16_t(10)});
+  }
+  // TODO: will need more once we support HDR / gainmap representation
+
+  auto iloc_box = std::make_shared<Box_iloc>();
+  file->set_iloc_box(iloc_box);
+  Box_iloc::Item main_item;
+  main_item.item_ID = 1;
+  main_item.construction_method = 0;
+  main_item.base_offset = 0;
+  main_item.data_reference_index = 0;
+  Box_iloc::Extent main_item_extent;
+  main_item_extent.offset = get_main_item_data_offset();
+  main_item_extent.length = get_main_item_data_size();
+  main_item.extents.push_back(main_item_extent);
+  iloc_box->append_item(main_item);
+
+  if (get_alpha_item_data_size() != 0) {
+    Box_iloc::Item alpha_item;
+    alpha_item.item_ID = 2;
+    alpha_item.base_offset = 0;
+    alpha_item.data_reference_index = 0;
+    Box_iloc::Extent alpha_item_extent;
+    alpha_item_extent.offset = get_alpha_item_data_offset();
+    alpha_item_extent.length = get_alpha_item_data_size();
+    alpha_item.extents.push_back(alpha_item_extent);
+    iloc_box->append_item(alpha_item);
+  }
+  if (get_exif_flag()) {
+    Box_iloc::Item exif_item;
+    exif_item.item_ID = 6;
+    exif_item.base_offset = 0;
+    exif_item.data_reference_index = 0;
+    Box_iloc::Extent exif_item_extent;
+    exif_item_extent.offset = get_exif_item_data_offset();
+    exif_item_extent.length = get_exif_item_data_size();
+    exif_item.extents.push_back(exif_item_extent);
+    iloc_box->append_item(exif_item);
+  }
+  if (get_xmp_flag()) {
+    Box_iloc::Item xmp_item;
+    xmp_item.item_ID = 7;
+    xmp_item.base_offset = 0;
+    xmp_item.data_reference_index = 0;
+    Box_iloc::Extent xmp_item_extent;
+    xmp_item_extent.offset = get_xmp_item_data_offset();
+    xmp_item_extent.length = get_xmp_item_data_size();
+    xmp_item.extents.push_back(xmp_item_extent);
+    iloc_box->append_item(xmp_item);
+  }
+
+  auto iref_box = std::make_shared<Box_iref>();
+  file->set_iref_box(iref_box);
+  std::vector<uint32_t> to_items = {1};
+  if (get_alpha_item_data_size() != 0) {
+    iref_box->add_references(2, fourcc("auxl"), to_items);
+  }
+  // TODO: if alpha prem
+  // TODO: if gainmap flag && item 4
+  // TODO: if gainmap flag && !item 4
+  if (get_exif_flag()) {
+    iref_box->add_references(6, fourcc("cdsc"), to_items);
+  }
+  if (get_xmp_flag()) {
+    iref_box->add_references(7, fourcc("cdsc"), to_items);
+  }
+
+  return Error::Ok;
+}
diff --git a/libheif/mini.h b/libheif/mini.h
new file mode 100644
index 0000000000..2358246a23
--- /dev/null
+++ b/libheif/mini.h
@@ -0,0 +1,157 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Brad Hards <bradh@frogmouth.net>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_MINI_H
+#define LIBHEIF_MINI_H
+
+#include "libheif/heif.h"
+#include "box.h"
+
+#include <memory>
+#include <string>
+#include <vector>
+
+class Box_mini : public Box
+{
+public:
+  Box_mini()
+  {
+    set_short_type(fourcc("mini"));
+  }
+
+  Error create_expanded_boxes(class HeifFile* file);
+
+  bool get_icc_flag() const { return m_icc_flag; }
+  bool get_exif_flag() const { return m_exif_flag; }
+  bool get_xmp_flag() const { return m_xmp_flag; }
+
+  uint32_t get_width() const { return m_width; }
+  uint32_t get_height() const { return m_height; }
+
+  uint8_t get_bit_depth() const { return m_bit_depth; }
+
+  uint8_t get_orientation() const { return m_orientation; }
+
+  std::vector<uint8_t> get_main_item_codec_config() const { return m_main_item_codec_config; }
+  std::vector<uint8_t> get_alpha_item_codec_config() const { return m_alpha_item_codec_config; }
+  std::vector<uint8_t> get_icc_data() const { return m_icc_data; }
+
+  uint64_t get_main_item_data_offset() const { return m_main_item_data_offset; }
+  uint32_t get_main_item_data_size() const { return m_main_item_data_size; }
+  uint64_t get_alpha_item_data_offset() const { return m_alpha_item_data_offset; }
+  uint32_t get_alpha_item_data_size() const { return m_alpha_item_data_size; }
+  uint64_t get_exif_item_data_offset() const { return m_exif_item_data_offset; }
+  uint32_t get_exif_item_data_size() const { return m_exif_item_data_size; }
+  uint64_t get_xmp_item_data_offset() const { return m_xmp_item_data_offset; }
+  uint32_t get_xmp_item_data_size() const { return m_xmp_item_data_size; }
+
+  uint16_t get_colour_primaries() const { return m_colour_primaries; }
+  uint16_t get_transfer_characteristics() const { return m_transfer_characteristics; }
+  uint16_t get_matrix_coefficients() const { return m_matrix_coefficients; }
+  bool get_full_range_flag() const { return m_full_range_flag; }
+
+  std::string dump(Indent &) const override;
+
+protected:
+  Error parse(BitstreamRange &range, const heif_security_limits *limits) override;
+
+private:
+  uint8_t m_version = 0;
+  bool m_explicit_codec_types_flag = false;
+  bool m_float_flag = false;
+  bool m_full_range_flag = false;
+  bool m_alpha_flag = false;
+  bool m_explicit_cicp_flag = false;
+  bool m_hdr_flag = false;
+  bool m_icc_flag = false;
+  bool m_exif_flag = false;
+  bool m_xmp_flag = false;
+  uint8_t m_chroma_subsampling = 0;
+  uint8_t m_orientation = 0;
+
+  uint32_t m_width = 0;
+  uint32_t m_height = 0;
+  uint8_t m_bit_depth = 8;
+  bool m_chroma_is_horizontally_centred = false;
+  bool m_chroma_is_vertically_centred = false;
+  bool m_alpha_is_premultiplied = false;
+  uint16_t m_colour_primaries = 0;
+  uint16_t m_transfer_characteristics = 0;
+  uint16_t m_matrix_coefficients = 0;
+
+  uint32_t m_infe_type = 0;
+  uint32_t m_codec_config_type = 0;
+
+  bool m_gainmap_flag = false;
+
+  uint32_t m_gainmap_width = 0;
+  uint32_t m_gainmap_height = 0;
+  uint8_t m_gainmap_matrix_coefficients = 0;
+  bool m_gainmap_full_range_flag = false;
+  uint8_t m_gainmap_chroma_subsampling = 0;
+  bool m_gainmap_chroma_is_horizontally_centred = false;
+  bool m_gainmap_chroma_is_vertically_centred = false;
+  bool m_gainmap_float_flag = false;
+  uint8_t m_gainmap_bit_depth = 8;
+  bool m_tmap_icc_flag = false;
+  bool m_tmap_explicit_cicp_flag = false;
+  uint16_t m_tmap_colour_primaries = 0;
+  uint16_t m_tmap_transfer_characteristics = 0;
+  uint16_t m_tmap_matrix_coefficients = 0;
+  bool m_tmap_full_range_flag = false;
+
+  bool m_reve_flag = false;
+  bool m_ndwt_flag = false;
+  std::shared_ptr<Box_clli> m_clli;
+  std::shared_ptr<Box_mdcv> m_mdcv;
+  std::shared_ptr<Box_cclv> m_cclv;
+  std::shared_ptr<Box_amve> m_amve;
+  // std::shared_ptr<Box_reve> m_reve;
+  // std::shared_ptr<Box_ndwt> m_ndwt;
+
+  bool m_tmap_reve_flag = false;
+  bool m_tmap_ndwt_flag = false;
+  std::shared_ptr<Box_clli> m_tmap_clli;
+  std::shared_ptr<Box_mdcv> m_tmap_mdcv;
+  std::shared_ptr<Box_cclv> m_tmap_cclv;
+  std::shared_ptr<Box_amve> m_tmap_amve;
+  // std::shared_ptr<Box_reve> m_tmap_reve;
+  // std::shared_ptr<Box_ndwt> m_tmap_ndwt;
+
+  std::vector<uint8_t> m_alpha_item_codec_config;
+  std::vector<uint8_t> m_gainmap_item_codec_config;
+  std::vector<uint8_t> m_main_item_codec_config;
+  std::vector<uint8_t> m_icc_data;
+  std::vector<uint8_t> m_tmap_icc_data;
+  std::vector<uint8_t> m_gainmap_metadata;
+
+  uint64_t m_alpha_item_data_offset = 0;
+  uint32_t m_alpha_item_data_size = 0;
+  uint64_t m_main_item_data_offset = 0;
+  uint32_t m_main_item_data_size = 0;
+  uint64_t m_gainmap_item_data_offset = 0;
+  uint32_t m_gainmap_item_data_size = 0;
+  uint64_t m_exif_item_data_offset = 0;
+  uint32_t m_exif_item_data_size = 0;
+  uint64_t m_xmp_item_data_offset = 0;
+  uint32_t m_xmp_item_data_size = 0;
+};
+
+#endif
diff --git a/libheif/nclx.cc b/libheif/nclx.cc
index 0c35b6cd14..4e11f68c27 100644
--- a/libheif/nclx.cc
+++ b/libheif/nclx.cc
@@ -1,6 +1,6 @@
 /*
  * HEIF codec.
- * Copyright (c) 2020 struktur AG, Dirk Farin <farin@struktur.de>
+ * Copyright (c) 2020 Dirk Farin <dirk.farin@gmail.com>
  *
  * This file is part of libheif.
  *
@@ -20,9 +20,15 @@
 
 
 #include "nclx.h"
+#include "libheif/heif_experimental.h"
 
+#include <cassert>
+#include <memory>
+#include <string>
+#include <vector>
 
-heif::primaries::primaries(float gx, float gy, float bx, float by, float rx, float ry, float wx, float wy)
+
+primaries::primaries(float gx, float gy, float bx, float by, float rx, float ry, float wx, float wy)
 {
   defined = true;
   redX = rx;
@@ -36,7 +42,7 @@ heif::primaries::primaries(float gx, float gy, float bx, float by, float rx, flo
 }
 
 
-heif::primaries heif::get_colour_primaries(uint16_t primaries_idx)
+primaries get_colour_primaries(uint16_t primaries_idx)
 {
   switch (primaries_idx) {
     case 1:
@@ -65,8 +71,17 @@ heif::primaries heif::get_colour_primaries(uint16_t primaries_idx)
   }
 }
 
+Kr_Kb Kr_Kb::defaults()
+{
+  Kr_Kb kr_kb;
+  // Rec 601.
+  kr_kb.Kr = 0.2990f;
+  kr_kb.Kb = 0.1140f;
+  return kr_kb;
+}
 
-heif::Kr_Kb heif::get_Kr_Kb(uint16_t matrix_coefficients_idx, uint16_t primaries_idx)
+
+Kr_Kb get_Kr_Kb(uint16_t matrix_coefficients_idx, uint16_t primaries_idx)
 {
   Kr_Kb result;
 
@@ -82,6 +97,10 @@ heif::Kr_Kb heif::get_Kr_Kb(uint16_t matrix_coefficients_idx, uint16_t primaries
     float denom = p.whiteY * (p.redX * (p.greenY * zb - p.blueY * zg) + p.greenX * (p.blueY * zr - p.redY * zb) +
                               p.blueX * (p.redY * zg - p.greenY * zr));
 
+    if (denom == 0.0f) {
+      return result;
+    }
+
     result.Kr = (p.redY * (p.whiteX * (p.greenY * zb - p.blueY * zg) + p.whiteY * (p.blueX * zg - p.greenX * zb) +
                            zw * (p.greenX * p.blueY - p.blueX * p.greenY))) / denom;
     result.Kb = (p.blueY * (p.whiteX * (p.redY * zg - p.greenY * zr) + p.whiteY * (p.greenX * zr - p.redX * zg) +
@@ -118,7 +137,7 @@ heif::Kr_Kb heif::get_Kr_Kb(uint16_t matrix_coefficients_idx, uint16_t primaries
 }
 
 
-heif::YCbCr_to_RGB_coefficients heif::YCbCr_to_RGB_coefficients::defaults()
+YCbCr_to_RGB_coefficients YCbCr_to_RGB_coefficients::defaults()
 {
   YCbCr_to_RGB_coefficients coeffs;
   coeffs.defined = true;
@@ -129,8 +148,8 @@ heif::YCbCr_to_RGB_coefficients heif::YCbCr_to_RGB_coefficients::defaults()
   return coeffs;
 }
 
-heif::YCbCr_to_RGB_coefficients
-heif::get_YCbCr_to_RGB_coefficients(uint16_t matrix_coefficients_idx, uint16_t primaries_idx)
+YCbCr_to_RGB_coefficients
+get_YCbCr_to_RGB_coefficients(uint16_t matrix_coefficients_idx, uint16_t primaries_idx)
 {
   YCbCr_to_RGB_coefficients coeffs;
 
@@ -151,8 +170,8 @@ heif::get_YCbCr_to_RGB_coefficients(uint16_t matrix_coefficients_idx, uint16_t p
 }
 
 
-heif::RGB_to_YCbCr_coefficients
-heif::get_RGB_to_YCbCr_coefficients(uint16_t matrix_coefficients_idx, uint16_t primaries_idx)
+RGB_to_YCbCr_coefficients
+get_RGB_to_YCbCr_coefficients(uint16_t matrix_coefficients_idx, uint16_t primaries_idx)
 {
   RGB_to_YCbCr_coefficients coeffs;
 
@@ -178,11 +197,11 @@ heif::get_RGB_to_YCbCr_coefficients(uint16_t matrix_coefficients_idx, uint16_t p
 }
 
 
-heif::RGB_to_YCbCr_coefficients heif::RGB_to_YCbCr_coefficients::defaults()
+RGB_to_YCbCr_coefficients RGB_to_YCbCr_coefficients::defaults()
 {
   RGB_to_YCbCr_coefficients coeffs;
   coeffs.defined = true;
-
+  // Rec 601 full. Kr=0.2990f Kb=0.1140f.
   coeffs.c[0][0] = 0.299f;
   coeffs.c[0][1] = 0.587f;
   coeffs.c[0][2] = 0.114f;
@@ -196,3 +215,296 @@ heif::RGB_to_YCbCr_coefficients heif::RGB_to_YCbCr_coefficients::defaults()
   return coeffs;
 }
 
+
+Error color_profile_nclx::parse(BitstreamRange& range)
+{
+  StreamReader::grow_status status;
+  status = range.wait_for_available_bytes(7);
+  if (status != StreamReader::grow_status::size_reached) {
+    // TODO: return recoverable error at timeout
+    return Error(heif_error_Invalid_input,
+                 heif_suberror_End_of_data);
+  }
+
+  m_profile.m_colour_primaries = range.read16();
+  m_profile.m_transfer_characteristics = range.read16();
+  m_profile.m_matrix_coefficients = range.read16();
+  m_profile.m_full_range_flag = (range.read8() & 0x80 ? true : false);
+
+  return Error::Ok;
+}
+
+Error color_profile_nclx::parse_nclc(BitstreamRange& range)
+{
+  StreamReader::grow_status status;
+  status = range.wait_for_available_bytes(6);
+  if (status != StreamReader::grow_status::size_reached) {
+    // TODO: return recoverable error at timeout
+    return Error(heif_error_Invalid_input,
+                 heif_suberror_End_of_data);
+  }
+
+  m_profile.m_colour_primaries = range.read16();
+  m_profile.m_transfer_characteristics = range.read16();
+  m_profile.m_matrix_coefficients = range.read16();
+
+  // use full range for RGB, limited range otherwise
+  m_profile.m_full_range_flag = (m_profile.m_matrix_coefficients == 0);
+
+  return Error::Ok;
+}
+
+Error nclx_profile::get_nclx_color_profile(heif_color_profile_nclx** out_data) const
+{
+  *out_data = nullptr;
+
+  heif_color_profile_nclx* nclx = heif_nclx_color_profile_alloc();
+
+  if (nclx == nullptr) {
+    return Error(heif_error_Memory_allocation_error,
+                 heif_suberror_Unspecified);
+  }
+
+  heif_error err;
+
+  nclx->version = 1;
+
+  err = heif_nclx_color_profile_set_color_primaries(nclx, get_colour_primaries());
+  if (err.code) {
+    heif_nclx_color_profile_free(nclx);
+    return {err.code, err.subcode};
+  }
+
+  err = heif_nclx_color_profile_set_transfer_characteristics(nclx, get_transfer_characteristics());
+  if (err.code) {
+    heif_nclx_color_profile_free(nclx);
+    return {err.code, err.subcode};
+  }
+
+  err = heif_nclx_color_profile_set_matrix_coefficients(nclx, get_matrix_coefficients());
+  if (err.code) {
+    heif_nclx_color_profile_free(nclx);
+    return {err.code, err.subcode};
+  }
+
+  nclx->full_range_flag = get_full_range_flag();
+
+  // fill color primaries
+
+  auto primaries = ::get_colour_primaries(nclx->color_primaries);
+
+  nclx->color_primary_red_x = primaries.redX;
+  nclx->color_primary_red_y = primaries.redY;
+  nclx->color_primary_green_x = primaries.greenX;
+  nclx->color_primary_green_y = primaries.greenY;
+  nclx->color_primary_blue_x = primaries.blueX;
+  nclx->color_primary_blue_y = primaries.blueY;
+  nclx->color_primary_white_x = primaries.whiteX;
+  nclx->color_primary_white_y = primaries.whiteY;
+
+  *out_data = nclx;
+
+  return Error::Ok;
+}
+
+
+void nclx_profile::set_sRGB_defaults()
+{
+  // sRGB defaults
+  m_colour_primaries = 1;
+  m_transfer_characteristics = 13;
+  m_matrix_coefficients = 6;
+  m_full_range_flag = true;
+}
+
+
+void nclx_profile::set_undefined()
+{
+  m_colour_primaries = 2;
+  m_transfer_characteristics = 2;
+  m_matrix_coefficients = 2;
+  m_full_range_flag = true;
+}
+
+
+bool nclx_profile::is_undefined() const
+{
+  return *this == nclx_profile::undefined();
+}
+
+
+void nclx_profile::set_from_heif_color_profile_nclx(const heif_color_profile_nclx* nclx)
+{
+  if (nclx) {
+    m_colour_primaries = nclx->color_primaries;
+    m_transfer_characteristics = nclx->transfer_characteristics;
+    m_matrix_coefficients = nclx->matrix_coefficients;
+    m_full_range_flag = nclx->full_range_flag;
+  }
+}
+
+
+void nclx_profile::copy_to_heif_color_profile_nclx(heif_color_profile_nclx* nclx)
+{
+  assert(nclx);
+  nclx->color_primaries = (enum heif_color_primaries)m_colour_primaries;
+  nclx->transfer_characteristics = (enum heif_transfer_characteristics)m_transfer_characteristics;
+  nclx->matrix_coefficients = (enum heif_matrix_coefficients)m_matrix_coefficients;
+  nclx->full_range_flag = m_full_range_flag;
+}
+
+
+void nclx_profile::replace_undefined_values_with_sRGB_defaults()
+{
+  if (m_matrix_coefficients == heif_matrix_coefficients_unspecified) {
+    m_matrix_coefficients = heif_matrix_coefficients_ITU_R_BT_601_6;
+  }
+
+  if (m_colour_primaries == heif_color_primaries_unspecified) {
+    m_colour_primaries = heif_color_primaries_ITU_R_BT_709_5;
+  }
+
+  if (m_transfer_characteristics == heif_transfer_characteristic_unspecified) {
+    m_transfer_characteristics = heif_transfer_characteristic_IEC_61966_2_1;
+  }
+}
+
+
+bool nclx_profile::equal_except_transfer_curve(const nclx_profile& b) const
+{
+  return (m_matrix_coefficients == b.m_matrix_coefficients &&
+          m_colour_primaries == b.m_colour_primaries &&
+          m_full_range_flag == b.m_full_range_flag);
+}
+
+
+Error Box_colr::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  StreamReader::grow_status status;
+  uint32_t colour_type = range.read32();
+
+  if (colour_type == fourcc("nclx")) {
+    auto color_profile = std::make_shared<color_profile_nclx>();
+    m_color_profile = color_profile;
+    Error err = color_profile->parse(range);
+    if (err) {
+      return err;
+    }
+  }
+  else if (colour_type == fourcc("nclc")) {
+    auto color_profile = std::make_shared<color_profile_nclx>();
+    m_color_profile = color_profile;
+    Error err = color_profile->parse_nclc(range);
+    if (err) {
+      return err;
+    }
+  }
+  else if (colour_type == fourcc("prof") ||
+           colour_type == fourcc("rICC")) {
+    if (!has_fixed_box_size()) {
+      return Error(heif_error_Unsupported_feature, heif_suberror_Unspecified, "colr boxes with undefined box size are not supported");
+    }
+
+    uint64_t profile_size_64 = get_box_size() - get_header_size() - 4;
+    if (limits->max_color_profile_size && profile_size_64 > limits->max_color_profile_size) {
+      return Error(heif_error_Invalid_input, heif_suberror_Security_limit_exceeded, "Color profile exceeds maximum supported size");
+    }
+
+    size_t profile_size = static_cast<size_t>(profile_size_64);
+
+    status = range.wait_for_available_bytes(profile_size);
+    if (status != StreamReader::grow_status::size_reached) {
+      // TODO: return recoverable error at timeout
+      return Error(heif_error_Invalid_input,
+                   heif_suberror_End_of_data);
+    }
+
+    std::vector<uint8_t> rawData(profile_size);
+    for (size_t i = 0; i < profile_size; i++) {
+      rawData[i] = range.read8();
+    }
+
+    m_color_profile = std::make_shared<color_profile_raw>(colour_type, rawData);
+  }
+  else {
+    return Error(heif_error_Invalid_input,
+                 heif_suberror_Unknown_color_profile_type);
+  }
+
+  return range.get_error();
+}
+
+
+std::string Box_colr::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
+
+  if (m_color_profile) {
+    sstr << indent << "colour_type: " << fourcc_to_string(get_color_profile_type()) << "\n";
+    sstr << m_color_profile->dump(indent);
+  }
+  else {
+    sstr << indent << "colour_type: ---\n";
+    sstr << "no color profile\n";
+  }
+
+  return sstr.str();
+}
+
+
+std::string color_profile_raw::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << indent << "profile size: " << m_data.size() << "\n";
+  return sstr.str();
+}
+
+
+std::string color_profile_nclx::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << indent << "colour_primaries: " << m_profile.m_colour_primaries << "\n"
+       << indent << "transfer_characteristics: " << m_profile.m_transfer_characteristics << "\n"
+       << indent << "matrix_coefficients: " << m_profile.m_matrix_coefficients << "\n"
+       << indent << "full_range_flag: " << m_profile.m_full_range_flag << "\n";
+  return sstr.str();
+}
+
+
+Error color_profile_nclx::write(StreamWriter& writer) const
+{
+  writer.write16(m_profile.m_colour_primaries);
+  writer.write16(m_profile.m_transfer_characteristics);
+  writer.write16(m_profile.m_matrix_coefficients);
+  writer.write8(m_profile.m_full_range_flag ? 0x80 : 0x00);
+
+  return Error::Ok;
+}
+
+Error color_profile_raw::write(StreamWriter& writer) const
+{
+  writer.write(m_data);
+
+  return Error::Ok;
+}
+
+Error Box_colr::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  assert(m_color_profile);
+
+  writer.write32(m_color_profile->get_type());
+
+  Error err = m_color_profile->write(writer);
+  if (err) {
+    return err;
+  }
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+
diff --git a/libheif/nclx.h b/libheif/nclx.h
index edcaa1d338..715fa5f8c3 100644
--- a/libheif/nclx.h
+++ b/libheif/nclx.h
@@ -1,6 +1,6 @@
 /*
  * HEIF codec.
- * Copyright (c) 2020 struktur AG, Dirk Farin <farin@struktur.de>
+ * Copyright (c) 2020 Dirk Farin <dirk.farin@gmail.com>
  *
  * This file is part of libheif.
  *
@@ -21,63 +21,206 @@
 #ifndef LIBHEIF_NCLX_H
 #define LIBHEIF_NCLX_H
 
+#include "box.h"
+
 #include <cinttypes>
+#include <memory>
+#include <string>
+#include <vector>
 
-namespace heif {
+struct primaries
+{
+  primaries() = default;
 
-  struct primaries
-  {
-    primaries() = default;
+  primaries(float gx, float gy, float bx, float by, float rx, float ry, float wx, float wy);
 
-    primaries(float gx, float gy, float bx, float by, float rx, float ry, float wx, float wy);
+  bool defined = false;
 
-    bool defined = false;
+  float greenX = 0, greenY = 0;
+  float blueX = 0, blueY = 0;
+  float redX = 0, redY = 0;
+  float whiteX = 0, whiteY = 0;
+};
 
-    float greenX=0, greenY=0;
-    float blueX=0, blueY=0;
-    float redX=0, redY=0;
-    float whiteX=0, whiteY=0;
-  };
+primaries get_colour_primaries(uint16_t primaries_idx);
 
-  primaries get_colour_primaries(uint16_t primaries_idx);
 
+struct Kr_Kb
+{
+  float Kr = 0, Kb = 0;
 
-  struct Kr_Kb
-  {
-    float Kr = 0, Kb = 0;
-  };
+  static Kr_Kb defaults();
+};
 
-  Kr_Kb get_Kr_Kb(uint16_t matrix_coefficients_idx, uint16_t primaries_idx);
+Kr_Kb get_Kr_Kb(uint16_t matrix_coefficients_idx, uint16_t primaries_idx);
 
-  struct YCbCr_to_RGB_coefficients
-  {
-    bool defined = false;
+struct YCbCr_to_RGB_coefficients
+{
+  bool defined = false;
 
-    float r_cr = 0;
-    float g_cb = 0;
-    float g_cr = 0;
-    float b_cb = 0;
+  float r_cr = 0;
+  float g_cb = 0;
+  float g_cr = 0;
+  float b_cb = 0;
 
-    static YCbCr_to_RGB_coefficients defaults();
-  };
+  static YCbCr_to_RGB_coefficients defaults();
+};
 
-  YCbCr_to_RGB_coefficients get_YCbCr_to_RGB_coefficients(uint16_t matrix_coefficients_idx, uint16_t primaries_idx);
+YCbCr_to_RGB_coefficients get_YCbCr_to_RGB_coefficients(uint16_t matrix_coefficients_idx, uint16_t primaries_idx);
 
-  struct RGB_to_YCbCr_coefficients
-  {
-    bool defined = false;
+struct RGB_to_YCbCr_coefficients
+{
+  bool defined = false;
 
-    float c[3][3] = {{0,0,0},{0,0,0},{0,0,0}};   // e.g. y = c[0][0]*r + c[0][1]*g + c[0][2]*b
+  float c[3][3] = {{0, 0, 0},
+                   {0, 0, 0},
+                   {0, 0, 0}};   // e.g. y = c[0][0]*r + c[0][1]*g + c[0][2]*b
 
-    static RGB_to_YCbCr_coefficients defaults();
-  };
+  static RGB_to_YCbCr_coefficients defaults();
+};
 
-  RGB_to_YCbCr_coefficients get_RGB_to_YCbCr_coefficients(uint16_t matrix_coefficients_idx, uint16_t primaries_idx);
+RGB_to_YCbCr_coefficients get_RGB_to_YCbCr_coefficients(uint16_t matrix_coefficients_idx, uint16_t primaries_idx);
 
 //  uint16_t get_transfer_characteristics() const {return m_transfer_characteristics;}
 // uint16_t get_matrix_coefficients() const {return m_matrix_coefficients;}
 //  bool get_full_range_flag() const {return m_full_range_flag;}
-}
+
+
+class color_profile
+{
+public:
+  virtual ~color_profile() = default;
+
+  virtual uint32_t get_type() const = 0;
+
+  virtual std::string dump(Indent&) const = 0;
+
+  virtual Error write(StreamWriter& writer) const = 0;
+};
+
+class color_profile_raw : public color_profile
+{
+public:
+  color_profile_raw(uint32_t type, const std::vector<uint8_t>& data)
+      : m_type(type), m_data(data) {}
+
+  uint32_t get_type() const override { return m_type; }
+
+  const std::vector<uint8_t>& get_data() const { return m_data; }
+
+  std::string dump(Indent&) const override;
+
+  Error write(StreamWriter& writer) const override;
+
+private:
+  uint32_t m_type;
+  std::vector<uint8_t> m_data;
+};
+
+
+struct nclx_profile
+{
+  uint16_t m_colour_primaries = heif_color_primaries_unspecified;
+  uint16_t m_transfer_characteristics = heif_transfer_characteristic_unspecified;
+  uint16_t m_matrix_coefficients = heif_matrix_coefficients_unspecified;
+  bool m_full_range_flag = true;
+
+  bool operator==(const nclx_profile& b) const = default;
+
+  bool operator!=(const nclx_profile& b) const = default;
+
+  static nclx_profile undefined() { return {}; }
+
+  static nclx_profile defaults() { nclx_profile profile; profile.set_sRGB_defaults(); return profile; }
+
+  heif_color_primaries get_colour_primaries() const { return static_cast<heif_color_primaries>(m_colour_primaries); }
+
+  heif_transfer_characteristics get_transfer_characteristics() const { return static_cast<heif_transfer_characteristics>(m_transfer_characteristics); }
+
+  heif_matrix_coefficients get_matrix_coefficients() const { return static_cast<heif_matrix_coefficients>(m_matrix_coefficients); }
+
+  bool get_full_range_flag() const { return m_full_range_flag; }
+
+  void set_colour_primaries(uint16_t primaries) { m_colour_primaries = primaries; }
+
+  void set_transfer_characteristics(uint16_t characteristics) { m_transfer_characteristics = characteristics; }
+
+  void set_matrix_coefficients(uint16_t coefficients) { m_matrix_coefficients = coefficients; }
+
+  void set_full_range_flag(bool full_range) { m_full_range_flag = full_range; }
+
+  void set_sRGB_defaults();
+
+  void set_undefined();
+
+  bool is_undefined() const;
+
+  void replace_undefined_values_with_sRGB_defaults();
+
+  bool equal_except_transfer_curve(const nclx_profile& b) const;
+
+  Error get_nclx_color_profile(heif_color_profile_nclx** out_data) const;
+
+  void set_from_heif_color_profile_nclx(const heif_color_profile_nclx* nclx);
+
+  void copy_to_heif_color_profile_nclx(heif_color_profile_nclx* nclx);
+};
+
+
+class color_profile_nclx : public color_profile
+{
+public:
+  color_profile_nclx() { m_profile.set_sRGB_defaults(); }
+
+  color_profile_nclx(const nclx_profile& profile) : m_profile(profile) { }
+
+  void set_from_heif_color_profile_nclx(const heif_color_profile_nclx* nclx)
+  {
+    m_profile.set_from_heif_color_profile_nclx(nclx);
+  }
+
+  uint32_t get_type() const override { return fourcc("nclx"); }
+
+  std::string dump(Indent&) const override;
+
+  Error parse(BitstreamRange& range);
+
+  Error parse_nclc(BitstreamRange& range);
+
+  Error write(StreamWriter& writer) const override;
+
+  nclx_profile get_nclx_color_profile() const { return m_profile; }
+
+private:
+  nclx_profile m_profile;
+};
+
+
+class Box_colr : public Box
+{
+public:
+  Box_colr()
+  {
+    set_short_type(fourcc("colr"));
+  }
+
+  std::string dump(Indent&) const override;
+
+  uint32_t get_color_profile_type() const { return m_color_profile->get_type(); }
+
+  const std::shared_ptr<const color_profile>& get_color_profile() const { return m_color_profile; }
+
+  void set_color_profile(const std::shared_ptr<const color_profile>& prof) { m_color_profile = prof; }
+
+
+  Error write(StreamWriter& writer) const override;
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits* limits) override;
+
+private:
+  std::shared_ptr<const color_profile> m_color_profile;
+};
 
 
 #endif //LIBHEIF_NCLX_H
diff --git a/libheif/omaf_boxes.cc b/libheif/omaf_boxes.cc
new file mode 100644
index 0000000000..4b45630f59
--- /dev/null
+++ b/libheif/omaf_boxes.cc
@@ -0,0 +1,104 @@
+/*
+ * libheif OMAF (ISO/IEC 23090-2)
+ *
+ * Copyright (c) 2026 Brad Hards <bradh@frogmouth.net>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "omaf_boxes.h"
+
+#include <memory>
+#include <string>
+
+
+Error Box_prfr::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  parse_full_box_header(range);
+
+  if (get_version() > 0) {
+    return unsupported_version_error("prfr");
+  }
+
+  uint8_t projection_type = (range.read8() & 0x1F);
+  switch (projection_type)
+  {
+  case 0x00:
+    m_projection = heif_omaf_image_projection::heif_omaf_image_projection_equirectangular;
+    break;
+  case 0x01:
+    m_projection = heif_omaf_image_projection::heif_omaf_image_projection_cube_map;
+    break;
+  default:
+    m_projection = heif_omaf_image_projection::heif_omaf_image_projection_unknown;
+    break;
+  }
+  return range.get_error();
+}
+
+std::string Box_prfr::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
+  sstr << indent << "projection_type: ";
+  switch (m_projection) {
+    case heif_omaf_image_projection_equirectangular:
+      sstr << "equirectangular\n";
+      break;
+    case heif_omaf_image_projection_cube_map:
+      sstr << "cube-map\n";
+      break;
+    default:
+      sstr << "unknown (" << m_projection << ")\n";
+      break;
+  }
+  return sstr.str();
+}
+
+Error Box_prfr::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+  switch (m_projection) {
+    case heif_omaf_image_projection::heif_omaf_image_projection_equirectangular:
+      writer.write8(0x00);
+      break;
+    case heif_omaf_image_projection::heif_omaf_image_projection_cube_map:
+      writer.write8(0x01);
+      break;
+    default:
+      return {
+        heif_error_Invalid_input,
+        heif_suberror_Unspecified,
+        "Unsupported image projection value."
+    };
+  }
+  prepend_header(writer, box_start);
+  return Error::Ok;
+}
+
+Error Box_prfr::set_image_projection(heif_omaf_image_projection projection)
+{
+  if ((projection == heif_omaf_image_projection::heif_omaf_image_projection_equirectangular) || (projection == heif_omaf_image_projection::heif_omaf_image_projection_cube_map)) {
+    m_projection = projection;
+    return Error::Ok;
+  } else {
+    return {
+      heif_error_Invalid_input,
+      heif_suberror_Unspecified,
+      "Unsupported image projection value."
+    };
+  }
+}
diff --git a/libheif/omaf_boxes.h b/libheif/omaf_boxes.h
new file mode 100644
index 0000000000..11dfafacf5
--- /dev/null
+++ b/libheif/omaf_boxes.h
@@ -0,0 +1,60 @@
+/*
+ * libheif OMAF (ISO/IEC 23090-2)
+ *
+ * Copyright (c) 2026 Brad Hards <bradh@frogmouth.net>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_OMAF_BOXES_H
+#define LIBHEIF_OMAF_BOXES_H
+
+#include "libheif/heif.h"
+#include "box.h"
+
+#include <memory>
+#include <string>
+
+// Projection format for OMAF
+// See ISO/IEC 23090-2:2023 Section 7.9.3
+class Box_prfr : public FullBox
+{
+public:
+  Box_prfr()
+  {
+    set_short_type(fourcc("prfr"));
+  }
+
+  heif_omaf_image_projection get_omaf_image_projection() const { return m_projection; }
+
+  Error set_image_projection(heif_omaf_image_projection projection);
+
+  std::string dump(Indent&) const override;
+
+  const char* debug_box_name() const override { return "Projection Format"; }
+
+  [[nodiscard]] parse_error_fatality get_parse_error_fatality() const override { return parse_error_fatality::optional; }
+
+  Error write(StreamWriter& writer) const override;
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+
+private:
+  heif_omaf_image_projection m_projection = heif_omaf_image_projection_equirectangular;
+};
+
+#endif
\ No newline at end of file
diff --git a/libheif/pixelimage.cc b/libheif/pixelimage.cc
new file mode 100644
index 0000000000..2ce28579be
--- /dev/null
+++ b/libheif/pixelimage.cc
@@ -0,0 +1,2344 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+
+#include "pixelimage.h"
+#include "common_utils.h"
+#include "security_limits.h"
+
+#include <cassert>
+#include <cstring>
+#include <utility>
+#include <limits>
+#include <algorithm>
+#include <color-conversion/colorconversion.h>
+
+#include "codecs/uncompressed/unc_types.h"
+
+#if WITH_UNCOMPRESSED_CODEC
+#include "codecs/uncompressed/unc_boxes.h"
+#endif
+
+
+heif_chroma chroma_from_subsampling(int h, int v)
+{
+  if (h == 2 && v == 2) {
+    return heif_chroma_420;
+  }
+  else if (h == 2 && v == 1) {
+    return heif_chroma_422;
+  }
+  else if (h == 1 && v == 1) {
+    return heif_chroma_444;
+  }
+  else {
+    assert(false);
+    return heif_chroma_undefined;
+  }
+}
+
+
+uint32_t chroma_width(uint32_t w, heif_chroma chroma)
+{
+  switch (chroma) {
+    case heif_chroma_420:
+    case heif_chroma_422:
+      return (w+1)/2;
+    default:
+      return w;
+  }
+}
+
+uint32_t chroma_height(uint32_t h, heif_chroma chroma)
+{
+  switch (chroma) {
+    case heif_chroma_420:
+      return (h+1)/2;
+    default:
+      return h;
+  }
+}
+
+uint32_t channel_width(uint32_t w, heif_chroma chroma, heif_channel channel)
+{
+  if (channel == heif_channel_Cb || channel == heif_channel_Cr) {
+    return chroma_width(w, chroma);
+  }
+  else {
+    return w;
+  }
+}
+
+uint32_t channel_height(uint32_t h, heif_chroma chroma, heif_channel channel)
+{
+  if (channel == heif_channel_Cb || channel == heif_channel_Cr) {
+    return chroma_height(h, chroma);
+  }
+  else {
+    return h;
+  }
+}
+
+
+heif_channel map_uncompressed_component_to_channel(uint16_t component_type)
+{
+  switch (component_type) {
+    case heif_uncompressed_component_type_monochrome:
+    case heif_uncompressed_component_type_Y:
+      return heif_channel_Y;
+    case heif_uncompressed_component_type_Cb:
+      return heif_channel_Cb;
+    case heif_uncompressed_component_type_Cr:
+      return heif_channel_Cr;
+    case heif_uncompressed_component_type_red:
+      return heif_channel_R;
+    case heif_uncompressed_component_type_green:
+      return heif_channel_G;
+    case heif_uncompressed_component_type_blue:
+      return heif_channel_B;
+    case heif_uncompressed_component_type_alpha:
+      return heif_channel_Alpha;
+    case heif_uncompressed_component_type_filter_array:
+      return heif_channel_filter_array;
+    case heif_uncompressed_component_type_depth:
+      return heif_channel_depth;
+    case heif_uncompressed_component_type_disparity:
+      return heif_channel_disparity;
+
+    case heif_uncompressed_component_type_padded:
+    default:
+      return heif_channel_unknown;
+  }
+}
+
+
+static std::vector<uint16_t> map_channel_to_component_type(heif_channel channel, heif_chroma chroma)
+{
+  switch (channel) {
+    case heif_channel_Y:
+      return {heif_uncompressed_component_type_Y};
+    case heif_channel_Cb:
+      return {heif_uncompressed_component_type_Cb};
+    case heif_channel_Cr:
+      return {heif_uncompressed_component_type_Cr};
+    case heif_channel_R:
+      return {heif_uncompressed_component_type_red};
+    case heif_channel_G:
+      return {heif_uncompressed_component_type_green};
+    case heif_channel_B:
+      return {heif_uncompressed_component_type_blue};
+    case heif_channel_Alpha:
+      return {heif_uncompressed_component_type_alpha};
+    case heif_channel_filter_array:
+      return {heif_uncompressed_component_type_filter_array};
+    case heif_channel_depth:
+      return {heif_uncompressed_component_type_depth};
+    case heif_channel_disparity:
+      return {heif_uncompressed_component_type_disparity};
+    case heif_channel_interleaved:
+      switch (chroma) {
+        case heif_chroma_interleaved_RGB:
+        case heif_chroma_interleaved_RRGGBB_BE:
+        case heif_chroma_interleaved_RRGGBB_LE:
+          return {
+            heif_uncompressed_component_type_red,
+            heif_uncompressed_component_type_green,
+            heif_uncompressed_component_type_blue
+          };
+        case heif_chroma_interleaved_RGBA:
+        case heif_chroma_interleaved_RRGGBBAA_BE:
+        case heif_chroma_interleaved_RRGGBBAA_LE:
+          return {
+            heif_uncompressed_component_type_red,
+            heif_uncompressed_component_type_green,
+            heif_uncompressed_component_type_blue,
+            heif_uncompressed_component_type_alpha
+          };
+        default:
+          assert(false);
+          return {static_cast<uint16_t>(1000 + channel)};
+          break;
+      }
+    default:
+      // For other channels without a direct match,
+      // use an internal custom value.
+      return {static_cast<uint16_t>(1000 + channel)};
+  }
+}
+
+
+
+ImageExtraData::~ImageExtraData()
+{
+  heif_tai_timestamp_packet_release(m_tai_timestamp);
+}
+
+
+bool ImageExtraData::has_nclx_color_profile() const
+{
+  return m_color_profile_nclx != nclx_profile::undefined();
+}
+
+
+nclx_profile ImageExtraData::get_color_profile_nclx_with_fallback() const
+{
+  if (has_nclx_color_profile()) {
+    return get_color_profile_nclx();
+  }
+  else {
+    return nclx_profile::defaults();
+  }
+}
+
+
+std::shared_ptr<Box_clli> ImageExtraData::get_clli_box() const
+{
+  if (!has_clli()) {
+    return {};
+  }
+
+  auto clli = std::make_shared<Box_clli>();
+  clli->clli = get_clli();
+
+  return clli;
+}
+
+
+std::shared_ptr<Box_mdcv> ImageExtraData::get_mdcv_box() const
+{
+  if (!has_mdcv()) {
+    return {};
+  }
+
+  auto mdcv = std::make_shared<Box_mdcv>();
+  mdcv->mdcv = get_mdcv();
+
+  return mdcv;
+}
+
+
+std::shared_ptr<Box_pasp> ImageExtraData::get_pasp_box() const
+{
+  if (!has_nonsquare_pixel_ratio()) {
+    return {};
+  }
+
+  auto pasp = std::make_shared<Box_pasp>();
+  pasp->hSpacing = m_PixelAspectRatio_h;
+  pasp->vSpacing = m_PixelAspectRatio_v;
+
+  return pasp;
+}
+
+
+std::shared_ptr<Box_colr> ImageExtraData::get_colr_box_nclx() const
+{
+  if (!has_nclx_color_profile()) {
+    return {};
+  }
+
+  auto colr = std::make_shared<Box_colr>();
+  colr->set_color_profile(std::make_shared<color_profile_nclx>(get_color_profile_nclx()));
+  return colr;
+}
+
+
+std::shared_ptr<Box_colr> ImageExtraData::get_colr_box_icc() const
+{
+  if (!has_icc_color_profile()) {
+    return {};
+  }
+
+  auto colr = std::make_shared<Box_colr>();
+  colr->set_color_profile(get_color_profile_icc());
+  return colr;
+}
+
+#if HEIF_WITH_OMAF
+std::shared_ptr<Box_prfr> ImageExtraData::get_prfr_box() const
+{
+  if (!has_omaf_image_projection()) {
+    return {};
+  }
+
+  auto prfr = std::make_shared<Box_prfr>();
+  if (prfr->set_image_projection(get_omaf_image_projection())) {
+    return {};
+  }
+
+  return prfr;
+}
+#endif
+
+std::vector<std::shared_ptr<Box>> ImageExtraData::generate_property_boxes(bool generate_colr_boxes) const
+{
+  std::vector<std::shared_ptr<Box>> properties;
+
+  // --- write PASP property
+
+  if (has_nonsquare_pixel_ratio()) {
+    auto pasp = std::make_shared<Box_pasp>();
+    get_pixel_ratio(&pasp->hSpacing, &pasp->vSpacing);
+
+    properties.push_back(pasp);
+  }
+
+
+  // --- write CLLI property
+
+  if (has_clli()) {
+    properties.push_back(get_clli_box());
+  }
+
+
+  // --- write MDCV property
+
+  if (has_mdcv()) {
+    auto mdcv = std::make_shared<Box_mdcv>();
+    mdcv->mdcv = get_mdcv();
+
+    properties.push_back(mdcv);
+  }
+
+
+  // --- write TAI property
+
+  if (auto* tai = get_tai_timestamp()) {
+    auto itai = std::make_shared<Box_itai>();
+    itai->set_from_tai_timestamp_packet(tai);
+
+    properties.push_back(itai);
+  }
+
+  // --- write GIMI content ID property
+
+  if (has_gimi_sample_content_id()) {
+    auto gimi = std::make_shared<Box_gimi_content_id>();
+    gimi->set_content_id(get_gimi_sample_content_id());
+    properties.push_back(gimi);
+  }
+
+  if (generate_colr_boxes) {
+    // --- colr (nclx)
+
+    if (has_nclx_color_profile()) {
+      properties.push_back(get_colr_box_nclx());
+    }
+
+    // --- colr (icc)
+
+    if (has_icc_color_profile()) {
+      properties.push_back(get_colr_box_icc());
+    }
+  }
+
+#if HEIF_WITH_OMAF
+  if (has_omaf_image_projection()) {
+    auto prfr = std::make_shared<Box_prfr>();
+    prfr->set_image_projection(get_omaf_image_projection());
+    properties.push_back(prfr);
+  }
+#endif
+
+#if WITH_UNCOMPRESSED_CODEC
+  if (has_component_content_ids()) {
+    auto ccid = std::make_shared<Box_gimi_component_content_ids>();
+    ccid->set_content_ids(get_component_content_ids());
+    properties.push_back(ccid);
+  }
+#endif
+
+  return properties;
+}
+
+
+
+HeifPixelImage::~HeifPixelImage()
+{
+  for (auto& component : m_planes) {
+    delete[] component.allocated_mem;
+  }
+}
+
+
+HeifPixelImage::ImageComponent* HeifPixelImage::find_component_for_channel(heif_channel channel)
+{
+  for (auto& component : m_planes) {
+    if (component.m_channel == channel) {
+      return &component;
+    }
+  }
+  return nullptr;
+}
+
+const HeifPixelImage::ImageComponent* HeifPixelImage::find_component_for_channel(heif_channel channel) const
+{
+  for (const auto& component : m_planes) {
+    if (component.m_channel == channel) {
+      return &component;
+    }
+  }
+  return nullptr;
+}
+
+
+int num_interleaved_components_per_plane(heif_chroma chroma)
+{
+  switch (chroma) {
+    case heif_chroma_undefined:
+    case heif_chroma_monochrome:
+    case heif_chroma_420:
+    case heif_chroma_422:
+    case heif_chroma_444:
+      return 1;
+
+    case heif_chroma_interleaved_RGB:
+    case heif_chroma_interleaved_RRGGBB_BE:
+    case heif_chroma_interleaved_RRGGBB_LE:
+      return 3;
+
+    case heif_chroma_interleaved_RGBA:
+    case heif_chroma_interleaved_RRGGBBAA_BE:
+    case heif_chroma_interleaved_RRGGBBAA_LE:
+      return 4;
+  }
+
+  assert(false);
+  return 0;
+}
+
+
+bool is_integer_multiple_of_chroma_size(uint32_t width,
+                                        uint32_t height,
+                                        heif_chroma chroma)
+{
+  switch (chroma) {
+    case heif_chroma_444:
+    case heif_chroma_monochrome:
+      return true;
+    case heif_chroma_422:
+      return (width & 1) == 0;
+    case heif_chroma_420:
+      return (width & 1) == 0 && (height & 1) == 0;
+    default:
+      assert(false);
+      return false;
+  }
+}
+
+
+std::vector<heif_chroma> get_valid_chroma_values_for_colorspace(heif_colorspace colorspace)
+{
+  switch (colorspace) {
+    case heif_colorspace_YCbCr:
+      return {heif_chroma_420, heif_chroma_422, heif_chroma_444};
+
+    case heif_colorspace_RGB:
+      return {heif_chroma_444,
+              heif_chroma_interleaved_RGB,
+              heif_chroma_interleaved_RGBA,
+              heif_chroma_interleaved_RRGGBB_BE,
+              heif_chroma_interleaved_RRGGBBAA_BE,
+              heif_chroma_interleaved_RRGGBB_LE,
+              heif_chroma_interleaved_RRGGBBAA_LE};
+
+    case heif_colorspace_monochrome:
+      return {heif_chroma_monochrome};
+
+    case heif_colorspace_nonvisual:
+      return {heif_chroma_undefined};
+
+    case heif_colorspace_filter_array:
+      return {heif_chroma_monochrome};
+
+    default:
+      return {};
+  }
+}
+
+
+void HeifPixelImage::create(uint32_t width, uint32_t height, heif_colorspace colorspace, heif_chroma chroma)
+{
+  m_width = width;
+  m_height = height;
+  m_colorspace = colorspace;
+  m_chroma = chroma;
+}
+
+static uint32_t rounded_size(uint32_t s)
+{
+  s = (s + 1U) & ~1U;
+
+  if (s < 64) {
+    s = 64;
+  }
+
+  return s;
+}
+
+HeifPixelImage::ImageComponent HeifPixelImage::new_image_plane_for_channel(heif_channel channel)
+{
+  ImageComponent plane;
+
+  // libheif channel type
+
+  plane.m_channel = channel;
+
+  // ISO 23001-17 component types
+  // For interleaved planes, several component types are added to cmpd
+
+  auto cmpd = map_channel_to_component_type(channel, m_chroma);
+  for (size_t i = 0; i < cmpd.size(); i++) {
+    plane.m_component_index.push_back(static_cast<uint32_t>(m_cmpd_component_types.size()));
+    m_cmpd_component_types.push_back(cmpd[i]);
+  }
+
+  return plane;
+}
+
+
+Error HeifPixelImage::add_plane(heif_channel channel, uint32_t width, uint32_t height, int bit_depth,
+                                const heif_security_limits* limits)
+{
+  ImageComponent plane = new_image_plane_for_channel(channel);
+
+  int num_interleaved_pixels = num_interleaved_components_per_plane(m_chroma);
+
+  // for backwards compatibility, allow for 24/32 bits for RGB/RGBA interleaved chromas
+
+  if (m_chroma == heif_chroma_interleaved_RGB && bit_depth == 24) {
+    bit_depth = 8;
+  }
+
+  if (m_chroma == heif_chroma_interleaved_RGBA && bit_depth == 32) {
+    bit_depth = 8;
+  }
+
+  if (auto err = plane.alloc(width, height, heif_channel_datatype_unsigned_integer, bit_depth, num_interleaved_pixels, limits, m_memory_handle)) {
+    return err;
+  }
+  else {
+    m_planes.push_back(plane);
+    return Error::Ok;
+  }
+}
+
+
+Error HeifPixelImage::add_channel(heif_channel channel, uint32_t width, uint32_t height, heif_channel_datatype datatype, int bit_depth,
+                                  const heif_security_limits* limits)
+{
+  ImageComponent plane = new_image_plane_for_channel(channel);
+
+  if (Error err = plane.alloc(width, height, datatype, bit_depth, 1, limits, m_memory_handle)) {
+    return err;
+  }
+  else {
+    m_planes.push_back(plane);
+    return Error::Ok;
+  }
+}
+
+
+Error HeifPixelImage::ImageComponent::alloc(uint32_t width, uint32_t height, heif_channel_datatype datatype, int bit_depth,
+                                        int num_interleaved_components,
+                                        const heif_security_limits* limits,
+                                        MemoryHandle& memory_handle)
+{
+  assert(bit_depth >= 1);
+  assert(bit_depth <= 128);
+
+  if (width == 0 || height == 0) {
+    return {heif_error_Usage_error,
+            heif_suberror_Unspecified,
+            "Invalid image size"};
+  }
+
+  // use 16 byte alignment (enough for 128 bit data-types). Every row is an integer number of data-elements.
+  uint16_t alignment = 16; // must be power of two
+
+  m_width = width;
+  m_height = height;
+
+  m_mem_width = rounded_size(width);
+  m_mem_height = rounded_size(height);
+
+  assert(num_interleaved_components > 0 && num_interleaved_components <= 255);
+
+  m_bit_depth = static_cast<uint8_t>(bit_depth);
+  m_num_interleaved_components = static_cast<uint8_t>(num_interleaved_components);
+  m_datatype = datatype;
+
+
+  int bytes_per_pixel = get_bytes_per_pixel();
+
+  stride = m_mem_width * bytes_per_pixel;
+  stride = (stride + alignment - 1U) & ~(alignment - 1U);
+
+  assert(alignment>=1);
+
+  if (limits &&
+      limits->max_image_size_pixels &&
+      limits->max_image_size_pixels / height < width) {
+
+    std::stringstream sstr;
+    sstr << "Allocating an image of size " << width << "x" << height << " exceeds the security limit of "
+         << limits->max_image_size_pixels << " pixels";
+
+    return {heif_error_Memory_allocation_error,
+            heif_suberror_Security_limit_exceeded,
+            sstr.str()};
+  }
+
+  // Check for allocation size overflow using 64-bit arithmetic
+  // Test case was an overlay image with size 1x134217727.
+  // Width 1 gets aligned to 64 and then width * height overflows 32 bit systems.
+  uint64_t alloc_64 = static_cast<uint64_t>(m_mem_height) * stride + alignment - 1;
+  if (alloc_64 > std::numeric_limits<size_t>::max()) {
+    return {heif_error_Memory_allocation_error,
+            heif_suberror_Security_limit_exceeded,
+            "Image allocation size overflow"};
+  }
+  allocation_size = static_cast<size_t>(alloc_64);
+
+  if (auto err = memory_handle.alloc(allocation_size, limits, "image data")) {
+    return err;
+  }
+
+    // --- allocate memory
+
+  allocated_mem = new (std::nothrow) uint8_t[allocation_size];
+  if (allocated_mem == nullptr) {
+    std::stringstream sstr;
+    sstr << "Allocating " << allocation_size << " bytes failed";
+
+    return {heif_error_Memory_allocation_error,
+            heif_suberror_Unspecified,
+            sstr.str()};
+  }
+
+  uint8_t* mem_8 = allocated_mem;
+
+  // shift beginning of image data to aligned memory position
+
+  auto mem_start_addr = (uint64_t) mem_8;
+  auto mem_start_offset = (mem_start_addr & (alignment - 1U));
+  if (mem_start_offset != 0) {
+    mem_8 += alignment - mem_start_offset;
+  }
+
+  mem = mem_8;
+
+  return Error::Ok;
+}
+
+
+Error HeifPixelImage::extend_padding_to_size(uint32_t width, uint32_t height, bool adjust_size,
+                                             const heif_security_limits* limits)
+{
+  for (auto& component : m_planes) {
+    uint32_t subsampled_width, subsampled_height;
+    get_subsampled_size(width, height, component.m_channel, m_chroma,
+                        &subsampled_width, &subsampled_height);
+
+    uint32_t old_width = component.m_width;
+    uint32_t old_height = component.m_height;
+
+    int bytes_per_pixel = component.get_bytes_per_pixel();
+
+    if (component.m_mem_width < subsampled_width ||
+        component.m_mem_height < subsampled_height) {
+
+      ImageComponent newPlane;
+      newPlane.m_channel = component.m_channel;
+      if (auto err = newPlane.alloc(subsampled_width, subsampled_height, component.m_datatype, component.m_bit_depth,
+                                    num_interleaved_components_per_plane(m_chroma),
+                                    limits, m_memory_handle))
+      {
+        return err;
+      }
+
+      // This is not needed, but we have to silence the clang-tidy false positive.
+      if (!newPlane.mem) {
+        return Error::InternalError;
+      }
+
+      // copy the visible part of the old plane into the new plane
+
+      for (uint32_t y = 0; y < component.m_height; y++) {
+        memcpy(static_cast<uint8_t*>(newPlane.mem) + y * newPlane.stride,
+               static_cast<uint8_t*>(component.mem) + y * component.stride,
+               component.m_width * bytes_per_pixel);
+      }
+
+      component = newPlane;
+    }
+
+    // extend plane size
+
+    if (old_width != subsampled_width) {
+      for (uint32_t y = 0; y < old_height; y++) {
+        for (uint32_t x = old_width; x < subsampled_width; x++) {
+          memcpy(static_cast<uint8_t*>(component.mem) + y * component.stride + x * bytes_per_pixel,
+                 static_cast<uint8_t*>(component.mem) + y * component.stride + (old_width - 1) * bytes_per_pixel,
+                 bytes_per_pixel);
+        }
+      }
+    }
+
+    for (uint32_t y = old_height; y < subsampled_height; y++) {
+      memcpy(static_cast<uint8_t*>(component.mem) + y * component.stride,
+             static_cast<uint8_t*>(component.mem) + (old_height - 1) * component.stride,
+             subsampled_width * bytes_per_pixel);
+    }
+
+
+    if (adjust_size) {
+      component.m_width = subsampled_width;
+      component.m_height = subsampled_height;
+    }
+  }
+
+  // modify logical image size, if requested
+
+  if (adjust_size) {
+    m_width = width;
+    m_height = height;
+  }
+
+  return Error::Ok;
+}
+
+
+Error HeifPixelImage::extend_to_size_with_zero(uint32_t width, uint32_t height, const heif_security_limits* limits)
+{
+  for (auto& component : m_planes) {
+    uint32_t subsampled_width, subsampled_height;
+    get_subsampled_size(width, height, component.m_channel, m_chroma,
+                        &subsampled_width, &subsampled_height);
+
+    uint32_t old_width = component.m_width;
+    uint32_t old_height = component.m_height;
+
+    int bytes_per_pixel = component.get_bytes_per_pixel();
+
+    if (component.m_mem_width < subsampled_width ||
+        component.m_mem_height < subsampled_height) {
+
+      ImageComponent newPlane;
+      newPlane.m_channel = component.m_channel;
+      if (auto err = newPlane.alloc(subsampled_width, subsampled_height, component.m_datatype, component.m_bit_depth, num_interleaved_components_per_plane(m_chroma), limits, m_memory_handle)) {
+        return err;
+      }
+
+      // This is not needed, but we have to silence the clang-tidy false positive.
+      if (!newPlane.mem) {
+        return Error::InternalError;
+      }
+
+      // copy the visible part of the old plane into the new plane
+
+      for (uint32_t y = 0; y < component.m_height; y++) {
+        memcpy(static_cast<uint8_t*>(newPlane.mem) + y * newPlane.stride,
+               static_cast<uint8_t*>(component.mem) + y * component.stride,
+               component.m_width * bytes_per_pixel);
+      }
+
+      // --- replace existing image plane with reallocated plane
+
+      delete[] component.allocated_mem;
+
+      component = newPlane;
+    }
+
+    // extend plane size
+
+    uint8_t fill = 0;
+    if (bytes_per_pixel == 1 && (component.m_channel == heif_channel_Cb || component.m_channel == heif_channel_Cr)) {
+      fill = 128;
+    }
+
+    if (old_width != subsampled_width) {
+      for (uint32_t y = 0; y < old_height; y++) {
+        memset(static_cast<uint8_t*>(component.mem) + y * component.stride + old_width * bytes_per_pixel,
+               fill,
+               bytes_per_pixel * (subsampled_width - old_width));
+      }
+    }
+
+    for (uint32_t y = old_height; y < subsampled_height; y++) {
+      memset(static_cast<uint8_t*>(component.mem) + y * component.stride,
+             fill,
+             subsampled_width * bytes_per_pixel);
+    }
+
+
+    component.m_width = subsampled_width;
+    component.m_height = subsampled_height;
+  }
+
+  // modify the logical image size
+
+  m_width = width;
+  m_height = height;
+
+  return Error::Ok;
+}
+
+bool HeifPixelImage::has_channel(heif_channel channel) const
+{
+  return find_component_for_channel(channel) != nullptr;
+}
+
+
+bool HeifPixelImage::has_alpha() const
+{
+  return has_channel(heif_channel_Alpha) ||
+         get_chroma_format() == heif_chroma_interleaved_RGBA ||
+         get_chroma_format() == heif_chroma_interleaved_RRGGBBAA_BE ||
+         get_chroma_format() == heif_chroma_interleaved_RRGGBBAA_LE;
+}
+
+
+uint32_t HeifPixelImage::get_width(enum heif_channel channel) const
+{
+  auto* comp = find_component_for_channel(channel);
+  if (!comp) {
+    return 0;
+  }
+
+  return comp->m_width;
+}
+
+
+uint32_t HeifPixelImage::get_height(enum heif_channel channel) const
+{
+  auto* comp = find_component_for_channel(channel);
+  if (!comp) {
+    return 0;
+  }
+
+  return comp->m_height;
+}
+
+
+uint32_t HeifPixelImage::get_width(uint32_t component_idx) const
+{
+  auto* comp = find_component_by_index(component_idx);
+  if (!comp) {
+    return 0;
+  }
+
+  return comp->m_width;
+}
+
+
+uint32_t HeifPixelImage::get_height(uint32_t component_idx) const
+{
+  auto* comp = find_component_by_index(component_idx);
+  if (!comp) {
+    return 0;
+  }
+
+  return comp->m_height;
+}
+
+
+uint32_t HeifPixelImage::get_primary_component() const
+{
+  // first pass: search for a visual channel
+
+  for (uint32_t idx=0; idx<m_planes.size(); idx++) {
+    switch (m_planes[idx].m_channel) {
+      case heif_channel_interleaved:
+      case heif_channel_Y:
+      case heif_channel_R:
+      case heif_channel_G:
+      case heif_channel_B:
+      case heif_channel_filter_array:
+        return m_planes[idx].m_component_index[0];
+      default:
+        ; // NOP
+    }
+  }
+
+  // second pass: if we have a cmpd table, use component types
+
+  if (!m_cmpd_component_types.empty()) {
+    for (uint32_t idx=0; idx<m_planes.size(); idx++) {
+      uint16_t comp_type = get_component_type(m_planes[idx].m_component_index[0]);
+      switch (comp_type) {
+        case heif_uncompressed_component_type_Y:
+        case heif_uncompressed_component_type_monochrome:
+        case heif_uncompressed_component_type_red:
+        case heif_uncompressed_component_type_green:
+        case heif_uncompressed_component_type_blue:
+        case heif_uncompressed_component_type_cyan:
+        case heif_uncompressed_component_type_magenta:
+        case heif_uncompressed_component_type_yellow:
+        case heif_uncompressed_component_type_key_black:
+        case heif_uncompressed_component_type_filter_array:
+        case heif_uncompressed_component_type_palette:
+          return m_planes[idx].m_component_index[0];
+
+        default:
+          ; // NOP
+      }
+    }
+  }
+
+  // third pass: allow anything
+
+  if (!m_planes.empty()) {
+    return m_planes[0].m_component_index[0];
+  }
+  return 0;
+}
+#if 0
+uint32_t HeifPixelImage::get_primary_width() const
+{
+  if (m_colorspace == heif_colorspace_RGB) {
+    if (m_chroma == heif_chroma_444) {
+      return get_width(heif_channel_G);
+    }
+    else {
+      return get_width(heif_channel_interleaved);
+    }
+  }
+  else {
+    return get_width(heif_channel_Y);
+  }
+}
+
+
+uint32_t HeifPixelImage::get_primary_height() const
+{
+  if (m_colorspace == heif_colorspace_RGB) {
+    if (m_chroma == heif_chroma_444) {
+      return get_height(heif_channel_G);
+    }
+    else {
+      return get_height(heif_channel_interleaved);
+    }
+  }
+  else {
+    return get_height(heif_channel_Y);
+  }
+}
+#endif
+
+std::set<heif_channel> HeifPixelImage::get_channel_set() const
+{
+  std::set<heif_channel> channels;
+
+  for (const auto& component : m_planes) {
+    channels.insert(component.m_channel);
+  }
+
+  return channels;
+}
+
+
+uint8_t HeifPixelImage::get_storage_bits_per_pixel(enum heif_channel channel) const
+{
+  auto* comp = find_component_for_channel(channel);
+  if (!comp) {
+    return -1;
+  }
+
+  uint32_t bpp = comp->get_bytes_per_pixel() * 8;
+  assert(bpp <= 255);
+  return static_cast<uint8_t>(bpp);
+}
+
+
+uint8_t HeifPixelImage::get_bits_per_pixel(enum heif_channel channel) const
+{
+  auto* comp = find_component_for_channel(channel);
+  if (!comp) {
+    return -1;
+  }
+
+  return comp->m_bit_depth;
+}
+
+
+uint8_t HeifPixelImage::get_visual_image_bits_per_pixel() const
+{
+  switch (m_colorspace) {
+    case heif_colorspace_monochrome:
+      return get_bits_per_pixel(heif_channel_Y);
+      break;
+    case heif_colorspace_YCbCr:
+      return std::max(get_bits_per_pixel(heif_channel_Y),
+                      std::max(get_bits_per_pixel(heif_channel_Cb),
+                               get_bits_per_pixel(heif_channel_Cr)));
+      break;
+    case heif_colorspace_RGB:
+      if (m_chroma == heif_chroma_444) {
+        return std::max(get_bits_per_pixel(heif_channel_R),
+             std::max(get_bits_per_pixel(heif_channel_G),
+                        get_bits_per_pixel(heif_channel_B)));
+      }
+      else {
+        assert(has_channel(heif_channel_interleaved));
+        return get_bits_per_pixel(heif_channel_interleaved);
+      }
+      break;
+    case heif_colorspace_nonvisual:
+      return 0;
+      break;
+    case heif_colorspace_filter_array:
+      assert(has_channel(heif_channel_filter_array));
+      return get_bits_per_pixel(heif_channel_filter_array);
+    default:
+      assert(false);
+      return 0;
+      break;
+  }
+}
+
+
+heif_channel_datatype HeifPixelImage::get_datatype(enum heif_channel channel) const
+{
+  auto* comp = find_component_for_channel(channel);
+  if (!comp) {
+    return heif_channel_datatype_undefined;
+  }
+
+  return comp->m_datatype;
+}
+
+
+int HeifPixelImage::get_number_of_interleaved_components(heif_channel channel) const
+{
+  auto* comp = find_component_for_channel(channel);
+  if (!comp) {
+    return 0;
+  }
+
+  return comp->m_num_interleaved_components;
+}
+
+
+Error HeifPixelImage::copy_new_plane_from(const std::shared_ptr<const HeifPixelImage>& src_image,
+                                          heif_channel src_channel,
+                                          heif_channel dst_channel,
+                                          const heif_security_limits* limits)
+{
+  assert(src_image->has_channel(src_channel));
+  assert(!has_channel(dst_channel));
+
+  uint32_t width = src_image->get_width(src_channel);
+  uint32_t height = src_image->get_height(src_channel);
+
+  const auto* src_plane_ptr = src_image->find_component_for_channel(src_channel);
+  assert(src_plane_ptr != nullptr);
+  const auto& src_plane = *src_plane_ptr;
+
+  auto err = add_channel(dst_channel, width, height,
+                         src_plane.m_datatype,
+                         src_image->get_bits_per_pixel(src_channel), limits);
+  if (err) {
+    return err;
+  }
+
+  uint8_t* dst;
+  size_t dst_stride = 0;
+
+  const uint8_t* src;
+  size_t src_stride = 0;
+
+  src = src_image->get_plane(src_channel, &src_stride);
+  dst = get_plane(dst_channel, &dst_stride);
+
+  uint32_t bpl = width * (src_image->get_storage_bits_per_pixel(src_channel) / 8);
+
+  for (uint32_t y = 0; y < height; y++) {
+    memcpy(dst + y * dst_stride, src + y * src_stride, bpl);
+  }
+
+  return Error::Ok;
+}
+
+
+Error HeifPixelImage::extract_alpha_from_RGBA(const std::shared_ptr<const HeifPixelImage>& src_image,
+                                              const heif_security_limits* limits)
+{
+  uint32_t width = src_image->get_width();
+  uint32_t height = src_image->get_height();
+
+  if (Error err = add_plane(heif_channel_Y, width, height, src_image->get_bits_per_pixel(heif_channel_interleaved), limits)) {
+    return err;
+  }
+
+  uint8_t* dst;
+  size_t dst_stride = 0;
+
+  const uint8_t* src;
+  size_t src_stride = 0;
+
+  src = src_image->get_plane(heif_channel_interleaved, &src_stride);
+  dst = get_plane(heif_channel_Y, &dst_stride);
+
+  //int bpl = width * (src_image->get_storage_bits_per_pixel(src_channel) / 8);
+
+  for (uint32_t y = 0; y < height; y++) {
+    for (uint32_t x = 0; x < width; x++) {
+      dst[y * dst_stride + x] = src[y * src_stride + 4 * x + 3];
+    }
+  }
+
+  return Error::Ok;
+}
+
+
+Error HeifPixelImage::fill_new_plane(heif_channel dst_channel, uint16_t value, int width, int height, int bpp,
+                                     const heif_security_limits* limits)
+{
+  if (Error err = add_plane(dst_channel, width, height, bpp, limits)) {
+    return err;
+  }
+
+  fill_plane(dst_channel, value);
+
+  return Error::Ok;
+}
+
+
+void HeifPixelImage::fill_plane(heif_channel dst_channel, uint16_t value)
+{
+  int num_interleaved = num_interleaved_components_per_plane(m_chroma);
+
+  int bpp = get_bits_per_pixel(dst_channel);
+  uint32_t width = get_width(dst_channel);
+  uint32_t height = get_height(dst_channel);
+
+  if (bpp <= 8) {
+    uint8_t* dst;
+    size_t dst_stride = 0;
+    dst = get_plane(dst_channel, &dst_stride);
+    uint32_t width_bytes = width * num_interleaved;
+
+    for (uint32_t y = 0; y < height; y++) {
+      memset(dst + y * dst_stride, value, width_bytes);
+    }
+  }
+  else {
+    uint16_t* dst;
+    size_t dst_stride = 0;
+    dst = get_channel<uint16_t>(dst_channel, &dst_stride);
+
+    for (uint32_t y = 0; y < height; y++) {
+      for (uint32_t x = 0; x < width * num_interleaved; x++) {
+        dst[y * dst_stride + x] = value;
+      }
+    }
+  }
+}
+
+
+void HeifPixelImage::transfer_plane_from_image_as(const std::shared_ptr<HeifPixelImage>& source,
+                                                  heif_channel src_channel,
+                                                  heif_channel dst_channel)
+{
+  // TODO: check that dst_channel does not exist yet
+
+  // Find and remove the component from source
+  ImageComponent plane;
+  for (auto it = source->m_planes.begin(); it != source->m_planes.end(); ++it) {
+    if (it->m_channel == src_channel) {
+      plane = *it;
+      source->m_planes.erase(it);
+      break;
+    }
+  }
+  source->m_memory_handle.free(plane.allocation_size);
+
+  plane.m_channel = dst_channel;
+  m_planes.push_back(plane);
+
+  // Note: we assume that image planes are never transferred between heif_contexts
+  m_memory_handle.alloc(plane.allocation_size,
+                        source->m_memory_handle.get_security_limits(),
+                        "transferred image data");
+}
+
+
+bool is_interleaved_with_alpha(heif_chroma chroma)
+{
+  switch (chroma) {
+    case heif_chroma_undefined:
+    case heif_chroma_monochrome:
+    case heif_chroma_420:
+    case heif_chroma_422:
+    case heif_chroma_444:
+    case heif_chroma_interleaved_RGB:
+    case heif_chroma_interleaved_RRGGBB_BE:
+    case heif_chroma_interleaved_RRGGBB_LE:
+      return false;
+
+    case heif_chroma_interleaved_RGBA:
+    case heif_chroma_interleaved_RRGGBBAA_BE:
+    case heif_chroma_interleaved_RRGGBBAA_LE:
+      return true;
+  }
+
+  assert(false);
+  return false;
+}
+
+
+Error HeifPixelImage::copy_image_to(const std::shared_ptr<const HeifPixelImage>& source, uint32_t x0, uint32_t y0)
+{
+  std::set<enum heif_channel> channels = source->get_channel_set();
+
+  uint32_t w = get_width();
+  uint32_t h = get_height();
+  heif_chroma chroma = get_chroma_format();
+
+
+  for (heif_channel channel : channels) {
+
+    size_t tile_stride;
+    const uint8_t* tile_data = source->get_plane(channel, &tile_stride);
+
+    size_t out_stride;
+    uint8_t* out_data = get_plane(channel, &out_stride);
+
+    if (w <= x0 || h <= y0) {
+      return {heif_error_Invalid_input,
+              heif_suberror_Invalid_grid_data};
+    }
+
+    if (source->get_bits_per_pixel(channel) != get_bits_per_pixel(channel)) {
+      return {heif_error_Invalid_input,
+              heif_suberror_Wrong_tile_image_pixel_depth};
+    }
+
+    uint32_t src_width = source->get_width(channel);
+    uint32_t src_height = source->get_height(channel);
+
+    uint32_t xs = channel_width(x0, chroma, channel);
+    uint32_t ys = channel_height(y0, chroma, channel);
+
+    // Compute copy size from actual plane bounds to avoid chroma rounding mismatch.
+    // channel_height(y0) + channel_height(h - y0) can exceed channel_height(h) with 4:2:0
+    // due to ceiling division, so we use (plane_size - offset) instead.
+    uint32_t copy_width = std::min(src_width, channel_width(w, chroma, channel) - xs);
+    uint32_t copy_height = std::min(src_height, channel_height(h, chroma, channel) - ys);
+
+    copy_width *= source->get_storage_bits_per_pixel(channel) / 8;
+    xs *= source->get_storage_bits_per_pixel(channel) / 8;
+
+    for (uint32_t py = 0; py < copy_height; py++) {
+      memcpy(out_data + xs + (ys + py) * out_stride,
+             tile_data + py * tile_stride,
+             copy_width);
+    }
+  }
+
+  return Error::Ok;
+}
+
+
+void HeifPixelImage::zero_region(uint32_t x0, uint32_t y0, uint32_t w, uint32_t h)
+{
+  uint32_t img_w = get_width();
+  uint32_t img_h = get_height();
+  heif_chroma chroma = get_chroma_format();
+
+  std::set<enum heif_channel> channels = get_channel_set();
+
+  for (heif_channel channel : channels) {
+    uint32_t cx0 = channel_width(x0, chroma, channel);
+    uint32_t cy0 = channel_height(y0, chroma, channel);
+    uint32_t cw = channel_width(w, chroma, channel);
+    uint32_t ch = channel_height(h, chroma, channel);
+
+    // clamp to plane bounds
+    uint32_t plane_w = channel_width(img_w, chroma, channel);
+    uint32_t plane_h = channel_height(img_h, chroma, channel);
+    if (cx0 >= plane_w || cy0 >= plane_h) {
+      continue;
+    }
+    cw = std::min(cw, plane_w - cx0);
+    ch = std::min(ch, plane_h - cy0);
+
+    size_t stride = 0;
+    uint8_t* data = get_plane(channel, &stride);
+    uint32_t bytes_per_pixel = get_storage_bits_per_pixel(channel) / 8;
+    uint32_t width_bytes = cw * bytes_per_pixel;
+
+    for (uint32_t y = 0; y < ch; y++) {
+      memset(data + cx0 * bytes_per_pixel + (cy0 + y) * stride, 0, width_bytes);
+    }
+  }
+}
+
+
+Result<std::shared_ptr<HeifPixelImage>> HeifPixelImage::rotate_ccw(int angle_degrees, const heif_security_limits* limits)
+{
+  // --- for some subsampled chroma colorspaces, we have to transform to 4:4:4 before rotation
+
+  bool need_conversion = false;
+
+  if (get_chroma_format() == heif_chroma_422) {
+    if (angle_degrees == 90 || angle_degrees == 270) {
+      need_conversion = true;
+    }
+    else if (angle_degrees == 180 && has_odd_height()) {
+      need_conversion = true;
+    }
+  }
+  else if (get_chroma_format() == heif_chroma_420) {
+    if (angle_degrees == 90 && has_odd_width()) {
+      need_conversion = true;
+    }
+    else if (angle_degrees == 180 && (has_odd_width() || has_odd_height())) {
+      need_conversion = true;
+    }
+    else if (angle_degrees == 270 && has_odd_height()) {
+      need_conversion = true;
+    }
+  }
+
+  if (need_conversion) {
+    heif_color_conversion_options options{};
+    heif_color_conversion_options_set_defaults(&options);
+
+    auto converted_image_result = convert_colorspace(shared_from_this(), heif_colorspace_YCbCr, heif_chroma_444,
+                                                     nclx_profile(), // default, undefined
+                                                     get_bits_per_pixel(heif_channel_Y), options, nullptr, limits);
+    if (!converted_image_result) {
+      return converted_image_result.error();
+    }
+
+    return (*converted_image_result)->rotate_ccw(angle_degrees, limits);
+  }
+
+
+  // --- create output image
+
+  if (angle_degrees == 0) {
+    return shared_from_this();
+  }
+
+  uint32_t out_width = m_width;
+  uint32_t out_height = m_height;
+
+  if (angle_degrees == 90 || angle_degrees == 270) {
+    std::swap(out_width, out_height);
+  }
+
+  std::shared_ptr<HeifPixelImage> out_img = std::make_shared<HeifPixelImage>();
+  out_img->create(out_width, out_height, m_colorspace, m_chroma);
+
+
+  // --- rotate all channels
+
+  for (const auto &component: m_planes) {
+    heif_channel channel = component.m_channel;
+
+    uint32_t out_plane_width = component.m_width;
+    uint32_t out_plane_height = component.m_height;
+
+    if (angle_degrees == 90 || angle_degrees == 270) {
+      std::swap(out_plane_width, out_plane_height);
+    }
+
+    Error err = out_img->add_channel(channel, out_plane_width, out_plane_height, component.m_datatype, component.m_bit_depth, limits);
+    if (err) {
+      return err;
+    }
+
+    // The output plane is the last one added
+    ImageComponent& out_plane = out_img->m_planes.back();
+
+    if (component.m_bit_depth <= 8) {
+      component.rotate_ccw<uint8_t>(angle_degrees, out_plane);
+    }
+    else if (component.m_bit_depth <= 16) {
+      component.rotate_ccw<uint16_t>(angle_degrees, out_plane);
+    }
+    else if (component.m_bit_depth <= 32) {
+      component.rotate_ccw<uint32_t>(angle_degrees, out_plane);
+    }
+    else if (component.m_bit_depth <= 64) {
+      component.rotate_ccw<uint64_t>(angle_degrees, out_plane);
+    }
+    else if (component.m_bit_depth <= 128) {
+      component.rotate_ccw<heif_complex64>(angle_degrees, out_plane);
+    }
+  }
+  // --- pass the color profiles to the new image
+
+  out_img->set_color_profile_nclx(get_color_profile_nclx());
+  out_img->set_color_profile_icc(get_color_profile_icc());
+
+  out_img->add_warnings(get_warnings());
+
+  return out_img;
+}
+
+template<typename T>
+void HeifPixelImage::ImageComponent::rotate_ccw(int angle_degrees,
+                                            ImageComponent& out_plane) const
+{
+  uint32_t w = m_width;
+  uint32_t h = m_height;
+
+  size_t in_stride = stride / sizeof(T);
+  const T* in_data = static_cast<const T*>(mem);
+
+  size_t out_stride = out_plane.stride / sizeof(T);
+  T* out_data = static_cast<T*>(out_plane.mem);
+
+  if (angle_degrees == 270) {
+    for (uint32_t x = 0; x < h; x++)
+      for (uint32_t y = 0; y < w; y++) {
+        out_data[y * out_stride + x] = in_data[(h - 1 - x) * in_stride + y];
+      }
+  } else if (angle_degrees == 180) {
+    for (uint32_t y = 0; y < h; y++)
+      for (uint32_t x = 0; x < w; x++) {
+        out_data[y * out_stride + x] = in_data[(h - 1 - y) * in_stride + (w - 1 - x)];
+      }
+  } else if (angle_degrees == 90) {
+    for (uint32_t x = 0; x < h; x++)
+      for (uint32_t y = 0; y < w; y++) {
+        out_data[y * out_stride + x] = in_data[x * in_stride + (w - 1 - y)];
+      }
+  }
+}
+
+
+template<typename T>
+void HeifPixelImage::ImageComponent::mirror_inplace(heif_transform_mirror_direction direction)
+{
+  uint32_t w = m_width;
+  uint32_t h = m_height;
+
+  T* data = static_cast<T*>(mem);
+
+  if (direction == heif_transform_mirror_direction_horizontal) {
+    for (uint32_t y = 0; y < h; y++) {
+      for (uint32_t x = 0; x < w / 2; x++)
+        std::swap(data[y * stride / sizeof(T) + x], data[y * stride / sizeof(T) + w - 1 - x]);
+    }
+  } else {
+    for (uint32_t y = 0; y < h / 2; y++) {
+      for (uint32_t x = 0; x < w; x++)
+        std::swap(data[y * stride / sizeof(T) + x], data[(h - 1 - y) * stride / sizeof(T) + x]);
+    }
+  }
+}
+
+
+Result<std::shared_ptr<HeifPixelImage>> HeifPixelImage::mirror_inplace(heif_transform_mirror_direction direction,
+                                                                       const heif_security_limits* limits)
+{
+  // --- for some subsampled chroma colorspaces, we have to transform to 4:4:4 before rotation
+
+  bool need_conversion = false;
+
+  if (get_chroma_format() == heif_chroma_422) {
+    if (direction == heif_transform_mirror_direction_horizontal && has_odd_width()) {
+      need_conversion = true;
+    }
+  }
+  else if (get_chroma_format() == heif_chroma_420) {
+    if (has_odd_width() || has_odd_height()) {
+      need_conversion = true;
+    }
+  }
+
+  if (need_conversion) {
+    heif_color_conversion_options options{};
+    heif_color_conversion_options_set_defaults(&options);
+
+    auto converted_image_result = convert_colorspace(shared_from_this(), heif_colorspace_YCbCr, heif_chroma_444,
+                                                     nclx_profile(), // default, undefined
+                                                     get_bits_per_pixel(heif_channel_Y), options, nullptr, limits);
+    if (!converted_image_result) {
+      return converted_image_result.error();
+    }
+
+    return (*converted_image_result)->mirror_inplace(direction, limits);
+  }
+
+
+  for (auto& component : m_planes) {
+    if (component.m_bit_depth <= 8) {
+      component.mirror_inplace<uint8_t>(direction);
+    }
+    else if (component.m_bit_depth <= 16) {
+      component.mirror_inplace<uint16_t>(direction);
+    }
+    else if (component.m_bit_depth <= 32) {
+      component.mirror_inplace<uint32_t>(direction);
+    }
+    else if (component.m_bit_depth <= 64) {
+      component.mirror_inplace<uint64_t>(direction);
+    }
+    else if (component.m_bit_depth <= 128) {
+      component.mirror_inplace<heif_complex64>(direction);
+    }
+    else {
+      std::stringstream sstr;
+      sstr << "Cannot mirror images with " << component.m_bit_depth << " bits per pixel";
+      return Error{heif_error_Unsupported_feature,
+                   heif_suberror_Unspecified,
+                   sstr.str()};
+    }
+  }
+
+  return shared_from_this();
+}
+
+
+int HeifPixelImage::ImageComponent::get_bytes_per_pixel() const
+{
+  int bytes_per_component;
+
+  if (m_bit_depth <= 8) {
+    bytes_per_component = 1;
+  }
+  else if (m_bit_depth <= 16) {
+    bytes_per_component = 2;
+  }
+  else if (m_bit_depth <= 32) {
+    bytes_per_component = 4;
+  }
+  else if (m_bit_depth <= 64) {
+    bytes_per_component = 8;
+  }
+  else {
+    assert(m_bit_depth <= 128);
+    bytes_per_component = 16;
+  }
+
+  return bytes_per_component * m_num_interleaved_components;
+}
+
+
+Result<std::shared_ptr<HeifPixelImage>> HeifPixelImage::crop(uint32_t left, uint32_t right, uint32_t top, uint32_t bottom,
+                                                             const heif_security_limits* limits) const
+{
+  // --- for some subsampled chroma colorspaces, we have to transform to 4:4:4 before cropping
+
+  bool need_conversion = false;
+
+  if (get_chroma_format() == heif_chroma_422 && (left & 1) == 1) {
+      need_conversion = true;
+  }
+  else if (get_chroma_format() == heif_chroma_420 &&
+           ((left & 1) == 1 || (top & 1) == 1)) {
+    need_conversion = true;
+  }
+
+  if (need_conversion) {
+    heif_color_conversion_options options{};
+    heif_color_conversion_options_set_defaults(&options);
+
+    auto converted_image_result = convert_colorspace(shared_from_this(), heif_colorspace_YCbCr, heif_chroma_444,
+                                                     nclx_profile(), // default, undefined
+                                                     get_bits_per_pixel(heif_channel_Y), options, nullptr, limits);
+
+    if (!converted_image_result) {
+      return converted_image_result.error();
+    }
+
+    return (*converted_image_result)->crop(left, right, top, bottom, limits);
+  }
+
+
+
+  auto out_img = std::make_shared<HeifPixelImage>();
+  out_img->create(right - left + 1, bottom - top + 1, m_colorspace, m_chroma);
+
+
+  // --- crop all channels
+
+  for (const auto& component : m_planes) {
+    heif_channel channel = component.m_channel;
+
+    uint32_t plane_left = get_subsampled_size_h(left, channel, m_chroma, scaling_mode::is_divisible); // is always divisible
+    uint32_t plane_right = get_subsampled_size_h(right, channel, m_chroma, scaling_mode::round_down); // this keeps enough chroma since 'right' is a coordinate and not the width
+    uint32_t plane_top = get_subsampled_size_v(top, channel, m_chroma, scaling_mode::is_divisible);
+    uint32_t plane_bottom = get_subsampled_size_v(bottom, channel, m_chroma, scaling_mode::round_down);
+
+    auto err = out_img->add_channel(channel,
+                                    plane_right - plane_left + 1,
+                                    plane_bottom - plane_top + 1,
+                                    component.m_datatype,
+                                    component.m_bit_depth,
+                                    limits);
+    if (err) {
+      return err;
+    }
+
+    // The output plane is the last one added
+    ImageComponent& out_plane = out_img->m_planes.back();
+
+    int bytes_per_pixel = component.get_bytes_per_pixel();
+    component.crop(plane_left, plane_right, plane_top, plane_bottom, bytes_per_pixel, out_plane);
+  }
+
+  // --- pass the color profiles to the new image
+
+  out_img->set_color_profile_nclx(get_color_profile_nclx());
+  out_img->set_color_profile_icc(get_color_profile_icc());
+
+  out_img->add_warnings(get_warnings());
+
+  return out_img;
+}
+
+
+void HeifPixelImage::ImageComponent::crop(uint32_t left, uint32_t right, uint32_t top, uint32_t bottom,
+                                      int bytes_per_pixel, ImageComponent& out_plane) const
+{
+  size_t in_stride = stride;
+  auto* in_data = static_cast<const uint8_t*>(mem);
+
+  size_t out_stride = out_plane.stride;
+  auto* out_data = static_cast<uint8_t*>(out_plane.mem);
+
+  for (uint32_t y = top; y <= bottom; y++) {
+    memcpy(&out_data[(y - top) * out_stride],
+           &in_data[y * in_stride + left * bytes_per_pixel],
+           (right - left + 1) * bytes_per_pixel);
+  }
+}
+
+
+Error HeifPixelImage::fill_RGB_16bit(uint16_t r, uint16_t g, uint16_t b, uint16_t a)
+{
+  for (const auto& channel : {heif_channel_R, heif_channel_G, heif_channel_B, heif_channel_Alpha}) {
+
+    auto* comp = find_component_for_channel(channel);
+    if (!comp) {
+
+      // alpha channel is optional, R,G,B is required
+      if (channel == heif_channel_Alpha) {
+        continue;
+      }
+
+      return {heif_error_Usage_error,
+              heif_suberror_Nonexisting_image_channel_referenced};
+
+    }
+
+    ImageComponent& plane = *comp;
+
+    if (plane.m_bit_depth != 8) {
+      return {heif_error_Unsupported_feature,
+              heif_suberror_Unspecified,
+              "Can currently only fill images with 8 bits per pixel"};
+    }
+
+    size_t h = plane.m_height;
+
+    size_t stride = plane.stride;
+    auto* data = static_cast<uint8_t*>(plane.mem);
+
+    uint16_t val16;
+    switch (channel) {
+      case heif_channel_R:
+        val16 = r;
+        break;
+      case heif_channel_G:
+        val16 = g;
+        break;
+      case heif_channel_B:
+        val16 = b;
+        break;
+      case heif_channel_Alpha:
+        val16 = a;
+        break;
+      default:
+        // initialization only to avoid warning of uninitialized variable.
+        val16 = 0;
+        // Should already be detected by the check above ("find_component_for_channel").
+        assert(false);
+    }
+
+    auto val8 = static_cast<uint8_t>(val16 >> 8U);
+
+
+    // memset() even when h * stride > sizeof(size_t)
+
+    if (std::numeric_limits<size_t>::max() / stride > h) {
+      // can fill in one step
+      memset(data, val8, stride * h);
+    }
+    else {
+      // fill line by line
+      auto* p = data;
+
+      for (size_t y=0;y<h;y++) {
+        memset(p, val8, stride);
+        p += stride;
+      }
+    }
+  }
+
+  return Error::Ok;
+}
+
+
+uint32_t negate_negative_int32(int32_t x)
+{
+  assert(x <= 0);
+
+  if (x == INT32_MIN) {
+    return static_cast<uint32_t>(INT32_MAX) + 1;
+  }
+  else {
+    return static_cast<uint32_t>(-x);
+  }
+}
+
+
+Error HeifPixelImage::overlay(std::shared_ptr<HeifPixelImage>& overlay, int32_t dx, int32_t dy)
+{
+  std::set<enum heif_channel> channels = overlay->get_channel_set();
+
+  bool has_alpha = overlay->has_channel(heif_channel_Alpha);
+  //bool has_alpha_me = has_channel(heif_channel_Alpha);
+
+  size_t alpha_stride = 0;
+  uint8_t* alpha_p;
+  alpha_p = overlay->get_plane(heif_channel_Alpha, &alpha_stride);
+
+  for (heif_channel channel : channels) {
+    if (!has_channel(channel)) {
+      continue;
+    }
+
+    size_t in_stride = 0;
+    const uint8_t* in_p;
+
+    size_t out_stride = 0;
+    uint8_t* out_p;
+
+    in_p = overlay->get_plane(channel, &in_stride);
+    out_p = get_plane(channel, &out_stride);
+
+    uint32_t in_w = overlay->get_width(channel);
+    uint32_t in_h = overlay->get_height(channel);
+
+    uint32_t out_w = get_width(channel);
+    uint32_t out_h = get_height(channel);
+
+
+    // --- check whether overlay image overlaps with current image
+
+    if (dx > 0 && static_cast<uint32_t>(dx) >= out_w) {
+      // the overlay image is completely outside the right border -> skip overlaying
+      return Error::Ok;
+    }
+    else if (dx < 0 && in_w <= negate_negative_int32(dx)) {
+      // the overlay image is completely outside the left border -> skip overlaying
+      return Error::Ok;
+    }
+
+    if (dy > 0 && static_cast<uint32_t>(dy) >= out_h) {
+      // the overlay image is completely outside the bottom border -> skip overlaying
+      return Error::Ok;
+    }
+    else if (dy < 0 && in_h <= negate_negative_int32(dy)) {
+      // the overlay image is completely outside the top border -> skip overlaying
+      return Error::Ok;
+    }
+
+
+    // --- compute overlapping area
+
+    // top-left points where to start copying in source and destination
+    uint32_t in_x0;
+    uint32_t in_y0;
+    uint32_t out_x0;
+    uint32_t out_y0;
+
+    // right border
+    if (dx + static_cast<int64_t>(in_w) > out_w) {
+      // overlay image extends partially outside of right border
+      // Notes:
+      // - (out_w-dx) cannot underflow because dx<out_w is ensured above
+      // - (out_w-dx) cannot overflow (for dx<0) because, as just checked, out_w-dx < in_w
+      //              and in_w fits into uint32_t
+      in_w = static_cast<uint32_t>(static_cast<int64_t>(out_w) - dx);
+    }
+
+    // bottom border
+    if (dy + static_cast<int64_t>(in_h) > out_h) {
+      // overlay image extends partially outside of bottom border
+      in_h = static_cast<uint32_t>(static_cast<int64_t>(out_h) - dy);
+    }
+
+    // left border
+    if (dx < 0) {
+      // overlay image starts partially outside of left border
+
+      in_x0 = negate_negative_int32(dx);
+      out_x0 = 0;
+      in_w = in_w - in_x0; // in_x0 < in_w because in_w > -dx = in_x0
+    }
+    else {
+      in_x0 = 0;
+      out_x0 = static_cast<uint32_t>(dx);
+    }
+
+    // top border
+    if (dy < 0) {
+      // overlay image started partially outside of top border
+
+      in_y0 = negate_negative_int32(dy);
+      out_y0 = 0;
+      in_h = in_h - in_y0; // in_y0 < in_h because in_h > -dy = in_y0
+    }
+    else {
+      in_y0 = 0;
+      out_y0 = static_cast<uint32_t>(dy);
+    }
+
+    // --- computer overlay in overlapping area
+
+    for (uint32_t y = in_y0; y < in_h; y++) {
+      if (!has_alpha) {
+        memcpy(out_p + out_x0 + (out_y0 + y - in_y0) * out_stride,
+               in_p + in_x0 + y * in_stride,
+               in_w);
+      }
+      else {
+        for (uint32_t x = in_x0; x < in_w; x++) {
+          uint8_t* outptr = &out_p[out_x0 + (out_y0 + y - in_y0) * out_stride + x];
+          uint8_t in_val = in_p[in_x0 + y * in_stride + x];
+          uint8_t alpha_val = alpha_p[in_x0 + y * alpha_stride + x];
+
+          *outptr = (uint8_t) ((in_val * alpha_val + *outptr * (255 - alpha_val)) / 255);
+        }
+      }
+    }
+  }
+
+  return Error::Ok;
+}
+
+
+Error HeifPixelImage::scale_nearest_neighbor(std::shared_ptr<HeifPixelImage>& out_img,
+                                             uint32_t width, uint32_t height,
+                                             const heif_security_limits* limits) const
+{
+  out_img = std::make_shared<HeifPixelImage>();
+  out_img->create(width, height, m_colorspace, m_chroma);
+
+
+  // --- create output image with scaled planes
+
+  if (has_channel(heif_channel_interleaved)) {
+    if (auto err = out_img->add_plane(heif_channel_interleaved, width, height, get_bits_per_pixel(heif_channel_interleaved), limits)) {
+      return err;
+    }
+  }
+  else {
+    if (get_colorspace() == heif_colorspace_RGB) {
+      if (!has_channel(heif_channel_R) ||
+          !has_channel(heif_channel_G) ||
+          !has_channel(heif_channel_B)) {
+        return {heif_error_Invalid_input, heif_suberror_Unspecified, "RGB input without R,G,B, planes"};
+      }
+
+      if (auto err = out_img->add_plane(heif_channel_R, width, height, get_bits_per_pixel(heif_channel_R), limits)) {
+        return err;
+      }
+      if (auto err = out_img->add_plane(heif_channel_G, width, height, get_bits_per_pixel(heif_channel_G), limits)) {
+        return err;
+      }
+      if (auto err = out_img->add_plane(heif_channel_B, width, height, get_bits_per_pixel(heif_channel_B), limits)) {
+        return err;
+      }
+    }
+    else if (get_colorspace() == heif_colorspace_monochrome) {
+      if (!has_channel(heif_channel_Y)) {
+        return {heif_error_Invalid_input, heif_suberror_Unspecified, "monochrome input with no Y plane"};
+      }
+
+      if (auto err = out_img->add_plane(heif_channel_Y, width, height, get_bits_per_pixel(heif_channel_Y), limits)) {
+        return err;
+      }
+    }
+    else if (get_colorspace() == heif_colorspace_YCbCr) {
+      if (!has_channel(heif_channel_Y) ||
+          !has_channel(heif_channel_Cb) ||
+          !has_channel(heif_channel_Cr)) {
+        return {heif_error_Invalid_input, heif_suberror_Unspecified, "YCbCr image without Y,Cb,Cr planes"};
+      }
+
+      uint32_t cw, ch;
+      get_subsampled_size(width, height, heif_channel_Cb, get_chroma_format(), &cw, &ch);
+      if (auto err = out_img->add_plane(heif_channel_Y, width, height, get_bits_per_pixel(heif_channel_Y), limits)) {
+        return err;
+      }
+      if (auto err = out_img->add_plane(heif_channel_Cb, cw, ch, get_bits_per_pixel(heif_channel_Cb), limits)) {
+        return err;
+      }
+      if (auto err = out_img->add_plane(heif_channel_Cr, cw, ch, get_bits_per_pixel(heif_channel_Cr), limits)) {
+        return err;
+      }
+    }
+    else {
+      return {heif_error_Invalid_input, heif_suberror_Unspecified, "unknown color configuration"};
+    }
+
+    if (has_channel(heif_channel_Alpha)) {
+      if (auto err = out_img->add_plane(heif_channel_Alpha, width, height, get_bits_per_pixel(heif_channel_Alpha), limits)) {
+        return err;
+      }
+    }
+  }
+
+
+  // --- scale all channels
+
+  int nInterleaved = num_interleaved_components_per_plane(m_chroma);
+  if (nInterleaved > 1) {
+    const auto* comp = find_component_for_channel(heif_channel_interleaved);
+    assert(comp != nullptr); // the plane must exist since we have an interleaved chroma format
+    const ImageComponent& plane = *comp;
+
+    uint32_t out_w = out_img->get_width(heif_channel_interleaved);
+    uint32_t out_h = out_img->get_height(heif_channel_interleaved);
+
+    if (plane.m_bit_depth <= 8) {
+      // SDR interleaved
+
+      size_t in_stride = plane.stride;
+      const auto* in_data = static_cast<const uint8_t*>(plane.mem);
+
+      size_t out_stride = 0;
+      auto* out_data = out_img->get_plane(heif_channel_interleaved, &out_stride);
+
+      for (uint32_t y = 0; y < out_h; y++) {
+        uint32_t iy = y * m_height / height;
+
+        for (uint32_t x = 0; x < out_w; x++) {
+          uint32_t ix = x * m_width / width;
+
+          for (int c = 0; c < nInterleaved; c++) {
+            out_data[y * out_stride + x * nInterleaved + c] = in_data[iy * in_stride + ix * nInterleaved + c];
+          }
+        }
+      }
+    }
+    else {
+      // HDR interleaved
+      // TODO: untested
+
+      size_t in_stride = plane.stride;
+      const uint16_t* in_data = static_cast<const uint16_t*>(plane.mem);
+
+      size_t out_stride = 0;
+      uint16_t* out_data = out_img->get_channel<uint16_t>(heif_channel_interleaved, &out_stride);
+
+      in_stride /= 2;
+
+      for (uint32_t y = 0; y < out_h; y++) {
+        uint32_t iy = y * m_height / height;
+
+        for (uint32_t x = 0; x < out_w; x++) {
+          uint32_t ix = x * m_width / width;
+
+          for (int c = 0; c < nInterleaved; c++) {
+            out_data[y * out_stride + x * nInterleaved + c] = in_data[iy * in_stride + ix * nInterleaved + c];
+          }
+        }
+      }
+    }
+  }
+  else {
+    for (const auto& component : m_planes) {
+      heif_channel channel = component.m_channel;
+      const ImageComponent& plane = component;
+
+      if (!out_img->has_channel(channel)) {
+        return {heif_error_Invalid_input, heif_suberror_Unspecified, "scaling input has extra color plane"};
+      }
+
+
+      uint32_t out_w = out_img->get_width(channel);
+      uint32_t out_h = out_img->get_height(channel);
+
+      if (plane.m_bit_depth <= 8) {
+        // SDR planar
+
+        size_t in_stride = plane.stride;
+        const auto* in_data = static_cast<const uint8_t*>(plane.mem);
+
+        size_t out_stride = 0;
+        auto* out_data = out_img->get_plane(channel, &out_stride);
+
+        for (uint32_t y = 0; y < out_h; y++) {
+          uint32_t iy = y * m_height / height;
+
+          for (uint32_t x = 0; x < out_w; x++) {
+            uint32_t ix = x * m_width / width;
+
+            out_data[y * out_stride + x] = in_data[iy * in_stride + ix];
+          }
+        }
+      }
+      else {
+        // HDR planar
+
+        size_t in_stride = plane.stride;
+        const uint16_t* in_data = static_cast<const uint16_t*>(plane.mem);
+
+        size_t out_stride = 0;
+        uint16_t* out_data = out_img->get_channel<uint16_t>(channel, &out_stride);
+
+        in_stride /= 2;
+
+        for (uint32_t y = 0; y < out_h; y++) {
+          uint32_t iy = y * m_height / height;
+
+          for (uint32_t x = 0; x < out_w; x++) {
+            uint32_t ix = x * m_width / width;
+
+            out_data[y * out_stride + x] = in_data[iy * in_stride + ix];
+          }
+        }
+      }
+    }
+  }
+
+  return Error::Ok;
+}
+
+
+void HeifPixelImage::forward_all_metadata_from(const std::shared_ptr<const HeifPixelImage>& src_image)
+{
+  // --- pass the color profiles to the new image
+
+  set_color_profile_nclx(src_image->get_color_profile_nclx());
+  set_color_profile_icc(src_image->get_color_profile_icc());
+
+  set_premultiplied_alpha(src_image->is_premultiplied_alpha());
+
+  // pass through HDR information
+  if (src_image->has_clli()) {
+    set_clli(src_image->get_clli());
+  }
+
+  if (src_image->has_mdcv()) {
+    set_mdcv(src_image->get_mdcv());
+  }
+
+  if (src_image->has_nonsquare_pixel_ratio()) {
+    uint32_t h,v;
+    src_image->get_pixel_ratio(&h,&v);
+    set_pixel_ratio(h,v);
+  }
+
+  if (src_image->has_gimi_sample_content_id()) {
+    set_gimi_sample_content_id(src_image->get_gimi_sample_content_id());
+  }
+
+  if (auto* tai = src_image->get_tai_timestamp()) {
+    set_tai_timestamp(tai);
+  }
+
+  set_sample_duration(src_image->get_sample_duration());
+
+#if HEIF_WITH_OMAF
+  set_omaf_image_projection(src_image->get_omaf_image_projection());
+#endif
+
+  // TODO: should we also forward the warnings? It might be better to do that in ImageItem_Grid.
+
+#if HEIF_WITH_OMAF
+  set_omaf_image_projection(src_image->get_omaf_image_projection());
+#endif
+}
+
+
+void HeifPixelImage::debug_dump() const
+{
+  auto channels = get_channel_set();
+  for (auto c : channels) {
+    size_t stride = 0;
+    const uint8_t* p = get_plane(c, &stride);
+
+    for (int y = 0; y < 8; y++) {
+      for (int x = 0; x < 8; x++) {
+        printf("%02x ", p[y * stride + x]);
+      }
+      printf("\n");
+    }
+  }
+}
+
+Error HeifPixelImage::create_clone_image_at_new_size(const std::shared_ptr<const HeifPixelImage>& source, uint32_t w, uint32_t h,
+                                                     const heif_security_limits* limits)
+{
+  heif_colorspace colorspace = source->get_colorspace();
+  heif_chroma chroma = source->get_chroma_format();
+
+  create(w, h, colorspace, chroma);
+
+  // Copy the cmpd component type table (needed for nonvisual/component images)
+  m_cmpd_component_types = source->m_cmpd_component_types;
+
+  for (const auto& src_plane : source->m_planes) {
+    // TODO: do we also support images where some planes (e.g. the alpha-plane) have a different size than the main image?
+    //       We could do this by scaling all planes proportionally. This would also handle chroma channels implicitly.
+    uint32_t plane_w = channel_width(w, chroma, src_plane.m_channel);
+    uint32_t plane_h = channel_height(h, chroma, src_plane.m_channel);
+
+    ImageComponent plane;
+    plane.m_channel = src_plane.m_channel;
+    plane.m_component_index = src_plane.m_component_index;
+    if (auto err = plane.alloc(plane_w, plane_h, src_plane.m_datatype, src_plane.m_bit_depth,
+                               src_plane.m_num_interleaved_components, limits, m_memory_handle)) {
+      return err;
+    }
+
+    m_planes.push_back(plane);
+  }
+
+  return Error::Ok;
+}
+
+
+Result<std::shared_ptr<HeifPixelImage>>
+HeifPixelImage::extract_image_area(uint32_t x0, uint32_t y0, uint32_t w, uint32_t h,
+                                   const heif_security_limits* limits) const
+{
+  uint32_t minW = std::min(w, get_width() - x0);
+  uint32_t minH = std::min(h, get_height() - y0);
+
+  auto areaImg = std::make_shared<HeifPixelImage>();
+  Error err = areaImg->create_clone_image_at_new_size(shared_from_this(), minW, minH, limits);
+  if (err) {
+    return err;
+  }
+
+  std::set<enum heif_channel> channels = get_channel_set();
+  heif_chroma chroma = get_chroma_format();
+
+  for (heif_channel channel : channels) {
+
+    size_t src_stride;
+    const uint8_t* src_data = get_plane(channel, &src_stride);
+
+    size_t out_stride;
+    uint8_t* out_data = areaImg->get_plane(channel, &out_stride);
+
+    if (areaImg->get_bits_per_pixel(channel) != get_bits_per_pixel(channel)) {
+      return Error{
+        heif_error_Invalid_input,
+        heif_suberror_Wrong_tile_image_pixel_depth
+      };
+    }
+
+    uint32_t xs = channel_width(x0, chroma, channel);
+    uint32_t ys = channel_height(y0, chroma, channel);
+
+    // Clamp copy size to source plane bounds to avoid chroma rounding mismatch OOB read.
+    uint32_t src_plane_h = channel_height(get_height(), chroma, channel);
+    uint32_t src_plane_w = channel_width(get_width(), chroma, channel);
+    uint32_t copy_width = std::min(channel_width(minW, chroma, channel), src_plane_w - xs);
+    uint32_t copy_height = std::min(channel_height(minH, chroma, channel), src_plane_h - ys);
+
+    copy_width *= get_storage_bits_per_pixel(channel) / 8;
+    xs *= get_storage_bits_per_pixel(channel) / 8;
+
+    for (uint32_t py = 0; py < copy_height; py++) {
+      memcpy(out_data + py * out_stride,
+             src_data + xs + (ys + py) * src_stride,
+             copy_width);
+    }
+  }
+
+  err = areaImg->extend_to_size_with_zero(w,h,limits);
+  if (err) {
+    return err;
+  }
+
+  return areaImg;
+}
+
+
+// --- index-based component access methods
+
+HeifPixelImage::ImageComponent* HeifPixelImage::find_component_by_index(uint32_t component_index)
+{
+  for (auto& plane : m_planes) {
+    // we search through all indices in case we have an interleaved plane
+    if (std::find(plane.m_component_index.begin(),
+                  plane.m_component_index.end(),
+                  component_index) != plane.m_component_index.end()) {
+      return &plane;
+    }
+  }
+  return nullptr;
+}
+
+
+const HeifPixelImage::ImageComponent* HeifPixelImage::find_component_by_index(uint32_t component_index) const
+{
+  return const_cast<HeifPixelImage*>(this)->find_component_by_index(component_index);
+}
+
+
+heif_channel HeifPixelImage::get_component_channel(uint32_t component_idx) const
+{
+  auto* comp = find_component_by_index(component_idx);
+  assert(comp);
+  return comp->m_channel;
+}
+
+
+uint32_t HeifPixelImage::get_component_width(uint32_t component_idx) const
+{
+  auto* comp = find_component_by_index(component_idx);
+  assert(comp);
+  return comp->m_width;
+}
+
+
+uint32_t HeifPixelImage::get_component_height(uint32_t component_idx) const
+{
+  auto* comp = find_component_by_index(component_idx);
+  assert(comp);
+  return comp->m_height;
+}
+
+
+uint8_t HeifPixelImage::get_component_bits_per_pixel(uint32_t component_idx) const
+{
+  auto* comp = find_component_by_index(component_idx);
+  assert(comp);
+  return comp->m_bit_depth;
+}
+
+
+uint8_t HeifPixelImage::get_component_storage_bits_per_pixel(uint32_t component_idx) const
+{
+  auto* comp = find_component_by_index(component_idx);
+  assert(comp);
+  uint32_t bpp = comp->get_bytes_per_pixel() * 8;
+  assert(bpp <= 255);
+  return static_cast<uint8_t>(bpp);
+}
+
+
+heif_channel_datatype HeifPixelImage::get_component_datatype(uint32_t component_idx) const
+{
+  auto* comp = find_component_by_index(component_idx);
+  assert(comp);
+  return comp->m_datatype;
+}
+
+
+uint16_t HeifPixelImage::get_component_type(uint32_t component_idx) const
+{
+  if (component_idx >= m_cmpd_component_types.size()) {
+    return 0;
+  }
+  return m_cmpd_component_types[component_idx];
+}
+
+
+std::vector<uint32_t> HeifPixelImage::get_component_cmpd_indices_interleaved() const
+{
+  const ImageComponent* comp = find_component_for_channel(heif_channel_interleaved);
+  assert(comp);
+  return comp->m_component_index;
+}
+
+
+Result<uint32_t> HeifPixelImage::add_component(uint32_t width, uint32_t height,
+                                               uint16_t component_type,
+                                               heif_channel_datatype datatype, int bit_depth,
+                                               const heif_security_limits* limits)
+{
+  // Auto-generate component_index by appending to cmpd table
+  uint32_t component_index = static_cast<uint32_t>(m_cmpd_component_types.size());
+  m_cmpd_component_types.push_back(component_type);
+
+  ImageComponent plane;
+  plane.m_channel = map_uncompressed_component_to_channel(component_type);
+  plane.m_component_index = std::vector{component_index};
+  if (Error err = plane.alloc(width, height, datatype, bit_depth, 1, limits, m_memory_handle)) {
+    return {err};
+  }
+
+  m_planes.push_back(plane);
+  return component_index;
+}
+
+
+Result<uint32_t> HeifPixelImage::add_component_for_index(uint32_t component_index,
+                                                          uint32_t width, uint32_t height,
+                                                          heif_channel_datatype datatype, int bit_depth,
+                                                          const heif_security_limits* limits)
+{
+  if (component_index >= m_cmpd_component_types.size()) {
+    return Error{heif_error_Usage_error, heif_suberror_Invalid_parameter_value,
+                 "component_index out of range of cmpd table"};
+  }
+
+  uint16_t component_type = m_cmpd_component_types[component_index];
+
+  ImageComponent plane;
+  plane.m_channel = map_uncompressed_component_to_channel(component_type);
+  plane.m_component_index = std::vector{component_index};
+  if (Error err = plane.alloc(width, height, datatype, bit_depth, 1, limits, m_memory_handle)) {
+    return err;
+  }
+
+  m_planes.push_back(plane);
+  return component_index;
+}
+
+
+std::vector<uint32_t> HeifPixelImage::get_used_component_indices() const
+{
+  std::vector<uint32_t> indices;
+  indices.reserve(m_planes.size());
+  for (const auto& plane : m_planes) {
+    indices.insert(indices.end(), plane.m_component_index.begin(), plane.m_component_index.end());
+  }
+  return indices;
+}
+
+
+uint8_t* HeifPixelImage::get_component(uint32_t component_idx, size_t* out_stride)
+{
+  return get_component_data<uint8_t>(component_idx, out_stride);
+}
+
+
+const uint8_t* HeifPixelImage::get_component(uint32_t component_idx, size_t* out_stride) const
+{
+  return get_component_data<uint8_t>(component_idx, out_stride);
+}
diff --git a/libheif/pixelimage.h b/libheif/pixelimage.h
new file mode 100644
index 0000000000..56c4d7f0a6
--- /dev/null
+++ b/libheif/pixelimage.h
@@ -0,0 +1,622 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef LIBHEIF_IMAGE_H
+#define LIBHEIF_IMAGE_H
+
+//#include "heif.h"
+#include "error.h"
+#include "nclx.h"
+#include <libheif/heif_experimental.h>
+#include <libheif/heif_uncompressed.h>
+#if HEIF_WITH_OMAF
+#include "omaf_boxes.h"
+#endif
+#include "security_limits.h"
+
+#include <vector>
+#include <memory>
+#include <map>
+#include <optional>
+#include <set>
+#include <utility>
+#include <cassert>
+#include <string>
+
+struct BayerPattern
+{
+  uint16_t pattern_width = 0;
+  uint16_t pattern_height = 0;
+  std::vector<heif_bayer_pattern_pixel> pixels;
+};
+
+struct PolarizationPattern
+{
+  std::vector<uint32_t> component_indices;  // empty = applies to all components
+  uint16_t pattern_width = 0;
+  uint16_t pattern_height = 0;
+  std::vector<float> polarization_angles;   // pattern_width * pattern_height entries
+                                            // 0xFFFFFFFF bit-pattern (NaN) = no polarization filter
+};
+
+struct SensorBadPixelsMap
+{
+  std::vector<uint32_t> component_indices;  // empty = applies to all components
+  bool correction_applied = false;
+  std::vector<uint32_t> bad_rows;
+  std::vector<uint32_t> bad_columns;
+  struct BadPixel { uint32_t row; uint32_t column; };
+  std::vector<BadPixel> bad_pixels;
+};
+
+struct SensorNonUniformityCorrection
+{
+  std::vector<uint32_t> component_indices;  // empty = applies to all components
+  bool nuc_is_applied = false;
+  uint32_t image_width = 0;
+  uint32_t image_height = 0;
+  std::vector<float> nuc_gains;    // image_width * image_height entries
+  std::vector<float> nuc_offsets;  // image_width * image_height entries
+};
+
+heif_chroma chroma_from_subsampling(int h, int v);
+
+uint32_t chroma_width(uint32_t w, heif_chroma chroma);
+
+uint32_t chroma_height(uint32_t h, heif_chroma chroma);
+
+uint32_t channel_width(uint32_t w, heif_chroma chroma, heif_channel channel);
+
+uint32_t channel_height(uint32_t h, heif_chroma chroma, heif_channel channel);
+
+bool is_interleaved_with_alpha(heif_chroma chroma);
+
+int num_interleaved_components_per_plane(heif_chroma chroma);
+
+bool is_integer_multiple_of_chroma_size(uint32_t width,
+                                        uint32_t height,
+                                        heif_chroma chroma);
+
+// Returns the list of valid heif_chroma values for a given colorspace.
+std::vector<heif_chroma> get_valid_chroma_values_for_colorspace(heif_colorspace colorspace);
+
+class ImageExtraData
+{
+public:
+  virtual ~ImageExtraData();
+
+  // TODO: Decide who is responsible for writing the colr boxes.
+  //       Currently it is distributed over various places.
+  //       Either here, in image_item.cc or in grid.cc.
+  std::vector<std::shared_ptr<Box>> generate_property_boxes(bool generate_colr_boxes) const;
+
+
+  // --- color profile
+
+  bool has_nclx_color_profile() const;
+
+  virtual void set_color_profile_nclx(const nclx_profile& profile) { m_color_profile_nclx = profile; }
+
+  nclx_profile get_color_profile_nclx() const { return m_color_profile_nclx; }
+
+  // get the stored nclx fallback or return the default nclx if none is stored
+  nclx_profile get_color_profile_nclx_with_fallback() const;
+
+  virtual void set_color_profile_icc(const std::shared_ptr<const color_profile_raw>& profile) { m_color_profile_icc = profile; }
+
+  bool has_icc_color_profile() const { return m_color_profile_icc != nullptr; }
+
+  const std::shared_ptr<const color_profile_raw>& get_color_profile_icc() const { return m_color_profile_icc; }
+
+  void set_color_profile(const std::shared_ptr<const color_profile>& profile)
+  {
+    auto icc = std::dynamic_pointer_cast<const color_profile_raw>(profile);
+    if (icc) {
+      set_color_profile_icc(icc);
+    }
+
+    auto nclx = std::dynamic_pointer_cast<const color_profile_nclx>(profile);
+    if (nclx) {
+      set_color_profile_nclx(nclx->get_nclx_color_profile());
+    }
+  }
+
+
+  // --- premultiplied alpha
+
+  bool is_premultiplied_alpha() const { return m_premultiplied_alpha; }
+
+  virtual void set_premultiplied_alpha(bool flag) { m_premultiplied_alpha = flag; }
+
+
+  // --- pixel aspect ratio
+
+  bool has_nonsquare_pixel_ratio() const { return m_PixelAspectRatio_h != m_PixelAspectRatio_v; }
+
+  void get_pixel_ratio(uint32_t* h, uint32_t* v) const
+  {
+    *h = m_PixelAspectRatio_h;
+    *v = m_PixelAspectRatio_v;
+  }
+
+  virtual void set_pixel_ratio(uint32_t h, uint32_t v)
+  {
+    m_PixelAspectRatio_h = h;
+    m_PixelAspectRatio_v = v;
+  }
+
+  // --- clli
+
+  bool has_clli() const { return m_clli.max_content_light_level != 0 || m_clli.max_pic_average_light_level != 0; }
+
+  heif_content_light_level get_clli() const { return m_clli; }
+
+  virtual void set_clli(const heif_content_light_level& clli) { m_clli = clli; }
+
+  // --- mdcv
+
+  bool has_mdcv() const { return m_mdcv.has_value(); }
+
+  heif_mastering_display_colour_volume get_mdcv() const { return *m_mdcv; }
+
+  virtual void set_mdcv(const heif_mastering_display_colour_volume& mdcv)
+  {
+    m_mdcv = mdcv;
+  }
+
+  void unset_mdcv() { m_mdcv.reset(); }
+
+  virtual Error set_tai_timestamp(const heif_tai_timestamp_packet* tai) {
+    delete m_tai_timestamp;
+
+    m_tai_timestamp = heif_tai_timestamp_packet_alloc();
+    heif_tai_timestamp_packet_copy(m_tai_timestamp, tai);
+    return Error::Ok;
+  }
+
+  const heif_tai_timestamp_packet* get_tai_timestamp() const {
+    return m_tai_timestamp;
+  }
+
+
+  virtual void set_gimi_sample_content_id(std::string id) { m_gimi_sample_content_id = id; }
+
+  bool has_gimi_sample_content_id() const { return m_gimi_sample_content_id.has_value(); }
+
+  std::string get_gimi_sample_content_id() const { assert(has_gimi_sample_content_id()); return *m_gimi_sample_content_id; }
+
+
+  void set_component_content_ids(const std::vector<std::string>& ids) { m_component_content_ids = ids; }
+
+  bool has_component_content_ids() const { return !m_component_content_ids.empty(); }
+
+  const std::vector<std::string>& get_component_content_ids() const { return m_component_content_ids; }
+
+
+  // --- bayer pattern
+
+  bool has_bayer_pattern() const { return m_bayer_pattern.has_value(); }
+
+  const BayerPattern& get_bayer_pattern() const { assert(has_bayer_pattern()); return *m_bayer_pattern; }
+
+  virtual void set_bayer_pattern(const BayerPattern& pattern) { m_bayer_pattern = pattern; }
+
+
+  // --- polarization pattern
+
+  bool has_polarization_patterns() const { return !m_polarization_patterns.empty(); }
+
+  const std::vector<PolarizationPattern>& get_polarization_patterns() const { return m_polarization_patterns; }
+
+  virtual void set_polarization_patterns(const std::vector<PolarizationPattern>& p) { m_polarization_patterns = p; }
+
+  virtual void add_polarization_pattern(const PolarizationPattern& p) { m_polarization_patterns.push_back(p); }
+
+
+  // --- sensor bad pixels map
+
+  bool has_sensor_bad_pixels_maps() const { return !m_sensor_bad_pixels_maps.empty(); }
+
+  const std::vector<SensorBadPixelsMap>& get_sensor_bad_pixels_maps() const { return m_sensor_bad_pixels_maps; }
+
+  virtual void set_sensor_bad_pixels_maps(const std::vector<SensorBadPixelsMap>& m) { m_sensor_bad_pixels_maps = m; }
+
+  virtual void add_sensor_bad_pixels_map(const SensorBadPixelsMap& m) { m_sensor_bad_pixels_maps.push_back(m); }
+
+
+  // --- sensor non-uniformity correction
+
+  bool has_sensor_nuc() const { return !m_sensor_nuc.empty(); }
+
+  const std::vector<SensorNonUniformityCorrection>& get_sensor_nuc() const { return m_sensor_nuc; }
+
+  virtual void set_sensor_nuc(const std::vector<SensorNonUniformityCorrection>& n) { m_sensor_nuc = n; }
+
+  virtual void add_sensor_nuc(const SensorNonUniformityCorrection& n) { m_sensor_nuc.push_back(n); }
+
+
+  // --- chroma sample location (ISO 23001-17, Section 6.1.4)
+
+  bool has_chroma_location() const { return m_chroma_location.has_value(); }
+
+  uint8_t get_chroma_location() const { return m_chroma_location.value_or(0); }
+
+  virtual void set_chroma_location(uint8_t loc) { m_chroma_location = loc; }
+
+
+#if HEIF_WITH_OMAF
+  bool has_omaf_image_projection() const {
+    return (m_omaf_image_projection != heif_omaf_image_projection_flat);
+  }
+
+  const heif_omaf_image_projection get_omaf_image_projection() const {
+    return m_omaf_image_projection;
+  }
+
+  virtual void set_omaf_image_projection(const heif_omaf_image_projection projection) {
+    m_omaf_image_projection = projection;
+  }
+#endif
+
+private:
+  bool m_premultiplied_alpha = false;
+  nclx_profile m_color_profile_nclx = nclx_profile::undefined();
+  std::shared_ptr<const color_profile_raw> m_color_profile_icc;
+
+  uint32_t m_PixelAspectRatio_h = 1;
+  uint32_t m_PixelAspectRatio_v = 1;
+  heif_content_light_level m_clli{};
+  std::optional<heif_mastering_display_colour_volume> m_mdcv;
+
+  heif_tai_timestamp_packet* m_tai_timestamp = nullptr;
+
+  std::optional<std::string> m_gimi_sample_content_id;
+
+  std::vector<std::string> m_component_content_ids;
+
+  std::optional<BayerPattern> m_bayer_pattern;
+
+  std::vector<PolarizationPattern> m_polarization_patterns;
+
+  std::vector<SensorBadPixelsMap> m_sensor_bad_pixels_maps;
+
+  std::vector<SensorNonUniformityCorrection> m_sensor_nuc;
+
+  std::optional<uint8_t> m_chroma_location;
+
+#if HEIF_WITH_OMAF
+  heif_omaf_image_projection m_omaf_image_projection = heif_omaf_image_projection::heif_omaf_image_projection_flat;
+#endif
+
+protected:
+  std::shared_ptr<Box_clli> get_clli_box() const;
+
+  std::shared_ptr<Box_mdcv> get_mdcv_box() const;
+
+  std::shared_ptr<Box_pasp> get_pasp_box() const;
+
+  std::shared_ptr<Box_colr> get_colr_box_nclx() const;
+
+  std::shared_ptr<Box_colr> get_colr_box_icc() const;
+
+#if HEIF_WITH_OMAF
+  std::shared_ptr<Box_prfr> get_prfr_box() const;
+#endif
+};
+
+
+heif_channel map_uncompressed_component_to_channel(uint16_t component_type);
+
+
+class HeifPixelImage : public std::enable_shared_from_this<HeifPixelImage>,
+                       public ImageExtraData,
+                       public ErrorBuffer
+{
+public:
+  explicit HeifPixelImage() = default;
+
+  ~HeifPixelImage() override;
+
+  void create(uint32_t width, uint32_t height, heif_colorspace colorspace, heif_chroma chroma);
+
+  Error create_clone_image_at_new_size(const std::shared_ptr<const HeifPixelImage>& source, uint32_t w, uint32_t h,
+                                       const heif_security_limits* limits);
+
+  Error add_plane(heif_channel channel, uint32_t width, uint32_t height, int bit_depth, const heif_security_limits* limits);
+
+  Error add_channel(heif_channel channel, uint32_t width, uint32_t height, heif_channel_datatype datatype, int bit_depth,
+                    const heif_security_limits* limits);
+
+  bool has_channel(heif_channel channel) const;
+
+  // Has alpha information either as a separate channel or in the interleaved format.
+  bool has_alpha() const;
+
+  uint32_t get_width() const { return m_width; }
+
+  uint32_t get_height() const { return m_height; }
+
+  uint32_t get_width(heif_channel channel) const;
+
+  uint32_t get_height(heif_channel channel) const;
+
+  uint32_t get_width(uint32_t component_idx) const;
+
+  uint32_t get_height(uint32_t component_idx) const;
+
+  bool has_odd_width() const { return !!(m_width & 1); }
+
+  bool has_odd_height() const { return !!(m_height & 1); }
+
+  // TODO: currently only defined for colorspace RGB, YCbCr, Monochrome
+  //uint32_t get_primary_width() const;
+
+  // TODO: currently only defined for colorspace RGB, YCbCr, Monochrome
+  //uint32_t get_primary_height() const;
+
+  uint32_t get_primary_component() const;
+
+  heif_chroma get_chroma_format() const { return m_chroma; }
+
+  heif_colorspace get_colorspace() const { return m_colorspace; }
+
+  std::set<heif_channel> get_channel_set() const;
+
+  uint8_t get_storage_bits_per_pixel(heif_channel channel) const;
+
+  uint8_t get_bits_per_pixel(heif_channel channel) const;
+
+  // Get the maximum bit depth of a visual channel (YCbCr or RGB).
+  uint8_t get_visual_image_bits_per_pixel() const;
+
+  heif_channel_datatype get_datatype(heif_channel channel) const;
+
+  int get_number_of_interleaved_components(heif_channel channel) const;
+
+  // Note: we are using size_t as stride type since the stride is usually involved in a multiplication with the line number.
+  //       For very large images (e.g. >2 GB), this can result in an integer overflow and corresponding illegal memory access.
+  //       (see https://github.com/strukturag/libheif/issues/1419)
+  uint8_t* get_plane(heif_channel channel, size_t* out_stride) { return get_channel<uint8_t>(channel, out_stride); }
+
+  const uint8_t* get_plane(heif_channel channel, size_t* out_stride) const { return get_channel<uint8_t>(channel, out_stride); }
+
+  template <typename T>
+  T* get_channel(heif_channel channel, size_t* out_stride)
+  {
+    auto* comp = find_component_for_channel(channel);
+    if (!comp) {
+      if (out_stride)
+        *out_stride = 0;
+
+      return nullptr;
+    }
+
+    if (out_stride) {
+      *out_stride = static_cast<int>(comp->stride / sizeof(T));
+    }
+
+    return static_cast<T*>(comp->mem);
+  }
+
+  template <typename T>
+  const T* get_channel(heif_channel channel, size_t* out_stride) const
+  {
+    return const_cast<HeifPixelImage*>(this)->get_channel<T>(channel, out_stride);
+  }
+
+
+  // --- index-based component access (for ISO 23001-17 multi-component images)
+
+  uint32_t get_number_of_used_components() const { return static_cast<uint32_t>(m_planes.size()); }
+
+  uint32_t get_total_number_of_cmpd_components() const { return static_cast<uint32_t>(m_cmpd_component_types.size()); }
+
+  heif_channel get_component_channel(uint32_t component_idx) const;
+
+  uint32_t get_component_width(uint32_t component_idx) const;
+  uint32_t get_component_height(uint32_t component_idx) const;
+  uint8_t get_component_bits_per_pixel(uint32_t component_idx) const;
+  uint8_t get_component_storage_bits_per_pixel(uint32_t component_idx) const;
+  heif_channel_datatype get_component_datatype(uint32_t component_idx) const;
+
+  // Look up the component type from the cmpd table. Works for any cmpd index,
+  // even those that have no image plane (e.g. bayer reference components).
+  uint16_t get_component_type(uint32_t component_idx) const;
+
+  std::vector<uint16_t> get_cmpd_component_types() const { return m_cmpd_component_types; }
+
+  std::vector<uint32_t> get_component_cmpd_indices_interleaved() const;
+
+  uint32_t get_component_cmpd_index() const { assert(m_cmpd_component_types.size()==1); return m_cmpd_component_types[0]; }
+
+  // Encoder path: auto-generates component_index by appending to cmpd table.
+  Result<uint32_t> add_component(uint32_t width, uint32_t height,
+                                 uint16_t component_type,
+                                 heif_channel_datatype datatype, int bit_depth,
+                                 const heif_security_limits* limits);
+
+  // Decoder path: uses a pre-populated cmpd table to look up the component type.
+  Result<uint32_t> add_component_for_index(uint32_t component_index,
+                                            uint32_t width, uint32_t height,
+                                            heif_channel_datatype datatype, int bit_depth,
+                                            const heif_security_limits* limits);
+
+  // Populate the cmpd component types table (decoder path).
+  void set_cmpd_component_types(std::vector<uint16_t> types) { m_cmpd_component_types = std::move(types); }
+
+  const std::vector<uint16_t>& get_cmpd_component_types() { return m_cmpd_component_types; }
+
+  // Returns the sorted list of component_indices of all planes that have pixel data.
+  std::vector<uint32_t> get_used_component_indices() const;
+
+  uint8_t* get_component(uint32_t component_idx, size_t* out_stride);
+  const uint8_t* get_component(uint32_t component_idx, size_t* out_stride) const;
+
+  template <typename T>
+  T* get_component_data(uint32_t component_idx, size_t* out_stride)
+  {
+    auto* comp = find_component_by_index(component_idx);
+    if (!comp) {
+      if (out_stride) *out_stride = 0;
+      return nullptr;
+    }
+
+    if (out_stride) {
+      *out_stride = comp->stride / sizeof(T);
+    }
+    return static_cast<T*>(comp->mem);
+  }
+
+  template <typename T>
+  const T* get_component_data(uint32_t component_idx, size_t* out_stride) const
+  {
+    return const_cast<HeifPixelImage*>(this)->get_component_data<T>(component_idx, out_stride);
+  }
+
+  Error copy_new_plane_from(const std::shared_ptr<const HeifPixelImage>& src_image,
+                            heif_channel src_channel,
+                            heif_channel dst_channel,
+                            const heif_security_limits* limits);
+
+  Error extract_alpha_from_RGBA(const std::shared_ptr<const HeifPixelImage>& srcimage, const heif_security_limits* limits);
+
+  void fill_plane(heif_channel dst_channel, uint16_t value);
+
+  Error fill_new_plane(heif_channel dst_channel, uint16_t value, int width, int height, int bpp, const heif_security_limits* limits);
+
+  void transfer_plane_from_image_as(const std::shared_ptr<HeifPixelImage>& source,
+                                    heif_channel src_channel,
+                                    heif_channel dst_channel);
+
+  Error copy_image_to(const std::shared_ptr<const HeifPixelImage>& source, uint32_t x0, uint32_t y0);
+
+  void zero_region(uint32_t x0, uint32_t y0, uint32_t w, uint32_t h);
+
+  Result<std::shared_ptr<HeifPixelImage>> rotate_ccw(int angle_degrees, const heif_security_limits* limits);
+
+  Result<std::shared_ptr<HeifPixelImage>> mirror_inplace(heif_transform_mirror_direction, const heif_security_limits* limits);
+
+  Result<std::shared_ptr<HeifPixelImage>> crop(uint32_t left, uint32_t right, uint32_t top, uint32_t bottom,
+                                               const heif_security_limits* limits) const;
+
+  Error fill_RGB_16bit(uint16_t r, uint16_t g, uint16_t b, uint16_t a);
+
+  Error overlay(std::shared_ptr<HeifPixelImage>& overlay, int32_t dx, int32_t dy);
+
+  Error scale_nearest_neighbor(std::shared_ptr<HeifPixelImage>& output, uint32_t width, uint32_t height,
+                               const heif_security_limits* limits) const;
+
+  void forward_all_metadata_from(const std::shared_ptr<const HeifPixelImage>& src_image);
+
+  void debug_dump() const;
+
+  Error extend_padding_to_size(uint32_t width, uint32_t height, bool adjust_size,
+                               const heif_security_limits* limits);
+
+  Error extend_to_size_with_zero(uint32_t width, uint32_t height, const heif_security_limits* limits);
+
+  Result<std::shared_ptr<HeifPixelImage>> extract_image_area(uint32_t x0, uint32_t y0, uint32_t w, uint32_t h,
+                                                             const heif_security_limits* limits) const;
+
+
+  // --- sequences
+
+  void set_sample_duration(uint32_t d) { m_sample_duration = d; }
+
+  uint32_t get_sample_duration() const { return m_sample_duration; }
+
+  // --- warnings
+
+  void add_warning(Error warning) { m_warnings.emplace_back(std::move(warning)); }
+
+  void add_warnings(const std::vector<Error>& warning) { for (const auto& err : warning) m_warnings.emplace_back(err); }
+
+  const std::vector<Error>& get_warnings() const { return m_warnings; }
+
+private:
+  struct ImageComponent
+  {
+    heif_channel m_channel = heif_channel_Y;
+
+    // index into the cmpd component definition table
+    // Interleaved channels will have a list of indices in the order R,G,B,A
+    std::vector<uint32_t> m_component_index;
+
+    // limits=nullptr disables the limits
+    Error alloc(uint32_t width, uint32_t height, heif_channel_datatype datatype, int bit_depth,
+                int num_interleaved_components,
+                const heif_security_limits* limits,
+                MemoryHandle& memory_handle);
+
+    heif_channel_datatype m_datatype = heif_channel_datatype_unsigned_integer;
+
+    // logical bit depth per component
+    // For interleaved formats, it is the number of bits for one component.
+    // It is not the storage width.
+    uint8_t m_bit_depth = 0;
+    uint8_t m_num_interleaved_components = 1;
+
+    // the "visible" area of the plane
+    uint32_t m_width = 0;
+    uint32_t m_height = 0;
+
+    // the allocated memory size
+    uint32_t m_mem_width = 0;
+    uint32_t m_mem_height = 0;
+
+    void* mem = nullptr; // aligned memory start
+    uint8_t* allocated_mem = nullptr; // unaligned memory we allocated
+    size_t   allocation_size = 0;
+    size_t   stride = 0; // bytes per line
+
+    int get_bytes_per_pixel() const;
+
+    template <typename T> void mirror_inplace(heif_transform_mirror_direction);
+
+    template<typename T>
+    void rotate_ccw(int angle_degrees, ImageComponent& out_plane) const;
+
+    void crop(uint32_t left, uint32_t right, uint32_t top, uint32_t bottom, int bytes_per_pixel, ImageComponent& out_plane) const;
+  };
+
+  ImageComponent* find_component_for_channel(heif_channel channel);
+  const ImageComponent* find_component_for_channel(heif_channel channel) const;
+
+  ImageComponent* find_component_by_index(uint32_t component_index);
+  const ImageComponent* find_component_by_index(uint32_t component_index) const;
+
+  ImageComponent new_image_plane_for_channel(heif_channel channel);
+
+  uint32_t m_width = 0;
+  uint32_t m_height = 0;
+  heif_colorspace m_colorspace = heif_colorspace_undefined;
+  heif_chroma m_chroma = heif_chroma_undefined;
+
+  std::vector<ImageComponent> m_planes;
+  std::vector<uint16_t> m_cmpd_component_types;  // indexed by cmpd index
+  MemoryHandle m_memory_handle;
+
+  uint32_t m_sample_duration = 0; // duration of a sequence frame
+
+  std::vector<Error> m_warnings;
+};
+
+#endif
diff --git a/libheif/plugin_registry.cc b/libheif/plugin_registry.cc
new file mode 100644
index 0000000000..bf1212035f
--- /dev/null
+++ b/libheif/plugin_registry.cc
@@ -0,0 +1,375 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <utility>
+#include <cstring>
+#include <algorithm>
+
+#include "plugin_registry.h"
+#include "init.h"
+
+#if HAVE_WEBCODECS
+#include "plugins/decoder_webcodecs.h"
+#endif
+
+#if HAVE_LIBDE265
+#include "plugins/decoder_libde265.h"
+#endif
+
+#if HAVE_X265
+#include "plugins/encoder_x265.h"
+#endif
+
+#if HAVE_KVAZAAR
+#include "plugins/encoder_kvazaar.h"
+#endif
+
+#if HAVE_UVG266
+#include "plugins/encoder_uvg266.h"
+#endif
+
+#if HAVE_VVDEC
+#include "plugins/decoder_vvdec.h"
+#endif
+
+#if HAVE_VVENC
+#include "plugins/encoder_vvenc.h"
+#endif
+
+#if HAVE_AOM_ENCODER
+#include "plugins/encoder_aom.h"
+#endif
+
+#if HAVE_AOM_DECODER
+#include "plugins/decoder_aom.h"
+#endif
+
+#if HAVE_RAV1E
+#include "plugins/encoder_rav1e.h"
+#endif
+
+#if HAVE_DAV1D
+#include "plugins/decoder_dav1d.h"
+#endif
+
+#if HAVE_SvtEnc
+#include "plugins/encoder_svt.h"
+#endif
+
+#if HAVE_FFMPEG_DECODER
+#include "plugins/decoder_ffmpeg.h"
+#endif
+
+#if WITH_UNCOMPRESSED_CODEC
+#include "plugins/encoder_uncompressed.h"
+#include "plugins/decoder_uncompressed.h"
+#endif
+
+#if HAVE_JPEG_DECODER
+#include "plugins/decoder_jpeg.h"
+#endif
+
+#if HAVE_JPEG_ENCODER
+#include "plugins/encoder_jpeg.h"
+#endif
+
+#if HAVE_X264
+#include "plugins/encoder_x264.h"
+#endif
+
+#if HAVE_OpenH264_DECODER
+#include "plugins/decoder_openh264.h"
+#endif
+
+#if HAVE_OPENJPEG_ENCODER
+#include "plugins/encoder_openjpeg.h"
+#endif
+
+#if HAVE_OPENJPEG_DECODER
+#include "plugins/decoder_openjpeg.h"
+#endif
+
+#include "plugins/encoder_mask.h"
+
+#if HAVE_OPENJPH_ENCODER
+#include "plugins/encoder_openjph.h"
+#endif
+
+std::set<const heif_decoder_plugin*> s_decoder_plugins;
+
+std::multiset<std::unique_ptr<heif_encoder_descriptor>,
+              encoder_descriptor_priority_order> s_encoder_descriptors;
+
+std::set<const heif_decoder_plugin*>& get_decoder_plugins()
+{
+  load_plugins_if_not_initialized_yet();
+
+  return s_decoder_plugins;
+}
+
+extern std::multiset<std::unique_ptr<heif_encoder_descriptor>,
+                     encoder_descriptor_priority_order>& get_encoder_descriptors()
+{
+  load_plugins_if_not_initialized_yet();
+
+  return s_encoder_descriptors;
+}
+
+
+// Note: we cannot move this to 'heif_init' because we have to make sure that this is initialized
+// AFTER the two global std::set above.
+static class Register_Default_Plugins
+{
+public:
+  Register_Default_Plugins()
+  {
+    register_default_plugins();
+  }
+} dummy;
+
+
+void register_default_plugins()
+{
+#if HAVE_WEBCODECS
+  register_decoder(get_decoder_plugin_webcodecs());
+#endif
+
+#if HAVE_LIBDE265
+  register_decoder(get_decoder_plugin_libde265());
+#endif
+
+#if HAVE_X265
+  register_encoder(get_encoder_plugin_x265());
+#endif
+
+#if HAVE_KVAZAAR
+  register_encoder(get_encoder_plugin_kvazaar());
+#endif
+
+#if HAVE_UVG266
+  register_encoder(get_encoder_plugin_uvg266());
+#endif
+
+#if HAVE_VVENC
+  register_encoder(get_encoder_plugin_vvenc());
+#endif
+
+#if HAVE_VVDEC
+  register_decoder(get_decoder_plugin_vvdec());
+#endif
+
+#if HAVE_AOM_ENCODER
+  register_encoder(get_encoder_plugin_aom());
+#endif
+
+#if HAVE_AOM_DECODER
+  register_decoder(get_decoder_plugin_aom());
+#endif
+
+#if HAVE_RAV1E
+  register_encoder(get_encoder_plugin_rav1e());
+#endif
+
+#if HAVE_DAV1D
+  register_decoder(get_decoder_plugin_dav1d());
+#endif
+
+#if HAVE_SvtEnc
+  register_encoder(get_encoder_plugin_svt());
+#endif
+
+#if HAVE_FFMPEG_DECODER
+  register_decoder(get_decoder_plugin_ffmpeg());
+#endif
+
+#if HAVE_JPEG_DECODER
+  register_decoder(get_decoder_plugin_jpeg());
+#endif
+
+#if HAVE_JPEG_ENCODER
+  register_encoder(get_encoder_plugin_jpeg());
+#endif
+
+#if HAVE_OPENJPEG_ENCODER
+  register_encoder(get_encoder_plugin_openjpeg());
+#endif
+
+#if HAVE_OPENJPEG_DECODER
+  register_decoder(get_decoder_plugin_openjpeg());
+#endif
+
+#if HAVE_OPENJPH_ENCODER
+  register_encoder(get_encoder_plugin_openjph());
+#endif
+
+#if HAVE_OpenH264_DECODER
+  register_decoder(get_decoder_plugin_openh264());
+#endif
+
+#if HAVE_X264
+  register_encoder(get_encoder_plugin_x264());
+#endif
+
+#if WITH_UNCOMPRESSED_CODEC
+  register_encoder(get_encoder_plugin_uncompressed());
+  register_decoder(get_decoder_plugin_uncompressed());
+#endif
+
+  register_encoder(get_encoder_plugin_mask());
+}
+
+
+void register_decoder(const heif_decoder_plugin* decoder_plugin)
+{
+  if (decoder_plugin->init_plugin) {
+    (*decoder_plugin->init_plugin)();
+  }
+
+  s_decoder_plugins.insert(decoder_plugin);
+}
+
+
+bool has_decoder(heif_compression_format type, const char* name_id)
+{
+  load_plugins_if_not_initialized_yet();
+
+  for (const auto* plugin : s_decoder_plugins) {
+    int priority = plugin->does_support_format(type);
+    if (priority > 0 && strcmp(name_id, plugin->id_name) == 0) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+
+const heif_decoder_plugin* get_decoder(heif_compression_format type, const char* name_id)
+{
+  load_plugins_if_not_initialized_yet();
+
+  int highest_priority = 0;
+  const struct heif_decoder_plugin* best_plugin = nullptr;
+
+  for (const auto* plugin : s_decoder_plugins) {
+
+    int priority = plugin->does_support_format(type);
+
+    if (priority > 0 && name_id && plugin->plugin_api_version >= 3) {
+      if (strcmp(name_id, plugin->id_name) == 0) {
+        return plugin;
+      }
+    }
+
+    if (priority > highest_priority) {
+      highest_priority = priority;
+      best_plugin = plugin;
+    }
+  }
+
+  return best_plugin;
+}
+
+
+void register_encoder(const heif_encoder_plugin* encoder_plugin)
+{
+  if (encoder_plugin->init_plugin) {
+    (*encoder_plugin->init_plugin)();
+  }
+
+  auto descriptor = std::unique_ptr<heif_encoder_descriptor>(new heif_encoder_descriptor);
+  descriptor->plugin = encoder_plugin;
+
+  s_encoder_descriptors.insert(std::move(descriptor));
+}
+
+
+const heif_encoder_plugin* get_encoder(heif_compression_format type)
+{
+  auto filtered_encoder_descriptors = get_filtered_encoder_descriptors(type, nullptr);
+  if (filtered_encoder_descriptors.size() > 0) {
+    return filtered_encoder_descriptors[0]->plugin;
+  }
+  else {
+    return nullptr;
+  }
+}
+
+
+std::vector<const heif_encoder_descriptor*>
+get_filtered_encoder_descriptors(heif_compression_format format,
+                                 const char* name)
+{
+  load_plugins_if_not_initialized_yet();
+
+  std::vector<const heif_encoder_descriptor*> filtered_descriptors;
+
+  for (const auto& descr : s_encoder_descriptors) {
+    const heif_encoder_plugin* plugin = descr->plugin;
+
+    if (plugin->compression_format == format || format == heif_compression_undefined) {
+      if (name == nullptr || strcmp(name, plugin->id_name) == 0) {
+        filtered_descriptors.push_back(descr.get());
+      }
+    }
+  }
+
+
+  // Note: since our std::set<> is ordered by priority, we do not have to sort our output
+
+  return filtered_descriptors;
+}
+
+
+void heif_unregister_decoder_plugins()
+{
+  for (const auto* plugin : s_decoder_plugins) {
+    if (plugin->deinit_plugin) {
+      (*plugin->deinit_plugin)();
+    }
+  }
+  s_decoder_plugins.clear();
+}
+
+void heif_unregister_encoder_plugins()
+{
+  for (const auto& plugin : s_encoder_descriptors) {
+    if (plugin->plugin->cleanup_plugin) {
+      (*plugin->plugin->cleanup_plugin)();
+    }
+  }
+  s_encoder_descriptors.clear();
+}
+
+#if ENABLE_PLUGIN_LOADING
+void heif_unregister_encoder_plugin(const heif_encoder_plugin* plugin)
+{
+  if (plugin->cleanup_plugin) {
+    (*plugin->cleanup_plugin)();
+  }
+
+  for (auto iter = s_encoder_descriptors.begin() ; iter != s_encoder_descriptors.end(); ++iter) {
+    if ((*iter)->plugin == plugin) {
+      s_encoder_descriptors.erase(iter);
+      return;
+    }
+  }
+}
+#endif
diff --git a/libheif/plugin_registry.h b/libheif/plugin_registry.h
new file mode 100644
index 0000000000..8255b79306
--- /dev/null
+++ b/libheif/plugin_registry.h
@@ -0,0 +1,85 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_PLUGIN_REGISTRY_H
+#define LIBHEIF_PLUGIN_REGISTRY_H
+
+#include <map>
+#include <memory>
+#include <set>
+#include <string>
+#include <vector>
+
+#include "error.h"
+
+#include "libheif/heif.h"
+#include "libheif/heif_plugin.h"
+
+
+struct heif_encoder_descriptor
+{
+  const heif_encoder_plugin* plugin;
+
+  const char* get_name() const { return plugin->get_plugin_name(); }
+
+  heif_compression_format get_compression_format() const { return plugin->compression_format; }
+};
+
+
+struct encoder_descriptor_priority_order
+{
+  bool operator()(const std::unique_ptr<heif_encoder_descriptor>& a,
+                  const std::unique_ptr<heif_encoder_descriptor>& b) const
+  {
+    return a->plugin->priority > b->plugin->priority;  // highest priority first
+  }
+};
+
+
+extern std::set<const heif_decoder_plugin*>& get_decoder_plugins();
+
+extern std::multiset<std::unique_ptr<heif_encoder_descriptor>,
+                     encoder_descriptor_priority_order>& get_encoder_descriptors();
+
+void register_default_plugins();
+
+void register_decoder(const heif_decoder_plugin* decoder_plugin);
+
+void register_encoder(const heif_encoder_plugin* encoder_plugin);
+
+void heif_unregister_decoder_plugins();
+
+void heif_unregister_encoder_plugins();
+
+#if ENABLE_PLUGIN_LOADING
+void heif_unregister_encoder_plugin(const heif_encoder_plugin* plugin);
+#endif
+
+bool has_decoder(heif_compression_format type, const char* name_id);
+
+const heif_decoder_plugin* get_decoder(heif_compression_format type, const char* name_id);
+
+const heif_encoder_plugin* get_encoder(heif_compression_format type);
+
+std::vector<const heif_encoder_descriptor*>
+get_filtered_encoder_descriptors(heif_compression_format,
+                                 const char* name);
+
+#endif
diff --git a/libheif/plugins/CMakeLists.txt b/libheif/plugins/CMakeLists.txt
new file mode 100644
index 0000000000..47d807276b
--- /dev/null
+++ b/libheif/plugins/CMakeLists.txt
@@ -0,0 +1,145 @@
+
+macro(plugin_compilation name varName foundName optionName defineName)
+    if (${foundName} AND WITH_${optionName})
+        if (PLUGIN_LOADING_SUPPORTED_AND_ENABLED AND WITH_${optionName}_PLUGIN)
+            message("Compiling '" ${name} "' as dynamic plugin")
+            add_library(heif-${name}
+                    MODULE ${${optionName}_sources} ${${optionName}_extra_plugin_sources}
+                    ../api/libheif/heif_plugin.cc
+                    )
+            if (NOT APPLE)
+                set_target_properties(heif-${name}
+                        PROPERTIES
+                        VERSION ${PROJECT_VERSION}
+                        SOVERSION ${PROJECT_VERSION_MAJOR})
+            endif ()
+            target_compile_definitions(heif-${name}
+                    PUBLIC
+                    LIBHEIF_EXPORTS
+                    HAVE_VISIBILITY)
+            target_compile_definitions(heif-${name} PRIVATE PLUGIN_${defineName}=1)
+            target_include_directories(heif-${name} PRIVATE ${PROJECT_SOURCE_DIR} ${libheif_BINARY_DIR} ${libheif_SOURCE_DIR}/libheif ${libheif_SOURCE_DIR}/libheif/api ${${varName}_INCLUDE_DIRS})
+            target_link_libraries(heif-${name} PRIVATE ${${varName}_LIBRARIES} heif)
+
+            install(TARGETS heif-${name}
+                    LIBRARY DESTINATION ${COMPUTED_PLUGIN_INSTALL_DIRECTORY}
+                    )
+        else ()
+            message("Compiling '" ${name} "' as built-in backend")
+            target_sources(heif PRIVATE ${${optionName}_sources})
+            target_compile_definitions(heif PRIVATE HAVE_${defineName}=1)
+            target_include_directories(heif PRIVATE ${${varName}_INCLUDE_DIRS})
+            target_link_directories(heif PRIVATE ${${varName}_LINK_DIRS})
+            if (${varName}_DEBUG_LIBRARY)
+                target_link_libraries(heif PRIVATE debug ${${varName}_DEBUG_LIBRARY})
+                target_link_libraries(heif PRIVATE optimized ${${varName}_LIBRARIES})
+            else()
+                target_link_libraries(heif PRIVATE ${${varName}_LIBRARIES})
+            endif()
+        endif ()
+
+        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${${varName}_CFLAGS}")
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${${varName}_CFLAGS}")
+    else()
+        message("Not compiling '" ${name} "' backend")
+    endif ()
+endmacro()
+
+set(X265_sources encoder_x265.h encoder_x265.cc)
+set(X265_extra_plugin_sources)
+plugin_compilation(x265 X265 X265_FOUND X265 X265)
+
+set(LIBDE265_sources decoder_libde265.cc decoder_libde265.h)
+set(LIBDE265_extra_plugin_sources ../error.cc)
+plugin_compilation(libde265 LIBDE265 LIBDE265_FOUND LIBDE265 LIBDE265)
+
+set(DAV1D_sources decoder_dav1d.cc decoder_dav1d.h)
+set(DAV1D_extra_plugin_sources ../error.cc ../common_utils.cc ../common_utils.h)
+plugin_compilation(dav1d DAV1D DAV1D_FOUND DAV1D DAV1D)
+
+set(AOM_DECODER_sources decoder_aom.cc decoder_aom.h)
+set(AOM_DECODER_extra_plugin_sources)
+plugin_compilation(aomdec AOM AOM_DECODER_FOUND AOM_DECODER AOM_DECODER)
+
+set(AOM_ENCODER_sources encoder_aom.cc encoder_aom.h)
+set(AOM_ENCODER_extra_plugin_sources ../error.cc ../common_utils.cc ../common_utils.h)
+plugin_compilation(aomenc AOM AOM_ENCODER_FOUND AOM_ENCODER AOM_ENCODER)
+
+set(SvtEnc_sources encoder_svt.cc encoder_svt.h)
+set(SvtEnc_extra_plugin_sources ../error.cc ../common_utils.cc ../common_utils.h)
+plugin_compilation(svtenc SvtEnc SvtEnc_FOUND SvtEnc SvtEnc)
+
+set(RAV1E_sources encoder_rav1e.cc encoder_rav1e.h)
+set(RAV1E_extra_plugin_sources ../error.cc)
+plugin_compilation(rav1e RAV1E RAV1E_FOUND RAV1E RAV1E)
+
+set(JPEG_DECODER_sources decoder_jpeg.cc decoder_jpeg.h)
+set(JPEG_DECODER_extra_plugin_sources)
+plugin_compilation(jpegdec JPEG JPEG_FOUND JPEG_DECODER JPEG_DECODER)
+
+set(JPEG_ENCODER_sources encoder_jpeg.cc encoder_jpeg.h)
+set(JPEG_ENCODER_extra_plugin_sources)
+plugin_compilation(jpegenc JPEG JPEG_FOUND JPEG_ENCODER JPEG_ENCODER)
+
+set(OpenJPEG_DECODER_sources decoder_openjpeg.cc decoder_openjpeg.h)
+set(OpenJPEG_DECODER_extra_plugin_sources ) 
+plugin_compilation(j2kdec OPENJPEG OPENJPEG_FOUND OpenJPEG_DECODER OPENJPEG_DECODER)
+
+set(OpenJPEG_ENCODER_sources encoder_openjpeg.cc encoder_openjpeg.h)
+set(OpenJPEG_ENCODER_extra_plugin_sources)
+plugin_compilation(j2kenc OPENJPEG OPENJPEG_FOUND OpenJPEG_ENCODER OPENJPEG_ENCODER)
+
+set(KVAZAAR_sources encoder_kvazaar.cc encoder_kvazaar.h)
+set(KVAZAAR_extra_plugin_sources)
+plugin_compilation(kvazaar KVAZAAR KVAZAAR_FOUND KVAZAAR KVAZAAR)
+
+set(FFMPEG_DECODER_sources decoder_ffmpeg.cc decoder_ffmpeg.h)
+set(FFMPEG_DECODER_extra_plugin_sources ../error.cc nalu_utils.cc)
+plugin_compilation(ffmpegdec FFMPEG FFMPEG_FOUND FFMPEG_DECODER FFMPEG_DECODER)
+
+set(OPENJPH_ENCODER_sources encoder_openjph.cc encoder_openjph.h)
+set(OPENJPH_ENCODER_extra_plugin_sources)
+plugin_compilation(jphenc OPENJPH OPENJPH_FOUND OPENJPH_ENCODER OPENJPH_ENCODER)
+
+set(UVG266_sources encoder_uvg266.cc encoder_uvg266.h)
+set(UVG266_extra_plugin_sources)
+plugin_compilation(uvg266 UVG266 UVG266_FOUND UVG266 UVG266)
+
+set(VVDEC_sources decoder_vvdec.cc decoder_vvdec.h)
+set(VVDEC_extra_plugin_sources)
+plugin_compilation(vvdec vvdec vvdec_FOUND VVDEC VVDEC)
+
+set(VVENC_sources encoder_vvenc.cc encoder_vvenc.h)
+set(VVENC_extra_plugin_sources)
+plugin_compilation(vvenc vvenc vvenc_FOUND VVENC VVENC)
+
+set(X264_sources encoder_x264.h encoder_x264.cc)
+set(X264_extra_plugin_sources)
+plugin_compilation(x264 X264 X264_FOUND X264 X264)
+
+set(OpenH264_DECODER_sources decoder_openh264.cc decoder_openh264.h)
+set(OpenH264_DECODER_extra_plugin_sources)
+plugin_compilation(openh264dec OpenH264 OpenH264_DECODER_FOUND OpenH264_DECODER OpenH264_DECODER)
+
+target_sources(heif PRIVATE
+               encoder_mask.h
+               encoder_mask.cc
+               nalu_utils.h
+               nalu_utils.cc)
+
+if (WITH_UNCOMPRESSED_CODEC)
+    target_sources(heif PRIVATE
+            encoder_uncompressed.h
+            encoder_uncompressed.cc
+            decoder_uncompressed.h
+            decoder_uncompressed.cc)
+endif ()
+
+if (WITH_WEBCODECS)
+   target_sources(heif PRIVATE
+   		  decoder_webcodecs.h
+		  decoder_webcodecs.cc)
+   target_compile_definitions(heif PRIVATE HAVE_WEBCODECS=1)
+endif()
+
+
diff --git a/libheif/plugins/decoder_aom.cc b/libheif/plugins/decoder_aom.cc
new file mode 100644
index 0000000000..2db724a1ff
--- /dev/null
+++ b/libheif/plugins/decoder_aom.cc
@@ -0,0 +1,444 @@
+/*
+ * AVIF codec.
+ * Copyright (c) 2019 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "libheif/heif.h"
+#include "libheif/heif_plugin.h"
+#include "decoder_aom.h"
+#include <memory>
+#include <cstring>
+#include <cassert>
+#include <deque>
+#include <string>
+
+#include <aom/aom_decoder.h>
+#include <aom/aomdx.h>
+
+
+struct aom_decoder
+{
+  ~aom_decoder()
+  {
+    // --- free images that are still in the output queue
+
+    for (auto& pkt : output_queue) {
+      if (pkt.img) {
+        heif_image_release(pkt.img);
+      }
+    }
+  }
+
+  aom_codec_ctx_t codec;
+  bool codec_initialized = false;
+
+  aom_codec_iface_t* iface;
+
+  struct Packet
+  {
+    heif_image* img;
+    uintptr_t user_data = 0;
+  };
+
+  std::deque<Packet> output_queue;
+  bool strict_decoding = false;
+  std::string error_message;
+};
+
+static const char kSuccess[] = "Success";
+static const char kEmptyString[] = "";
+
+static const int AOM_PLUGIN_PRIORITY = 100;
+
+#define MAX_PLUGIN_NAME_LENGTH 80
+
+static char plugin_name[MAX_PLUGIN_NAME_LENGTH];
+
+
+static const char* aom_plugin_name()
+{
+  if (strlen(aom_codec_iface_name(aom_codec_av1_dx())) < MAX_PLUGIN_NAME_LENGTH) {
+    strcpy(plugin_name, aom_codec_iface_name(aom_codec_av1_dx()));
+  }
+  else {
+    strcpy(plugin_name, "AOMedia AV1 decoder");
+  }
+
+  return plugin_name;
+}
+
+
+static void aom_init_plugin()
+{
+}
+
+
+static void aom_deinit_plugin()
+{
+}
+
+
+static int aom_does_support_format(heif_compression_format format)
+{
+  if (format == heif_compression_AV1) {
+    return AOM_PLUGIN_PRIORITY;
+  }
+  else {
+    return 0;
+  }
+}
+
+static int aom_does_support_format2(const heif_decoder_plugin_compressed_format_description* format)
+{
+  return aom_does_support_format(format->format);
+}
+
+heif_error aom_new_decoder2(void** dec, const heif_decoder_plugin_options* options)
+{
+  aom_decoder* decoder = new aom_decoder();
+
+  decoder->iface = aom_codec_av1_dx();
+
+  aom_codec_dec_cfg_t cfg{};
+
+  if (options->num_threads) {
+    cfg.threads = options->num_threads;
+  }
+  cfg.w = 0;
+  cfg.h = 0;
+  cfg.allow_lowbitdepth = 1;
+
+  aom_codec_err_t aomerr = aom_codec_dec_init(&decoder->codec, decoder->iface, &cfg, 0);
+  if (aomerr) {
+    *dec = NULL;
+
+    delete decoder;
+
+    heif_error err = {heif_error_Decoder_plugin_error, heif_suberror_Unspecified, aom_codec_err_to_string(aomerr)};
+    return err;
+  }
+
+  decoder->codec_initialized = true;
+  *dec = decoder;
+
+  heif_error err = {heif_error_Ok, heif_suberror_Unspecified, kSuccess};
+  return err;
+}
+
+
+heif_error aom_new_decoder(void** dec)
+{
+  heif_decoder_plugin_options options;
+  options.format = heif_compression_AV1;
+  options.strict_decoding = false;
+  options.num_threads = 0;
+
+  return aom_new_decoder2(dec, &options);
+}
+
+void aom_free_decoder(void* decoder_raw)
+{
+  aom_decoder* decoder = (aom_decoder*) decoder_raw;
+
+  if (!decoder) {
+    return;
+  }
+
+  if (decoder->codec_initialized) {
+    aom_codec_destroy(&decoder->codec);
+    decoder->codec_initialized = false;
+  }
+
+  delete decoder;
+}
+
+
+void aom_set_strict_decoding(void* decoder_raw, int flag)
+{
+  aom_decoder* decoder = (aom_decoder*) decoder_raw;
+
+  decoder->strict_decoding = flag;
+}
+
+
+static heif_error get_next_image_from_decoder(aom_decoder* decoder,
+                                              aom_codec_iter_t* inout_iter,
+                                              heif_image** out_img,
+                                              uintptr_t* out_user_data,
+                                              const heif_security_limits* limits)
+{
+  aom_image_t* img = aom_codec_get_frame(&decoder->codec, inout_iter);
+
+  if (img == NULL) {
+    *out_img = NULL;
+    return {};
+  }
+
+  if (out_user_data) {
+    *out_user_data = (uintptr_t)img->user_priv;
+  }
+
+  /*
+  if (img == NULL) {
+    return {
+      heif_error_Decoder_plugin_error,
+      heif_suberror_Unspecified,
+      kEmptyString
+    };
+  }
+*/
+
+  if (img->fmt != AOM_IMG_FMT_I420 &&
+      img->fmt != AOM_IMG_FMT_I42016 &&
+      img->fmt != AOM_IMG_FMT_I422 &&
+      img->fmt != AOM_IMG_FMT_I42216 &&
+      img->fmt != AOM_IMG_FMT_I444 &&
+      img->fmt != AOM_IMG_FMT_I44416) {
+    return {
+      heif_error_Decoder_plugin_error,
+      heif_suberror_Unsupported_image_type,
+      kEmptyString
+    };
+  }
+
+  heif_chroma chroma;
+  heif_colorspace colorspace;
+
+  if (img->monochrome) {
+      chroma = heif_chroma_monochrome;
+      colorspace = heif_colorspace_monochrome;
+  }
+  else {
+    if (img->fmt == AOM_IMG_FMT_I444 ||
+        img->fmt == AOM_IMG_FMT_I44416) {
+      chroma = heif_chroma_444;
+    }
+    else if (img->fmt == AOM_IMG_FMT_I422 ||
+             img->fmt == AOM_IMG_FMT_I42216) {
+      chroma = heif_chroma_422;
+    }
+    else {
+      chroma = heif_chroma_420;
+    }
+    colorspace = heif_colorspace_YCbCr;
+  }
+
+  heif_image* heif_img = nullptr;
+  heif_error err = heif_image_create(img->d_w, img->d_h,
+                                     colorspace,
+                                     chroma,
+                                     &heif_img);
+  if (err.code != heif_error_Ok) {
+    assert(heif_img==nullptr);
+    return err;
+  }
+
+
+  // --- read nclx parameters from decoded AV1 bitstream
+
+  heif_color_profile_nclx nclx;
+  nclx.version = 1;
+  HEIF_WARN_OR_FAIL(decoder->strict_decoding, heif_img, heif_nclx_color_profile_set_color_primaries(&nclx, static_cast<uint16_t>(img->cp)), { heif_image_release(heif_img); });
+  HEIF_WARN_OR_FAIL(decoder->strict_decoding, heif_img, heif_nclx_color_profile_set_transfer_characteristics(&nclx, static_cast<uint16_t>(img->tc)), { heif_image_release(heif_img); });
+  HEIF_WARN_OR_FAIL(decoder->strict_decoding, heif_img, heif_nclx_color_profile_set_matrix_coefficients(&nclx, static_cast<uint16_t>(img->mc)), { heif_image_release(heif_img); });
+  nclx.full_range_flag = (img->range == AOM_CR_FULL_RANGE);
+  heif_image_set_nclx_color_profile(heif_img, &nclx);
+
+
+  // --- transfer data from aom_image_t to HeifPixelImage
+
+  heif_channel channel2plane[3] = {
+      heif_channel_Y,
+      heif_channel_Cb,
+      heif_channel_Cr
+  };
+
+
+  int num_planes = (chroma == heif_chroma_monochrome ? 1 : 3);
+
+  for (int c = 0; c < num_planes; c++) {
+    int bpp = img->bit_depth;
+
+    const uint8_t* data = img->planes[c];
+    int stride = img->stride[c];
+
+    int w = img->d_w;
+    int h = img->d_h;
+
+    if (c > 0 && chroma == heif_chroma_420) {
+      w = (w + 1) / 2;
+      h = (h + 1) / 2;
+    }
+    else if (c > 0 && chroma == heif_chroma_422) {
+      w = (w + 1) / 2;
+    }
+
+    err = heif_image_add_plane_safe(heif_img, channel2plane[c], w, h, bpp, limits);
+    if (err.code != heif_error_Ok) {
+      // copy error message to decoder object because heif_image will be released
+      decoder->error_message = err.message;
+      err.message = decoder->error_message.c_str();
+
+      heif_image_release(heif_img);
+      return err;
+    }
+
+    size_t dst_stride;
+    uint8_t* dst_mem = heif_image_get_plane2(heif_img, channel2plane[c], &dst_stride);
+
+    int bytes_per_pixel = (bpp + 7) / 8;
+
+    for (int y = 0; y < h; y++) {
+      memcpy(dst_mem + y * dst_stride, data + y * stride, w * bytes_per_pixel);
+    }
+  }
+
+  *out_img = heif_img;
+  return err;
+}
+
+
+
+heif_error aom_push_data2(void* decoder_raw, const void* frame_data, size_t frame_size, uintptr_t user_data)
+{
+  aom_decoder* decoder = (struct aom_decoder*) decoder_raw;
+
+  const char* ver = aom_codec_version_str();
+  (void)ver;
+
+  aom_codec_err_t aomerr;
+  aomerr = aom_codec_decode(&decoder->codec, (const uint8_t*) frame_data, frame_size, (void*)user_data);
+  if (aomerr) {
+    heif_error err = {heif_error_Invalid_input, heif_suberror_Unspecified, aom_codec_err_to_string(aomerr)};
+    return err;
+  }
+
+
+  // --- decode images and fill into output queue
+
+  aom_codec_iter_t iter = NULL;
+  for (;;) {
+    heif_image* img;
+    uintptr_t out_user_data;
+    heif_error err = get_next_image_from_decoder(decoder, &iter, &img, &out_user_data, nullptr); // TODO: send limits);
+    if (err.code) {
+      return err;
+    }
+
+    if (img) {
+      decoder->output_queue.push_back({img, out_user_data});
+    }
+    else {
+      break;
+    }
+  }
+
+  heif_error err = {heif_error_Ok, heif_suberror_Unspecified, kSuccess};
+  return err;
+}
+
+
+heif_error aom_push_data(void* decoder_raw, const void* frame_data, size_t frame_size)
+{
+  return aom_push_data2(decoder_raw, frame_data, frame_size, 0);
+}
+
+
+static heif_error aom_decode_next_image2(void* decoder_raw, heif_image** out_img,
+                                         uintptr_t* out_user_data,
+                                         const heif_security_limits* limits)
+{
+  aom_decoder* decoder = (struct aom_decoder*) decoder_raw;
+
+  // --- if there are images in the output queue, pass them back
+
+  if (!decoder->output_queue.empty()) {
+    if (out_user_data) {
+      *out_user_data = decoder->output_queue.front().user_data;
+    }
+
+    heif_image* next_image = decoder->output_queue.front().img;
+    decoder->output_queue.pop_front();
+
+    *out_img = next_image;
+    return {};
+  }
+  else {
+    *out_img = nullptr;
+    return {};
+  }
+}
+
+
+static heif_error aom_decode_next_image(void* decoder_raw, heif_image** out_img,
+                                        const heif_security_limits* limits)
+{
+  return aom_decode_next_image2(decoder_raw, out_img, nullptr, limits);
+}
+
+heif_error aom_decode_image(void* decoder_raw, heif_image** out_img)
+{
+  auto* limits = heif_get_global_security_limits();
+  return aom_decode_next_image(decoder_raw, out_img, limits);
+}
+
+
+static heif_error aom_flush_data(void* decoder_raw)
+{
+  // aom_decoder* decoder = (aom_decoder*) decoder_raw;
+
+  return heif_error_ok;
+}
+
+
+static const heif_decoder_plugin decoder_aom
+    {
+        5,
+        aom_plugin_name,
+        aom_init_plugin,
+        aom_deinit_plugin,
+        aom_does_support_format,
+        aom_new_decoder,
+        aom_free_decoder,
+        aom_push_data,
+        aom_decode_image,
+        aom_set_strict_decoding,
+        "aom",
+        aom_decode_next_image,
+        /* minimum_required_libheif_version */ LIBHEIF_MAKE_VERSION(1,21,0),
+        aom_does_support_format2,
+        aom_new_decoder2,
+        aom_push_data2,
+        aom_flush_data,
+        aom_decode_next_image2
+    };
+
+
+const heif_decoder_plugin* get_decoder_plugin_aom()
+{
+  return &decoder_aom;
+}
+
+
+#if PLUGIN_AOM_DECODER
+heif_plugin_info plugin_info {
+  1,
+  heif_plugin_type_decoder,
+  &decoder_aom
+};
+#endif
diff --git a/libheif/heif_decoder_aom.h b/libheif/plugins/decoder_aom.h
similarity index 75%
rename from libheif/heif_decoder_aom.h
rename to libheif/plugins/decoder_aom.h
index 3b1a151409..23ed80b9eb 100644
--- a/libheif/heif_decoder_aom.h
+++ b/libheif/plugins/decoder_aom.h
@@ -1,6 +1,6 @@
 /*
  * HEIF codec.
- * Copyright (c) 2017 struktur AG, Dirk Farin <farin@struktur.de>
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
  *
  * This file is part of libheif.
  *
@@ -18,9 +18,17 @@
  * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef LIBHEIF_HEIF_DECODER_AOM_H
-#define LIBHEIF_HEIF_DECODER_AOM_H
+#ifndef LIBHEIF_DECODER_AOM_H
+#define LIBHEIF_DECODER_AOM_H
+
+#include "common_utils.h"
 
 const struct heif_decoder_plugin* get_decoder_plugin_aom();
 
+#if PLUGIN_AOM_DECODER
+extern "C" {
+MAYBE_UNUSED LIBHEIF_API extern heif_plugin_info plugin_info;
+}
+#endif
+
 #endif
diff --git a/libheif/plugins/decoder_dav1d.cc b/libheif/plugins/decoder_dav1d.cc
new file mode 100644
index 0000000000..8502f1c5da
--- /dev/null
+++ b/libheif/plugins/decoder_dav1d.cc
@@ -0,0 +1,451 @@
+/*
+ * AVIF codec.
+ * Copyright (c) 2020 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "libheif/heif.h"
+#include "libheif/heif_plugin.h"
+#include "security_limits.h"
+#include "common_utils.h"
+#include "decoder_dav1d.h"
+#include <cstring>
+#include <cassert>
+#include <cstdio>
+#include <deque>
+#include <limits>
+#include <string>
+
+#include <dav1d/version.h>
+#include <dav1d/dav1d.h>
+
+
+struct dav1d_decoder
+{
+  Dav1dSettings settings{};
+  Dav1dContext* context{};
+  std::deque<Dav1dData> queued_data;
+  bool strict_decoding = false;
+  std::string error_message;
+};
+
+static constexpr char kEmptyString[] = "";
+static constexpr char kSuccess[] = "Success";
+
+static constexpr int DAV1D_PLUGIN_PRIORITY = 150;
+
+#define MAX_PLUGIN_NAME_LENGTH 80
+
+static char plugin_name[MAX_PLUGIN_NAME_LENGTH];
+
+
+static const char* dav1d_plugin_name()
+{
+  snprintf(plugin_name, MAX_PLUGIN_NAME_LENGTH, "dav1d v%d.%d.%d",
+           DAV1D_API_VERSION_MAJOR,
+           DAV1D_API_VERSION_MINOR,
+           DAV1D_API_VERSION_PATCH);
+
+  // make sure that the string is null-terminated
+  plugin_name[MAX_PLUGIN_NAME_LENGTH - 1] = 0;
+
+  return plugin_name;
+}
+
+
+static void dav1d_init_plugin()
+{
+}
+
+
+static void dav1d_deinit_plugin()
+{
+}
+
+
+static int dav1d_does_support_format(heif_compression_format format)
+{
+  if (format == heif_compression_AV1) {
+    return DAV1D_PLUGIN_PRIORITY;
+  }
+  else {
+    return 0;
+  }
+}
+
+
+static int dav1d_does_support_format2(const heif_decoder_plugin_compressed_format_description* format)
+{
+  return dav1d_does_support_format(format->format);
+}
+
+heif_error dav1d_new_decoder2(void** dec, const heif_decoder_plugin_options* options)
+{
+  auto* decoder = new dav1d_decoder();
+
+  dav1d_default_settings(&decoder->settings);
+
+  if (heif_get_global_security_limits()->max_image_size_pixels > std::numeric_limits<unsigned int>::max()) {
+    decoder->settings.frame_size_limit = 0;
+  }
+  else {
+    decoder->settings.frame_size_limit = static_cast<unsigned int>(heif_get_global_security_limits()->max_image_size_pixels);
+  }
+
+  decoder->settings.all_layers = 0;
+
+  if (options->num_threads) {
+    decoder->settings.n_threads = options->num_threads;
+  }
+
+  if (dav1d_open(&decoder->context, &decoder->settings) != 0) {
+    delete decoder;
+    return {heif_error_Decoder_plugin_error, heif_suberror_Unspecified, kSuccess};
+  }
+
+  *dec = decoder;
+
+  return heif_error_ok;
+}
+
+heif_error dav1d_new_decoder(void** dec)
+{
+  struct heif_decoder_plugin_options options;
+  options.format = heif_compression_AV1;
+  options.strict_decoding = false;
+  options.num_threads = 0;
+
+  return dav1d_new_decoder2(dec, &options);
+}
+
+void dav1d_free_decoder(void* decoder_raw)
+{
+  auto* decoder = (dav1d_decoder*) decoder_raw;
+
+  if (!decoder) {
+    return;
+  }
+
+  // free queued data
+
+  for (auto& pkt : decoder->queued_data) {
+    dav1d_data_unref(&pkt);
+  }
+  decoder->queued_data.clear();
+
+  // free decoder context
+
+  if (decoder->context) {
+    dav1d_close(&decoder->context);
+  }
+
+  delete decoder;
+}
+
+
+void dav1d_set_strict_decoding(void* decoder_raw, int flag)
+{
+  dav1d_decoder* decoder = (dav1d_decoder*) decoder_raw;
+
+  decoder->strict_decoding = flag;
+}
+
+
+static heif_error push_pending_data_into_decoder(dav1d_decoder* decoder)
+{
+  while (!decoder->queued_data.empty()) {
+
+    // send data
+
+    int res = dav1d_send_data(decoder->context, &decoder->queued_data.front());
+
+    // decoder does not accept more data at this moment
+
+    if (res == DAV1D_ERR(EAGAIN)) {
+      break;
+    }
+
+    // Decoder has accepted data. Remove packet and check for error.
+
+    decoder->queued_data.pop_front();
+
+    if ((res < 0) && (res != DAV1D_ERR(EAGAIN))) {
+      return {
+        heif_error_Decoder_plugin_error,
+        heif_suberror_Unspecified,
+        kEmptyString
+      };
+    }
+  }
+
+  return heif_error_ok;
+}
+
+
+heif_error dav1d_push_data2(void* decoder_raw, const void* frame_data, size_t frame_size, uintptr_t user_data)
+{
+  auto* decoder = (struct dav1d_decoder*) decoder_raw;
+
+  // --- copy input data into Dav1dData packet
+
+  Dav1dData packet{};
+
+  uint8_t* d = dav1d_data_create(&packet, frame_size);
+  if (d == nullptr) {
+    return {heif_error_Memory_allocation_error, heif_suberror_Unspecified, kSuccess};
+  }
+
+  memcpy(d, frame_data, frame_size);
+
+  packet.m.user_data.data = (uint8_t*)user_data;
+
+  // --- put data into queue
+
+  decoder->queued_data.push_back(packet);
+
+  // --- push pending data to decoder
+
+  return push_pending_data_into_decoder(decoder);
+}
+
+
+heif_error dav1d_push_data(void* decoder_raw, const void* frame_data, size_t frame_size)
+{
+  return dav1d_push_data2(decoder_raw, frame_data, frame_size, 0);
+}
+
+
+heif_error dav1d_decode_next_image2(void* decoder_raw, heif_image** out_img,
+                                    uintptr_t* out_user_data,
+                                    const heif_security_limits* limits)
+{
+  auto* decoder = (struct dav1d_decoder*) decoder_raw;
+
+  heif_error err;
+
+  Dav1dPicture frame{};
+
+  for (;;) {
+
+    // --- send more pending data to decoder
+
+    err = push_pending_data_into_decoder(decoder);
+    if (err.code) {
+      return err;
+    }
+
+    // --- try to get decoded image
+
+    int res = dav1d_get_picture(decoder->context, &frame);
+
+    // We got a picture from the decoder. Continue with processing it.
+    if (res == 0) {
+      break;
+    }
+
+    // decoder wants more data, but queue is empty
+    if (res == DAV1D_ERR(EAGAIN) && decoder->queued_data.empty()) {
+      *out_img = nullptr;
+      return heif_error_ok;
+    }
+
+    // continue feeding more data from queue
+    if (res == DAV1D_ERR(EAGAIN)) {
+      continue;
+    }
+
+    // decoder error
+    if (res < 0) {
+      return {
+        heif_error_Decoder_plugin_error,
+        heif_suberror_Unspecified,
+        kEmptyString
+      };
+    }
+  }
+
+  // --- convert image to heif_image
+
+  heif_chroma chroma;
+  heif_colorspace colorspace;
+  switch (frame.p.layout) {
+    case DAV1D_PIXEL_LAYOUT_I420:
+      chroma = heif_chroma_420;
+      colorspace = heif_colorspace_YCbCr;
+      break;
+    case DAV1D_PIXEL_LAYOUT_I422:
+      chroma = heif_chroma_422;
+      colorspace = heif_colorspace_YCbCr;
+      break;
+    case DAV1D_PIXEL_LAYOUT_I444:
+      chroma = heif_chroma_444;
+      colorspace = heif_colorspace_YCbCr;
+      break;
+    case DAV1D_PIXEL_LAYOUT_I400:
+      chroma = heif_chroma_monochrome;
+      colorspace = heif_colorspace_monochrome;
+      break;
+    default: {
+      return {
+        heif_error_Decoder_plugin_error,
+        heif_suberror_Unspecified,
+        kEmptyString
+      };
+    }
+  }
+
+  if (out_user_data) {
+    *out_user_data = (uintptr_t)frame.m.user_data.data;
+  }
+
+  heif_image* heif_img = nullptr;
+  err = heif_image_create(frame.p.w, frame.p.h,
+                          colorspace,
+                          chroma,
+                          &heif_img);
+  if (err.code != heif_error_Ok) {
+    assert(heif_img == nullptr);
+    return err;
+  }
+
+
+  // --- read nclx parameters from decoded AV1 bitstream
+
+  heif_color_profile_nclx nclx;
+  HEIF_WARN_OR_FAIL(decoder->strict_decoding, heif_img, heif_nclx_color_profile_set_color_primaries(&nclx, static_cast<uint16_t>(frame.seq_hdr->pri)), {});
+  HEIF_WARN_OR_FAIL(decoder->strict_decoding, heif_img, heif_nclx_color_profile_set_transfer_characteristics(&nclx, static_cast<uint16_t>(frame.seq_hdr->trc)), {});
+  HEIF_WARN_OR_FAIL(decoder->strict_decoding, heif_img, heif_nclx_color_profile_set_matrix_coefficients(&nclx, static_cast<uint16_t>(frame.seq_hdr->mtrx)), {});
+  nclx.full_range_flag = (frame.seq_hdr->color_range != 0);
+  heif_image_set_nclx_color_profile(heif_img, &nclx);
+
+
+  heif_channel channel2plane[3] = {
+      heif_channel_Y,
+      heif_channel_Cb,
+      heif_channel_Cr
+  };
+
+
+  // --- copy image data
+
+  int num_planes = (chroma == heif_chroma_monochrome ? 1 : 3);
+
+  for (int c = 0; c < num_planes; c++) {
+    int bpp = frame.p.bpc;
+
+    const uint8_t* data = (uint8_t*) frame.data[c];
+    int stride = (int) frame.stride[c > 0 ? 1 : 0];
+
+    uint32_t w, h;
+    get_subsampled_size(frame.p.w, frame.p.h,
+                        channel2plane[c], chroma, &w, &h);
+
+    err = heif_image_add_plane_safe(heif_img, channel2plane[c], w, h, bpp, limits);
+    if (err.code != heif_error_Ok) {
+      // copy error message to decoder object because heif_image will be released
+      decoder->error_message = err.message;
+      err.message = decoder->error_message.c_str();
+
+      heif_image_release(heif_img);
+      return err;
+    }
+
+    size_t dst_stride;
+    uint8_t* dst_mem = heif_image_get_plane2(heif_img, channel2plane[c], &dst_stride);
+
+    const int bytes_per_pixel = (bpp + 7) / 8;
+
+    for (uint32_t y = 0; y < h; y++) {
+      memcpy(dst_mem + y * dst_stride, data + y * stride, w * bytes_per_pixel);
+    }
+  }
+
+  dav1d_picture_unref(&frame);
+
+  *out_img = heif_img;
+
+
+  return {heif_error_Ok, heif_suberror_Unspecified, kSuccess};
+}
+
+
+heif_error dav1d_decode_next_image(void* decoder_raw, heif_image** out_img,
+                                   const heif_security_limits* limits)
+{
+  return dav1d_decode_next_image2(decoder_raw, out_img, nullptr, limits);
+}
+
+
+heif_error dav1d_decode_image(void* decoder_raw, struct heif_image** out_img)
+{
+  auto* limits = heif_get_global_security_limits();
+  return dav1d_decode_next_image(decoder_raw, out_img, limits);
+}
+
+
+heif_error dav1d_flush_data(void* decoder_raw)
+{
+  auto* decoder = (struct dav1d_decoder*) decoder_raw;
+
+  constexpr Dav1dData packet{}; // empty packet
+
+  // --- put data into queue
+
+  decoder->queued_data.push_back(packet);
+
+  // --- push pending data to decoder
+
+  return push_pending_data_into_decoder(decoder);
+}
+
+
+static const heif_decoder_plugin decoder_dav1d
+    {
+        5,
+        dav1d_plugin_name,
+        dav1d_init_plugin,
+        dav1d_deinit_plugin,
+        dav1d_does_support_format,
+        dav1d_new_decoder,
+        dav1d_free_decoder,
+        dav1d_push_data,
+        dav1d_decode_image,
+        dav1d_set_strict_decoding,
+        "dav1d",
+        dav1d_decode_next_image,
+        /* minimum_required_libheif_version */ LIBHEIF_MAKE_VERSION(1,21,0),
+        dav1d_does_support_format2,
+        dav1d_new_decoder2,
+        dav1d_push_data2,
+        dav1d_flush_data,
+        dav1d_decode_next_image2
+    };
+
+
+const heif_decoder_plugin* get_decoder_plugin_dav1d()
+{
+  return &decoder_dav1d;
+}
+
+
+#if PLUGIN_DAV1D
+heif_plugin_info plugin_info {
+  1,
+  heif_plugin_type_decoder,
+  &decoder_dav1d
+};
+#endif
diff --git a/libheif/heif_decoder_dav1d.h b/libheif/plugins/decoder_dav1d.h
similarity index 75%
rename from libheif/heif_decoder_dav1d.h
rename to libheif/plugins/decoder_dav1d.h
index fe872e477e..e32d8b4ff2 100644
--- a/libheif/heif_decoder_dav1d.h
+++ b/libheif/plugins/decoder_dav1d.h
@@ -1,6 +1,6 @@
 /*
  * HEIF codec.
- * Copyright (c) 2017 struktur AG, Dirk Farin <farin@struktur.de>
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
  *
  * This file is part of libheif.
  *
@@ -18,9 +18,17 @@
  * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef LIBHEIF_HEIF_DECODER_DAV1D_H
-#define LIBHEIF_HEIF_DECODER_DAV1D_H
+#ifndef LIBHEIF_DECODER_DAV1D_H
+#define LIBHEIF_DECODER_DAV1D_H
+
+#include "common_utils.h"
 
 const struct heif_decoder_plugin* get_decoder_plugin_dav1d();
 
+#if PLUGIN_DAV1D
+extern "C" {
+MAYBE_UNUSED LIBHEIF_API extern heif_plugin_info plugin_info;
+}
+#endif
+
 #endif
diff --git a/libheif/plugins/decoder_ffmpeg.cc b/libheif/plugins/decoder_ffmpeg.cc
new file mode 100644
index 0000000000..22e1bb33ae
--- /dev/null
+++ b/libheif/plugins/decoder_ffmpeg.cc
@@ -0,0 +1,668 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "libheif/heif.h"
+#include "libheif/heif_plugin.h"
+#include "decoder_ffmpeg.h"
+#include "nalu_utils.h"
+#include <string>
+
+#if defined(HAVE_CONFIG_H)
+#include "config.h"
+#endif
+
+
+#include <deque>
+#include <iostream>
+#include <memory>
+#include <utility>
+#include <vector>
+
+extern "C"
+{
+    #include <libavcodec/avcodec.h>
+}
+
+
+struct ffmpeg_decoder
+{
+  // --- input data
+
+  struct Packet
+  {
+    std::vector<uint8_t> data;
+    uintptr_t user_data;
+  };
+
+  std::deque<Packet> input_data;
+  bool strict_decoding = false;
+
+  // --- decoder
+
+  const AVCodec* av_codec = NULL;
+  AVCodecParserContext* av_codec_parser_context = NULL;
+  AVCodecContext* av_codec_context = NULL;
+
+  std::string error_message;
+
+  ~ffmpeg_decoder()
+  {
+    if (av_codec_parser_context) av_parser_close(av_codec_parser_context);
+    if (av_codec_context) avcodec_free_context(&av_codec_context);
+  }
+};
+
+static const int FFMPEG_DECODER_PLUGIN_PRIORITY = 90;
+
+#define MAX_PLUGIN_NAME_LENGTH 80
+
+static char plugin_name[MAX_PLUGIN_NAME_LENGTH];
+
+
+static const char* ffmpeg_plugin_name()
+{
+  snprintf(plugin_name, MAX_PLUGIN_NAME_LENGTH, "FFMPEG AVC/HEVC decoder %s", av_version_info());
+  plugin_name[MAX_PLUGIN_NAME_LENGTH - 1] = 0; //null-terminated
+
+  return plugin_name;
+}
+
+
+static void ffmpeg_init_plugin()
+{
+
+}
+
+
+static void ffmpeg_deinit_plugin()
+{
+
+}
+
+
+static int ffmpeg_does_support_format(heif_compression_format format)
+{
+  // TODO: it should work at least also for AV1 and JPEG. Check why it isn't decoding.
+
+  if (format == heif_compression_HEVC) {
+    return FFMPEG_DECODER_PLUGIN_PRIORITY;
+  }
+  else if (format == heif_compression_AVC) {
+    return FFMPEG_DECODER_PLUGIN_PRIORITY;
+  }
+#if 0
+  else if (format == heif_compression_VVC) {
+    return FFMPEG_DECODER_PLUGIN_PRIORITY;
+  }
+  else if (format == heif_compression_AV1) {
+    return FFMPEG_DECODER_PLUGIN_PRIORITY;
+  }
+  else if (format == heif_compression_JPEG) {
+    return FFMPEG_DECODER_PLUGIN_PRIORITY;
+  }
+  else if (format == heif_compression_JPEG2000 ||
+           format == heif_compression_HTJ2K) {
+    return FFMPEG_DECODER_PLUGIN_PRIORITY;
+  }
+#endif
+  else {
+    return 0;
+  }
+}
+
+
+static int ffmpeg_does_support_format2(const heif_decoder_plugin_compressed_format_description* format)
+{
+  return ffmpeg_does_support_format(format->format);
+}
+
+static heif_error ffmpeg_new_decoder2(void** dec, const heif_decoder_plugin_options* options)
+{
+  ffmpeg_decoder* decoder = new ffmpeg_decoder();
+  *dec = decoder;
+
+  // Find matching video decoder
+  switch (options->format) {
+    case heif_compression_AVC:
+      decoder->av_codec = avcodec_find_decoder(AV_CODEC_ID_H264);
+      break;
+    case heif_compression_HEVC:
+      decoder->av_codec = avcodec_find_decoder(AV_CODEC_ID_HEVC);
+      break;
+#if 0
+    case heif_compression_VVC:
+      decoder->av_codec = avcodec_find_decoder(AV_CODEC_ID_VVC);
+      break;
+    case heif_compression_AV1:
+      decoder->av_codec = avcodec_find_decoder(AV_CODEC_ID_AV1);
+      break;
+    case heif_compression_JPEG:
+      decoder->av_codec = avcodec_find_decoder(AV_CODEC_ID_MJPEG);
+      break;
+    case heif_compression_JPEG2000:
+    case heif_compression_HTJ2K:
+      decoder->av_codec = avcodec_find_decoder(AV_CODEC_ID_JPEG2000);
+      break;
+#endif
+    default:
+      assert(false);
+      return {
+        heif_error_Invalid_input,
+        heif_suberror_Unspecified,
+        "FFMPEG plugin started with unsupported codec."
+      };
+  }
+
+  if (!decoder->av_codec) {
+    return { heif_error_Decoder_plugin_error, heif_suberror_Unspecified, "avcodec_find_decoder() returned error" };
+  }
+
+  decoder->av_codec_parser_context = av_parser_init(decoder->av_codec->id);
+  if (!decoder->av_codec_parser_context) {
+    return { heif_error_Decoder_plugin_error, heif_suberror_Unspecified, "av_parser_init returned error" };
+  }
+
+  decoder->av_codec_context = avcodec_alloc_context3(decoder->av_codec);
+  if (!decoder->av_codec_context) {
+    return { heif_error_Memory_allocation_error, heif_suberror_Unspecified, "avcodec_alloc_context3 returned error" };
+  }
+
+  /* open it */
+  if (avcodec_open2(decoder->av_codec_context, decoder->av_codec, NULL) < 0) {
+    return { heif_error_Decoder_plugin_error, heif_suberror_Unspecified, "avcodec_open2 returned error" };
+  }
+
+
+  return heif_error_success;
+}
+
+static heif_error ffmpeg_new_decoder(void** dec)
+{
+  heif_decoder_plugin_options options;
+  options.format = heif_compression_HEVC;
+  options.num_threads = 0;
+  options.strict_decoding = false;
+
+  return ffmpeg_new_decoder2(dec, &options);
+}
+
+static void ffmpeg_free_decoder(void* decoder_raw)
+{
+  ffmpeg_decoder* decoder = (struct ffmpeg_decoder*) decoder_raw;
+
+  delete decoder;
+}
+
+
+void ffmpeg_set_strict_decoding(void* decoder_raw, int flag)
+{
+  ffmpeg_decoder* decoder = (ffmpeg_decoder*) decoder_raw;
+
+  decoder->strict_decoding = flag;
+}
+
+static heif_error ffmpeg_push_data2(void *decoder_raw, const void *data, size_t size, uintptr_t user_data)
+{
+  ffmpeg_decoder* decoder = (struct ffmpeg_decoder*) decoder_raw;
+
+  const uint8_t* cdata = (const uint8_t*) data;
+
+  ffmpeg_decoder::Packet pkt;
+
+  size_t ptr = 0;
+  while (ptr < size)
+  {
+    if (size - ptr < 4) {
+      return {
+        heif_error_Decoder_plugin_error,
+        heif_suberror_End_of_data,
+        "insufficient data"
+      };
+    }
+
+    uint32_t nal_size = four_bytes_to_uint32(cdata[ptr + 0],
+                                             cdata[ptr + 1],
+                                             cdata[ptr + 2],
+                                             cdata[ptr + 3]);
+    ptr += 4;
+
+    if (nal_size > size - ptr) {
+      return {
+        heif_error_Decoder_plugin_error,
+        heif_suberror_End_of_data,
+        "insufficient data"
+      };
+    }
+
+    pkt.data.push_back(0);
+    pkt.data.push_back(0);
+    pkt.data.push_back(1);
+    pkt.data.insert(pkt.data.end(), cdata + ptr, cdata + ptr + nal_size);
+
+    ptr += nal_size;
+  }
+
+  pkt.user_data = user_data;
+
+  decoder->input_data.emplace_back(std::move(pkt));
+
+  return heif_error_success;
+}
+
+static heif_error ffmpeg_push_data(void *decoder_raw, const void *data, size_t size)
+{
+  return ffmpeg_push_data2(decoder_raw, data, size, 0);
+}
+
+
+static heif_chroma ffmpeg_get_chroma_format(AVPixelFormat pix_fmt) {
+  switch (pix_fmt) {
+    case AV_PIX_FMT_GRAY8:
+    case AV_PIX_FMT_GRAY10LE:
+      return heif_chroma_monochrome;
+
+    case AV_PIX_FMT_YUV420P:
+    case AV_PIX_FMT_YUVJ420P:
+    case AV_PIX_FMT_YUV420P10LE:
+    case AV_PIX_FMT_YUV420P12LE:
+    case AV_PIX_FMT_YUV420P14LE:
+    case AV_PIX_FMT_YUV420P16LE:
+      return heif_chroma_420;
+
+    case AV_PIX_FMT_YUV422P:
+    case AV_PIX_FMT_YUV422P10LE:
+    case AV_PIX_FMT_YUV422P12LE:
+    case AV_PIX_FMT_YUV422P14LE:
+    case AV_PIX_FMT_YUV422P16LE:
+      return heif_chroma_422;
+
+    case AV_PIX_FMT_YUV444P:
+    case AV_PIX_FMT_YUV444P10LE:
+    case AV_PIX_FMT_YUV444P12LE:
+    case AV_PIX_FMT_YUV444P14LE:
+    case AV_PIX_FMT_YUV444P16LE:
+      return heif_chroma_444;
+
+    default:
+      // Unsupported pix_fmt
+      return heif_chroma_undefined;
+  }
+}
+
+static int ffmpeg_get_chroma_width(const AVFrame* frame, heif_channel channel, heif_chroma chroma)
+{
+    if (channel == heif_channel_Y)
+    {
+        return frame->width;
+    }
+    else if (chroma == heif_chroma_420 || chroma == heif_chroma_422)
+    {
+        return (frame->width + 1) / 2;
+    }
+    else
+    {
+        return frame->width;
+    }
+}
+
+static int ffmpeg_get_chroma_height(const AVFrame* frame, heif_channel channel, heif_chroma chroma)
+{
+    if (channel == heif_channel_Y)
+    {
+        return frame->height;
+    }
+    else if (chroma == heif_chroma_420)
+    {
+        return (frame->height + 1) / 2;
+    }
+    else
+    {
+        return frame->height;
+    }
+}
+
+static int get_ffmpeg_format_bpp(AVPixelFormat pix_fmt)
+{
+  switch (pix_fmt) {
+    case AV_PIX_FMT_GRAY8:
+    case AV_PIX_FMT_YUV420P:
+    case AV_PIX_FMT_YUVJ420P:
+    case AV_PIX_FMT_YUV422P:
+    case AV_PIX_FMT_YUV444P:
+      return 8;
+    case AV_PIX_FMT_GRAY10LE:
+    case AV_PIX_FMT_YUV420P10LE:
+    case AV_PIX_FMT_YUV422P10LE:
+    case AV_PIX_FMT_YUV444P10LE:
+      return 10;
+    case AV_PIX_FMT_GRAY12LE:
+    case AV_PIX_FMT_YUV420P12LE:
+    case AV_PIX_FMT_YUV422P12LE:
+    case AV_PIX_FMT_YUV444P12LE:
+      return 12;
+    case AV_PIX_FMT_GRAY14LE:
+    case AV_PIX_FMT_YUV420P14LE:
+    case AV_PIX_FMT_YUV422P14LE:
+    case AV_PIX_FMT_YUV444P14LE:
+      return 14;
+    case AV_PIX_FMT_GRAY16LE:
+    case AV_PIX_FMT_YUV420P16LE:
+    case AV_PIX_FMT_YUV422P16LE:
+    case AV_PIX_FMT_YUV444P16LE:
+      return 16;
+    default:
+      return 0;
+  }
+}
+
+static heif_error ffmpeg_av_decode(ffmpeg_decoder* decoder, AVCodecContext* av_dec_ctx, AVFrame* av_frame, heif_image** image,
+                                   uintptr_t* out_user_data,
+                                   const heif_security_limits* limits)
+{
+  int ret;
+
+  ret = avcodec_receive_frame(av_dec_ctx, av_frame);
+  if (ret == AVERROR(EAGAIN) || ret == AVERROR(AVERROR_EOF)) {
+    *image = nullptr;
+    return heif_error_ok;
+  }
+
+  if (ret < 0) {
+    return {heif_error_Decoder_plugin_error, heif_suberror_Unspecified, "Error in avcodec_receive_frame"};
+  }
+
+  if (out_user_data) {
+    *out_user_data = av_frame->pts;
+  }
+
+  heif_chroma chroma = ffmpeg_get_chroma_format(av_dec_ctx->pix_fmt);
+  if (chroma != heif_chroma_undefined) {
+    bool is_mono = (chroma == heif_chroma_monochrome);
+
+    heif_error err;
+    err = heif_image_create(av_frame->width,
+                            av_frame->height,
+                            is_mono ? heif_colorspace_monochrome : heif_colorspace_YCbCr,
+                            chroma,
+                            image);
+    if (err.code) {
+      return err;
+    }
+
+    heif_channel channel2plane[3] = {
+      heif_channel_Y,
+      heif_channel_Cb,
+      heif_channel_Cr
+    };
+
+    int nPlanes = is_mono ? 1 : 3;
+
+    for (int channel = 0; channel < nPlanes; channel++) {
+      int bpp = get_ffmpeg_format_bpp(av_dec_ctx->pix_fmt);
+      if (bpp == 0) {
+        heif_image_release(*image);
+        err = {
+          heif_error_Decoder_plugin_error,
+          heif_suberror_Unsupported_color_conversion,
+          "Pixel format not implemented"
+        };
+        return err;
+      }
+
+      int stride = av_frame->linesize[channel];
+      const uint8_t* data = av_frame->data[channel];
+
+      int w = ffmpeg_get_chroma_width(av_frame, channel2plane[channel], chroma);
+      int h = ffmpeg_get_chroma_height(av_frame, channel2plane[channel], chroma);
+      if (w <= 0 || h <= 0) {
+        heif_image_release(*image);
+        err = {
+          heif_error_Decoder_plugin_error,
+          heif_suberror_Invalid_image_size,
+          "invalid image size"
+        };
+        return err;
+      }
+
+      err = heif_image_add_plane_safe(*image, channel2plane[channel], w, h, bpp, limits);
+      if (err.code) {
+        // copy error message to decoder object because heif_image will be released
+        decoder->error_message = err.message;
+        err.message = decoder->error_message.c_str();
+
+        heif_image_release(*image);
+        return err;
+      }
+
+      size_t dst_stride;
+      uint8_t* dst_mem = heif_image_get_plane2(*image, channel2plane[channel], &dst_stride);
+
+      int bytes_per_pixel = (bpp + 7) / 8;
+
+      for (int y = 0; y < h; y++) {
+        memcpy(dst_mem + y * dst_stride, data + y * stride, w * bytes_per_pixel);
+      }
+    }
+
+    return heif_error_success;
+  }
+  else {
+    return {
+      heif_error_Unsupported_feature,
+      heif_suberror_Unsupported_color_conversion,
+      "Pixel format not implemented"
+    };
+  }
+}
+
+static heif_error ffmpeg_decode_next_image2(void* decoder_raw,
+                                            heif_image** out_img,
+                                            uintptr_t* out_user_data,
+                                            const heif_security_limits* limits)
+{
+  ffmpeg_decoder* decoder = (ffmpeg_decoder*) decoder_raw;
+
+  AVPacket* av_pkt = NULL;
+  AVFrame* av_frame = NULL;
+  AVCodecParameters* av_codecParam = NULL;
+  heif_color_profile_nclx* nclx = NULL;
+  int ret = 0;
+
+  heif_error err = heif_error_success;
+
+  if (!decoder->input_data.empty()) {
+    uint8_t* parse_av_data = NULL;
+    int parse_av_data_size = 0;
+
+    ffmpeg_decoder::Packet& first_pkt = decoder->input_data.front();
+
+    if (first_pkt.data.empty()) {
+      // send 'flush' packet
+      int ret = avcodec_send_packet(decoder->av_codec_context, nullptr);
+      if (ret < 0) {
+        return {heif_error_Decoder_plugin_error, heif_suberror_Unspecified, "Error in avcodec_send_packet"};
+      }
+
+      decoder->input_data.pop_front();
+    }
+    else {
+      av_pkt = av_packet_alloc();
+      auto pkt_deleter = std::unique_ptr<AVPacket, void (*)(AVPacket*)>(av_pkt, [](AVPacket* pkt){av_packet_free(&pkt);});
+
+      if (!av_pkt) {
+        return { heif_error_Memory_allocation_error, heif_suberror_Unspecified, "av_packet_alloc returned error" };
+      }
+
+      parse_av_data = first_pkt.data.data();
+      parse_av_data_size = (int) first_pkt.data.size();
+      size_t n_bytes_consumed = 0;
+
+      while (parse_av_data_size > 0) {
+        decoder->av_codec_parser_context->flags = PARSER_FLAG_COMPLETE_FRAMES;
+        ret = av_parser_parse2(decoder->av_codec_parser_context, decoder->av_codec_context, &av_pkt->data, &av_pkt->size,
+                               parse_av_data, parse_av_data_size,
+                               AV_NOPTS_VALUE, AV_NOPTS_VALUE, 0);
+        if (ret < 0) {
+          return {heif_error_Decoder_plugin_error, heif_suberror_Unspecified, "av_parser_parse2 returned error"};
+        }
+
+        // std::cout << "decode packet of size: " << ret << "\n";
+
+        parse_av_data += ret;
+        parse_av_data_size -= ret;
+        n_bytes_consumed += ret;
+
+        if (av_pkt->size) {
+          av_pkt->pts = first_pkt.user_data;
+
+          ret = avcodec_send_packet(decoder->av_codec_context, av_pkt);
+          if (ret < 0) {
+            char buf[100];
+            av_make_error_string(buf, 100, ret);
+            return {heif_error_Decoder_plugin_error, heif_suberror_Unspecified, "Error in avcodec_send_packet"};
+          }
+        }
+        else {
+          break;
+        }
+      }
+
+      if (n_bytes_consumed == first_pkt.data.size()) {
+        decoder->input_data.pop_front();
+      }
+      else {
+        if (n_bytes_consumed > 0) {
+          memmove(first_pkt.data.data(), first_pkt.data.data() + n_bytes_consumed,
+                  first_pkt.data.size() - n_bytes_consumed);
+          decoder->input_data.resize(decoder->input_data.size() - n_bytes_consumed);
+        }
+      }
+    }
+  }
+
+  //uint8_t nal_type = (decoder->input_data.front().data[3] >> 1);
+
+  av_frame = av_frame_alloc();
+  auto frame_deleter = std::unique_ptr<AVFrame, void (*)(AVFrame*)>(av_frame, [](AVFrame* frame){av_frame_free(&frame);});
+
+  if (!av_frame) {
+    return { heif_error_Memory_allocation_error, heif_suberror_Unspecified, "av_frame_alloc returned error" };
+  }
+
+  err = ffmpeg_av_decode(decoder, decoder->av_codec_context, av_frame, out_img, out_user_data, limits);
+  if (err.code != heif_error_Ok)
+    return err;
+
+  if (*out_img == nullptr) {
+    return heif_error_ok;
+  }
+
+  av_codecParam = avcodec_parameters_alloc();
+  auto param_deleter = std::unique_ptr<AVCodecParameters, void (*)(AVCodecParameters*)>(av_codecParam, [](AVCodecParameters* params){avcodec_parameters_free(&params);});
+
+  if (!av_codecParam) {
+    return { heif_error_Memory_allocation_error, heif_suberror_Unspecified, "avcodec_parameters_alloc returned error" };
+  }
+  if (avcodec_parameters_from_context(av_codecParam, decoder->av_codec_context) < 0)
+  {
+    return { heif_error_Decoder_plugin_error, heif_suberror_Unspecified, "avcodec_parameters_from_context returned error" };
+  }
+
+  uint8_t video_full_range_flag = 0;
+  uint8_t color_primaries = 0;
+  uint8_t transfer_characteristics = 0;
+  uint8_t matrix_coefficients = 0;
+
+  video_full_range_flag = (av_codecParam->color_range == AVCOL_RANGE_JPEG) ? 1 : 0;
+  color_primaries = av_codecParam->color_primaries;
+  transfer_characteristics = av_codecParam->color_trc;
+  matrix_coefficients = av_codecParam->color_space;
+
+  nclx = heif_nclx_color_profile_alloc();
+  auto nclx_deleter = std::unique_ptr<heif_color_profile_nclx, void (*)(heif_color_profile_nclx*)>(nclx, [](heif_color_profile_nclx* nclx){heif_nclx_color_profile_free(nclx);});
+
+  heif_nclx_color_profile_set_color_primaries(nclx, static_cast<uint16_t>(color_primaries));
+  heif_nclx_color_profile_set_transfer_characteristics(nclx, static_cast<uint16_t>(transfer_characteristics));
+  heif_nclx_color_profile_set_matrix_coefficients(nclx, static_cast<uint16_t>(matrix_coefficients));
+  nclx->full_range_flag = (bool)video_full_range_flag;
+  heif_image_set_nclx_color_profile(*out_img, nclx);
+
+  return heif_error_ok;
+}
+
+static heif_error ffmpeg_decode_next_image(void* decoder_raw,
+                                            heif_image** out_img,
+                                            const heif_security_limits* limits)
+{
+  return ffmpeg_decode_next_image2(decoder_raw, out_img, nullptr, limits);
+}
+
+
+static heif_error ffmpeg_decode_image(void* decoder_raw,
+                                         heif_image** out_img)
+{
+  auto* limits = heif_get_global_security_limits();
+  return ffmpeg_decode_next_image(decoder_raw, out_img, limits);
+}
+
+heif_error ffmpeg_flush_data(void* decoder_raw)
+{
+  auto* decoder = (struct ffmpeg_decoder*) decoder_raw;
+
+  decoder->input_data.push_back({});
+
+  return heif_error_ok;
+}
+
+
+static const heif_decoder_plugin decoder_ffmpeg
+    {
+        5,
+        ffmpeg_plugin_name,
+        ffmpeg_init_plugin,
+        ffmpeg_deinit_plugin,
+        ffmpeg_does_support_format,
+        ffmpeg_new_decoder,
+        ffmpeg_free_decoder,
+        ffmpeg_push_data,
+        ffmpeg_decode_image,
+        ffmpeg_set_strict_decoding,
+        "ffmpeg",
+        ffmpeg_decode_next_image,
+        /* minimum_required_libheif_version */ LIBHEIF_MAKE_VERSION(1,21,0),
+        ffmpeg_does_support_format2,
+        ffmpeg_new_decoder2,
+        ffmpeg_push_data2,
+        ffmpeg_flush_data,
+        ffmpeg_decode_next_image2
+    };
+
+const heif_decoder_plugin* get_decoder_plugin_ffmpeg()
+{
+  return &decoder_ffmpeg;
+}
+
+#if PLUGIN_FFMPEG_DECODER
+heif_plugin_info plugin_info{
+  1,
+  heif_plugin_type_decoder,
+  &decoder_ffmpeg
+};
+#endif
diff --git a/libheif/plugins/decoder_ffmpeg.h b/libheif/plugins/decoder_ffmpeg.h
new file mode 100644
index 0000000000..d4ee87bf79
--- /dev/null
+++ b/libheif/plugins/decoder_ffmpeg.h
@@ -0,0 +1,34 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_HEIF_DECODER_FFMPEG_H
+#define LIBHEIF_HEIF_DECODER_FFMPEG_H
+
+#include "common_utils.h"
+
+const struct heif_decoder_plugin* get_decoder_plugin_ffmpeg();
+
+#if PLUGIN_FFMPEG_DECODER
+extern "C" {
+	MAYBE_UNUSED LIBHEIF_API extern heif_plugin_info plugin_info;
+}
+#endif
+
+#endif
diff --git a/libheif/plugins/decoder_jpeg.cc b/libheif/plugins/decoder_jpeg.cc
new file mode 100644
index 0000000000..7d07cfd00c
--- /dev/null
+++ b/libheif/plugins/decoder_jpeg.cc
@@ -0,0 +1,467 @@
+/*
+ * JPEG codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "libheif/heif.h"
+#include "libheif/heif_plugin.h"
+#include "decoder_jpeg.h"
+#include <memory>
+#include <cstring>
+#include <cassert>
+#include <csetjmp>
+#include <vector>
+#include <cstdio>
+#include <string>
+
+extern "C" {
+#include <jpeglib.h>
+}
+
+
+struct jpeg_decoder
+{
+  std::vector<uint8_t> data;
+  uintptr_t user_data;
+
+  std::string error_message;
+};
+
+static const char kSuccess[] = "Success";
+
+static const int JPEG_PLUGIN_PRIORITY = 100;
+
+#define MAX_PLUGIN_NAME_LENGTH 80
+
+static char plugin_name[MAX_PLUGIN_NAME_LENGTH];
+
+#define xstr(s) str(s)
+#define str(s) #s
+
+static const char* jpeg_plugin_name()
+{
+#ifdef LIBJPEG_TURBO_VERSION
+  snprintf(plugin_name, MAX_PLUGIN_NAME_LENGTH-1, "libjpeg-turbo " xstr(LIBJPEG_TURBO_VERSION) " (libjpeg %d.%d)", JPEG_LIB_VERSION/10, JPEG_LIB_VERSION%10);
+  plugin_name[MAX_PLUGIN_NAME_LENGTH-1] = 0;
+#else
+  sprintf(plugin_name, "libjpeg %d.%d", JPEG_LIB_VERSION/10, JPEG_LIB_VERSION%10);
+#endif
+
+  return plugin_name;
+}
+
+
+static void jpeg_init_plugin()
+{
+}
+
+
+static void jpeg_deinit_plugin()
+{
+}
+
+
+static int jpeg_does_support_format(heif_compression_format format)
+{
+  if (format == heif_compression_JPEG) {
+    return JPEG_PLUGIN_PRIORITY;
+  }
+  else {
+    return 0;
+  }
+}
+
+
+static int jpeg_does_support_format2(const heif_decoder_plugin_compressed_format_description* format)
+{
+  return jpeg_does_support_format(format->format);
+}
+
+heif_error jpeg_new_decoder2(void** dec, const heif_decoder_plugin_options* options)
+{
+  struct jpeg_decoder* decoder = new jpeg_decoder();
+  *dec = decoder;
+
+  return {heif_error_Ok, heif_suberror_Unspecified, kSuccess};
+}
+
+
+heif_error jpeg_new_decoder(void** dec)
+{
+  heif_decoder_plugin_options options;
+  options.format = heif_compression_JPEG;
+  options.num_threads = 0;
+  options.strict_decoding = false;
+
+  return jpeg_new_decoder2(dec, &options);
+}
+
+
+void jpeg_free_decoder(void* decoder_raw)
+{
+  jpeg_decoder* decoder = (jpeg_decoder*) decoder_raw;
+
+  if (!decoder) {
+    return;
+  }
+
+  delete decoder;
+}
+
+
+void jpeg_set_strict_decoding(void* decoder_raw, int flag)
+{
+//  struct jpeg_decoder* decoder = (jpeg_decoder*) decoder_raw;
+}
+
+
+heif_error jpeg_push_data2(void* decoder_raw, const void* frame_data, size_t frame_size, uintptr_t user_data)
+{
+  jpeg_decoder* decoder = (jpeg_decoder*) decoder_raw;
+
+  const uint8_t* input_data = (const uint8_t*)frame_data;
+
+  decoder->data.insert(decoder->data.end(), input_data, input_data + frame_size);
+  decoder->user_data = user_data;
+
+  return {heif_error_Ok, heif_suberror_Unspecified, kSuccess};
+}
+
+heif_error jpeg_push_data(void* decoder_raw, const void* frame_data, size_t frame_size)
+{
+  return jpeg_push_data2(decoder_raw, frame_data, frame_size, 0);
+}
+
+
+struct my_error_manager {
+  jpeg_error_mgr mgr;
+  jmp_buf setjmp_buffer;
+};
+
+static char last_libjpeg_error_message[JMSG_LENGTH_MAX];
+
+void on_jpeg_error(j_common_ptr cinfo)
+{
+  /* cinfo->err actually points to a jpegErrorManager struct */
+  auto* my_err_mgr = (my_error_manager*) cinfo->err;
+  /* note : *(cinfo->err) is now equivalent to myerr->mgr */
+
+  // Create the message
+  ( *(cinfo->err->format_message) ) (cinfo, last_libjpeg_error_message);
+
+  // Jump to the setjmp point
+  longjmp(my_err_mgr->setjmp_buffer, 1);
+}
+
+
+heif_error jpeg_decode_next_image2(void* decoder_raw, heif_image** out_img,
+                                   uintptr_t* out_user_data,
+                                   const heif_security_limits* limits)
+{
+  jpeg_decoder* decoder = (jpeg_decoder*) decoder_raw;
+
+  // When there is no input data yet, return NULL image.
+  if (decoder->data.empty()) {
+    *out_img = nullptr;
+    return heif_error_ok;
+  }
+
+  jpeg_decompress_struct cinfo;
+  my_error_manager jerr;
+
+  // to store embedded icc profile
+//  uint32_t iccLen;
+//  uint8_t* iccBuffer = NULL;
+
+//  std::vector<uint8_t> xmpData;
+//  std::vector<uint8_t> exifData;
+
+  // initialize decompressor
+
+  jpeg_create_decompress(&cinfo);
+
+  heif_image* heif_img = nullptr;
+
+  cinfo.err = jpeg_std_error(&jerr.mgr);
+  jerr.mgr.error_exit = on_jpeg_error;
+  if (setjmp(jerr.setjmp_buffer)) {
+    // If we get here, the JPEG code has signaled an error.
+
+    jpeg_destroy_decompress(&cinfo);
+
+    if (heif_img) {
+      heif_image_release(heif_img);
+    }
+
+    return heif_error{
+      heif_error_Decoder_plugin_error,
+      heif_suberror_Unspecified,
+      last_libjpeg_error_message,
+    };
+  }
+
+
+  jpeg_mem_src(&cinfo, decoder->data.data(), static_cast<unsigned long>(decoder->data.size()));
+
+  /* Adding this part to prepare for icc profile reading. */
+//  jpeg_save_markers(&cinfo, JPEG_ICC_MARKER, 0xFFFF);
+//  jpeg_save_markers(&cinfo, JPEG_XMP_MARKER, 0xFFFF);
+//  jpeg_save_markers(&cinfo, JPEG_EXIF_MARKER, 0xFFFF);
+
+  jpeg_read_header(&cinfo, TRUE);
+
+//  bool embeddedIccFlag = ReadICCProfileFromJPEG(&cinfo, &iccBuffer, &iccLen);
+//  bool embeddedXMPFlag = ReadXMPFromJPEG(&cinfo, xmpData);
+//  if (embeddedXMPFlag) {
+//    img.xmp = xmpData;
+//  }
+
+//  bool embeddedEXIFFlag = ReadEXIFFromJPEG(&cinfo, exifData);
+//  if (embeddedEXIFFlag) {
+//    img.exif = exifData;
+//    img.orientation = (heif_orientation) read_exif_orientation_tag(exifData.data(), (int) exifData.size());
+//  }
+
+  if (cinfo.jpeg_color_space == JCS_GRAYSCALE) {
+    cinfo.out_color_space = JCS_GRAYSCALE;
+
+    jpeg_start_decompress(&cinfo);
+
+    JSAMPARRAY buffer;
+    buffer = (*cinfo.mem->alloc_sarray)
+        ((j_common_ptr) &cinfo, JPOOL_IMAGE, cinfo.output_width * cinfo.output_components, 1);
+
+
+    // create destination image
+
+    heif_error err = heif_image_create(cinfo.output_width, cinfo.output_height,
+                                       heif_colorspace_monochrome,
+                                       heif_chroma_monochrome,
+                                       &heif_img);
+    if (err.code != heif_error_Ok) {
+      assert(heif_img==nullptr);
+      jpeg_destroy_decompress(&cinfo);
+      return err;
+    }
+
+    err = heif_image_add_plane_safe(heif_img, heif_channel_Y, cinfo.output_width, cinfo.output_height, 8, limits);
+    if (err.code) {
+      // copy error message to decoder object because heif_image will be released
+      decoder->error_message = err.message;
+      err.message = decoder->error_message.c_str();
+
+      heif_image_release(heif_img);
+      heif_img = nullptr;
+      jpeg_destroy_decompress(&cinfo);
+      return err;
+    }
+
+    size_t y_stride;
+    uint8_t* py = heif_image_get_plane2(heif_img, heif_channel_Y, &y_stride);
+
+
+    // read the image
+
+    while (cinfo.output_scanline < cinfo.output_height) {
+      (void) jpeg_read_scanlines(&cinfo, buffer, 1);
+
+      memcpy(py + (cinfo.output_scanline - 1) * y_stride, *buffer, cinfo.output_width);
+    }
+
+    *out_img = heif_img;
+    heif_img = nullptr;  // pass ownership to caller, don't delete it in the plugin during any subsequent error
+  }
+  else {
+    cinfo.out_color_space = JCS_YCbCr;
+
+    jpeg_start_decompress(&cinfo);
+
+    JSAMPARRAY buffer;
+    buffer = (*cinfo.mem->alloc_sarray)
+        ((j_common_ptr) &cinfo, JPOOL_IMAGE, cinfo.output_width * cinfo.output_components, 1);
+
+
+    // create destination image
+
+    heif_error err = heif_image_create(cinfo.output_width, cinfo.output_height,
+                                       heif_colorspace_YCbCr,
+                                       heif_chroma_420,
+                                       &heif_img);
+    if (err.code != heif_error_Ok) {
+      assert(heif_img==nullptr);
+      jpeg_destroy_decompress(&cinfo);
+      return err;
+    }
+
+    err = heif_image_add_plane_safe(heif_img, heif_channel_Y, cinfo.output_width, cinfo.output_height, 8, limits);
+    if (err.code) {
+      // copy error message to decoder object because heif_image will be released
+      decoder->error_message = err.message;
+      err.message = decoder->error_message.c_str();
+
+      heif_image_release(heif_img);
+      heif_img = nullptr; // avoid double free in jpeg error handler
+      jpeg_destroy_decompress(&cinfo);
+      return err;
+    }
+    err = heif_image_add_plane_safe(heif_img, heif_channel_Cb, (cinfo.output_width + 1) / 2, (cinfo.output_height + 1) / 2, 8, limits);
+    if (err.code) {
+      // copy error message to decoder object because heif_image will be released
+      decoder->error_message = err.message;
+      err.message = decoder->error_message.c_str();
+
+      heif_image_release(heif_img);
+      heif_img = nullptr; // avoid double free in jpeg error handler
+      jpeg_destroy_decompress(&cinfo);
+      return err;
+    }
+    err = heif_image_add_plane_safe(heif_img, heif_channel_Cr, (cinfo.output_width + 1) / 2, (cinfo.output_height + 1) / 2, 8, limits);
+    if (err.code) {
+      // copy error message to decoder object because heif_image will be released
+      decoder->error_message = err.message;
+      err.message = decoder->error_message.c_str();
+
+      heif_image_release(heif_img);
+      heif_img = nullptr; // avoid double free in jpeg error handler
+      jpeg_destroy_decompress(&cinfo);
+      return err;
+    }
+
+    size_t y_stride;
+    size_t cb_stride;
+    size_t cr_stride;
+    uint8_t* py = heif_image_get_plane2(heif_img, heif_channel_Y, &y_stride);
+    uint8_t* pcb = heif_image_get_plane2(heif_img, heif_channel_Cb, &cb_stride);
+    uint8_t* pcr = heif_image_get_plane2(heif_img, heif_channel_Cr, &cr_stride);
+
+    // read the image
+
+    //printf("jpeg size: %d %d\n",cinfo.output_width, cinfo.output_height);
+
+    while (cinfo.output_scanline < cinfo.output_height) {
+      JOCTET* bufp;
+
+      (void) jpeg_read_scanlines(&cinfo, buffer, 1);
+
+      bufp = buffer[0];
+
+      int y = cinfo.output_scanline - 1;
+
+      for (unsigned int x = 0; x < cinfo.output_width; x += 2) {
+        py[y * y_stride + x] = *bufp++;
+        pcb[y / 2 * cb_stride + x / 2] = *bufp++;
+        pcr[y / 2 * cr_stride + x / 2] = *bufp++;
+
+        if (x + 1 < cinfo.output_width) {
+          py[y * y_stride + x + 1] = *bufp++;
+        }
+
+        bufp += 2;
+      }
+
+
+      if (cinfo.output_scanline < cinfo.output_height) {
+        (void) jpeg_read_scanlines(&cinfo, buffer, 1);
+
+        bufp = buffer[0];
+
+        y = cinfo.output_scanline - 1;
+
+        for (unsigned int x = 0; x < cinfo.output_width; x++) {
+          py[y * y_stride + x] = *bufp++;
+          bufp += 2;
+        }
+      }
+    }
+
+    *out_img = heif_img;
+    heif_img = nullptr; // pass ownership to caller (see similar comment above)
+  }
+
+  if (out_user_data) {
+    *out_user_data = decoder->user_data;
+  }
+
+//  if (embeddedIccFlag && iccLen > 0) {
+//    heif_image_set_raw_color_profile(image, "prof", iccBuffer, (size_t) iccLen);
+//  }
+
+  // cleanup
+//  free(iccBuffer);
+  jpeg_finish_decompress(&cinfo);
+  jpeg_destroy_decompress(&cinfo);
+
+  decoder->data.clear();
+
+  return heif_error_ok;
+}
+
+heif_error jpeg_decode_next_image(void* decoder_raw, heif_image** out_img,
+                                  const heif_security_limits* limits)
+{
+  return jpeg_decode_next_image2(decoder_raw, out_img, nullptr, limits);
+}
+
+heif_error jpeg_decode_image(void* decoder_raw, heif_image** out_img)
+{
+  auto* limits = heif_get_global_security_limits();
+  return jpeg_decode_next_image(decoder_raw, out_img, limits);
+}
+
+heif_error jpeg_flush_data(void* decoder)
+{
+  return heif_error_ok;
+}
+
+
+static const heif_decoder_plugin decoder_jpeg
+    {
+        5,
+        jpeg_plugin_name,
+        jpeg_init_plugin,
+        jpeg_deinit_plugin,
+        jpeg_does_support_format,
+        jpeg_new_decoder,
+        jpeg_free_decoder,
+        jpeg_push_data,
+        jpeg_decode_image,
+        jpeg_set_strict_decoding,
+        "jpeg",
+        jpeg_decode_next_image,
+        /* minimum_required_libheif_version */ LIBHEIF_MAKE_VERSION(1,21,0),
+        jpeg_does_support_format2,
+        jpeg_new_decoder2,
+        jpeg_push_data2,
+        jpeg_flush_data,
+        jpeg_decode_next_image2,
+    };
+
+
+const heif_decoder_plugin* get_decoder_plugin_jpeg()
+{
+  return &decoder_jpeg;
+}
+
+
+#if PLUGIN_JPEG_DECODER
+heif_plugin_info plugin_info {
+  1,
+  heif_plugin_type_decoder,
+  &decoder_jpeg
+};
+#endif
diff --git a/libheif/plugins/decoder_jpeg.h b/libheif/plugins/decoder_jpeg.h
new file mode 100644
index 0000000000..d40e441b15
--- /dev/null
+++ b/libheif/plugins/decoder_jpeg.h
@@ -0,0 +1,34 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_DECODER_JPEG_H
+#define LIBHEIF_DECODER_JPEG_H
+
+#include "common_utils.h"
+
+const struct heif_decoder_plugin* get_decoder_plugin_jpeg();
+
+#if PLUGIN_JPEG_DECODER
+extern "C" {
+MAYBE_UNUSED LIBHEIF_API extern heif_plugin_info plugin_info;
+}
+#endif
+
+#endif
diff --git a/libheif/plugins/decoder_libde265.cc b/libheif/plugins/decoder_libde265.cc
new file mode 100644
index 0000000000..3dd573269b
--- /dev/null
+++ b/libheif/plugins/decoder_libde265.cc
@@ -0,0 +1,514 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "libheif/heif.h"
+#include "libheif/heif_plugin.h"
+#include "decoder_libde265.h"
+#include <cassert>
+#include <memory>
+#include <cstring>
+#include <string>
+
+#include <libde265/de265.h>
+
+
+
+struct libde265_decoder
+{
+  de265_decoder_context* ctx;
+  bool strict_decoding = false;
+  std::string error_message;
+};
+
+static const char kEmptyString[] = "";
+static const char kSuccess[] = "Success";
+
+static const int LIBDE265_PLUGIN_PRIORITY = 100;
+
+#define MAX_PLUGIN_NAME_LENGTH 80
+
+static char plugin_name[MAX_PLUGIN_NAME_LENGTH];
+
+
+static const char* libde265_plugin_name()
+{
+  strcpy(plugin_name, "libde265 HEVC decoder");
+
+  const char* libde265_version = de265_get_version();
+
+  if (strlen(libde265_version) + 10 < MAX_PLUGIN_NAME_LENGTH) {
+    strcat(plugin_name, ", version ");
+    strcat(plugin_name, libde265_version);
+  }
+
+  return plugin_name;
+}
+
+
+static void libde265_init_plugin()
+{
+  de265_init();
+}
+
+
+static void libde265_deinit_plugin()
+{
+  de265_free();
+}
+
+
+static int libde265_does_support_format(heif_compression_format format)
+{
+  if (format == heif_compression_HEVC) {
+    return LIBDE265_PLUGIN_PRIORITY;
+  }
+  else {
+    return 0;
+  }
+}
+
+
+[[maybe_unused]]
+static int libde265_does_support_format2(const heif_decoder_plugin_compressed_format_description* format)
+{
+  return libde265_does_support_format(format->format);
+}
+
+
+
+static heif_error convert_libde265_image_to_heif_image(libde265_decoder* decoder,
+                                                       const de265_image* de265img,
+                                                       heif_image** image,
+                                                       const heif_security_limits* limits)
+{
+  bool is_mono = (de265_get_chroma_format(de265img) == de265_chroma_mono);
+
+  heif_error err;
+  err = heif_image_create(de265_get_image_width(de265img, 0),
+                          de265_get_image_height(de265img, 0),
+                          is_mono ? heif_colorspace_monochrome : heif_colorspace_YCbCr,
+                          (heif_chroma) de265_get_chroma_format(de265img),
+                          image);
+  if (err.code) {
+    return err;
+  }
+
+  // --- transfer data from de265_image to HeifPixelImage
+
+  heif_channel channel2plane[3] = {
+      heif_channel_Y,
+      heif_channel_Cb,
+      heif_channel_Cr
+  };
+
+
+  int bpp = de265_get_bits_per_pixel(de265img, 0);
+
+  int num_planes = (is_mono ? 1 : 3);
+
+  for (int c = 0; c < num_planes; c++) {
+    if (de265_get_bits_per_pixel(de265img, c) != bpp) {
+      heif_image_release(*image);
+      err = {heif_error_Unsupported_feature,
+             heif_suberror_Unsupported_color_conversion,
+             "Channels with different number of bits per pixel are not supported"};
+      return err;
+    }
+
+    int stride;
+    const uint8_t* data = de265_get_image_plane(de265img, c, &stride);
+
+    int w = de265_get_image_width(de265img, c);
+    int h = de265_get_image_height(de265img, c);
+    if (w <= 0 || h <= 0) {
+      heif_image_release(*image);
+      err = {heif_error_Decoder_plugin_error,
+             heif_suberror_Invalid_image_size,
+             kEmptyString};
+      return err;
+    }
+
+    err = heif_image_add_plane_safe(*image, channel2plane[c], w,h, bpp, limits);
+    if (err.code) {
+      // copy error message to decoder object because heif_image will be released
+      decoder->error_message = err.message;
+      err.message = decoder->error_message.c_str();
+
+      heif_image_release(*image);
+      return err;
+    }
+
+    size_t dst_stride;
+    uint8_t* dst_mem = heif_image_get_plane2(*image, channel2plane[c], &dst_stride);
+
+    int bytes_per_pixel = (bpp + 7) / 8;
+
+    for (int y = 0; y < h; y++) {
+      memcpy(dst_mem + y * dst_stride, data + y * stride, w * bytes_per_pixel);
+    }
+  }
+
+
+  return {heif_error_Ok, heif_suberror_Unspecified, kSuccess};
+}
+
+
+
+// Create a new decoder context for decoding an image
+heif_error libde265_new_decoder2(void** dec, const heif_decoder_plugin_options* options)
+{
+  libde265_decoder* decoder = new libde265_decoder();
+  heif_error err = {heif_error_Ok, heif_suberror_Unspecified, kSuccess};
+
+  decoder->ctx = de265_new_decoder();
+#if defined(__EMSCRIPTEN__)
+  // Speed up decoding from JavaScript.
+  de265_set_parameter_bool(decoder->ctx, DE265_DECODER_PARAM_DISABLE_DEBLOCKING, 1);
+  de265_set_parameter_bool(decoder->ctx, DE265_DECODER_PARAM_DISABLE_SAO, 1);
+#else
+  int nThreads = (options->num_threads ? options->num_threads : 1);
+
+  // Worker threads are not supported when running on Emscripten.
+  de265_start_worker_threads(decoder->ctx, nThreads);
+#endif
+
+  decoder->strict_decoding = options->strict_decoding;
+
+  *dec = decoder;
+  return err;
+}
+
+
+static heif_error libde265_new_decoder(void** dec)
+{
+  heif_decoder_plugin_options options;
+  options.format = heif_compression_HEVC;
+  options.num_threads = 0;
+  options.strict_decoding = false;
+
+  return libde265_new_decoder2(dec, &options);
+}
+
+static void libde265_free_decoder(void* decoder_raw)
+{
+  libde265_decoder* decoder = (libde265_decoder*) decoder_raw;
+
+  de265_error err = de265_free_decoder(decoder->ctx);
+  (void) err;
+
+  delete decoder;
+}
+
+
+void libde265_set_strict_decoding(void* decoder_raw, int flag)
+{
+  libde265_decoder* decoder = (libde265_decoder*) decoder_raw;
+
+  decoder->strict_decoding = flag;
+}
+
+
+#if LIBDE265_NUMERIC_VERSION >= 0x02000000
+
+static heif_error libde265_v2_push_data(void* decoder_raw, const void* data, size_t size)
+{
+  libde265_decoder* decoder = (libde265_decoder*)decoder_raw;
+
+  const uint8_t* cdata = (const uint8_t*)data;
+
+  size_t ptr=0;
+  while (ptr < size) {
+    if (4 > size - ptr) {
+      return { heif_error_Decoder_plugin_error,
+               heif_suberror_End_of_data,
+               kEmptyString };
+    }
+
+    // TODO: the size of the NAL unit length variable is defined in the hvcC header.
+    // We should not assume that it is always 4 bytes.
+    uint32_t nal_size = (uint32_t)((cdata[ptr]<<24) | (cdata[ptr+1]<<16) | (cdata[ptr+2]<<8) | (cdata[ptr+3]));
+    ptr+=4;
+
+    if (nal_size > size - ptr) {
+      //sstr << "NAL size (" << size32 << ") exceeds available data in file ("
+      //<< data_bytes_left_to_read << ")";
+
+      return { heif_error_Decoder_plugin_error,
+               heif_suberror_End_of_data,
+               kEmptyString };
+    }
+
+    de265_push_NAL(decoder->ctx, cdata+ptr, nal_size, 0, nullptr);
+    ptr += nal_size;
+  }
+
+
+  return { heif_error_Ok, heif_suberror_Unspecified, kSuccess };
+}
+
+
+static heif_error libde265_v2_decode_next_image(void* decoder_raw,
+                                                heif_image** out_img,
+                                                const heif_security_limits* limits)
+{
+  libde265_decoder* decoder = (libde265_decoder*)decoder_raw;
+
+  de265_push_end_of_stream(decoder->ctx);
+
+  int action = de265_get_action(decoder->ctx, 1);
+
+  // TODO: read NCLX from h265 bitstream
+
+  // TODO(farindk): Set "err" if no image was decoded.
+  if (action==de265_action_get_image) {
+    const de265_image* img = de265_get_next_picture(decoder->ctx);
+    if (img) {
+      heif_error err = convert_libde265_image_to_heif_image(decoder, img,
+                                                                   out_img, limits);
+      de265_release_picture(img);
+
+      return err;
+    }
+  }
+
+  return { heif_error_Decoder_plugin_error, heif_suberror_Unspecified, kEmptyString };
+}
+
+static heif_error libde265_v2_decode_image(void* decoder_raw,
+                                           heif_image** out_img)
+{
+  auto* limits = heif_get_global_security_limits();
+  return libde265_v2_decode_next_image(decoder_raw, out_img, limits);
+}
+#else
+
+static heif_error libde265_v1_push_data2(void* decoder_raw, const void* data, size_t size, uintptr_t user_data)
+{
+  libde265_decoder* decoder = (libde265_decoder*) decoder_raw;
+
+  const uint8_t* cdata = (const uint8_t*) data;
+
+  size_t ptr = 0;
+  while (ptr < size) {
+    if (4 > size - ptr) {
+      return {
+        heif_error_Decoder_plugin_error,
+        heif_suberror_End_of_data,
+        kEmptyString
+      };
+    }
+
+    uint32_t nal_size = static_cast<uint32_t>((cdata[ptr] << 24) | (cdata[ptr + 1] << 16) | (cdata[ptr + 2] << 8) | (cdata[ptr + 3]));
+    ptr += 4;
+
+    if (nal_size > size - ptr) {
+      return {
+        heif_error_Decoder_plugin_error,
+        heif_suberror_End_of_data,
+        kEmptyString
+      };
+    }
+
+#if 0
+    FILE* fh = fopen("data.h265", "a");
+    fputc(0, fh);
+    fputc(0, fh);
+    fputc(1, fh);
+    fwrite(cdata + ptr, nal_size, 1, fh);
+    fclose(fh);
+
+    printf("put nal with size %d %x\n", nal_size, *(cdata+ptr));
+#endif
+
+    de265_push_NAL(decoder->ctx, cdata + ptr, nal_size, 0, (void*)user_data);
+    ptr += nal_size;
+  }
+
+  // TODO(farindk): Set "err" if data could not be pushed
+  //de265_push_data(decoder->ctx, data, size, 0, nullptr);
+
+  return {heif_error_Ok, heif_suberror_Unspecified, kSuccess};
+}
+
+static heif_error libde265_v1_push_data(void* decoder_raw, const void* data, size_t size)
+{
+  return libde265_v1_push_data2(decoder_raw, data, size, 0);
+}
+
+static heif_error libde265_flush_data(void* decoder_raw)
+{
+  libde265_decoder* decoder = (libde265_decoder*) decoder_raw;
+
+  de265_flush_data(decoder->ctx);
+
+  return heif_error_ok;
+}
+
+
+
+static heif_error libde265_v1_decode_next_image2(void* decoder_raw,
+                                                 heif_image** out_img,
+                                                 uintptr_t* out_user_data,
+                                                 const heif_security_limits* limits)
+{
+  libde265_decoder* decoder = (libde265_decoder*) decoder_raw;
+  heif_error err = {heif_error_Ok, heif_suberror_Unspecified, kSuccess};
+
+  // TODO(251119) : de265_flush_data(decoder->ctx);
+
+  // TODO(farindk): Set "err" if no image was decoded.
+  int more;
+  de265_error decode_err;
+  *out_img = nullptr;
+  do {
+    more = 0;
+    decode_err = de265_decode(decoder->ctx, &more);
+    if (decode_err != DE265_OK) {
+      // printf("Error decoding: %s (%d)\n", de265_get_error_text(decode_err), decode_err);
+      break;
+    }
+
+    // TODO: read NCLX from h265 bitstream
+
+    const de265_image* image = de265_get_next_picture(decoder->ctx);
+    if (image) {
+      // TODO(farindk): Should we return the first image instead?
+      if (*out_img) {
+        heif_image_release(*out_img);
+      }
+
+      if (out_user_data) {
+        *out_user_data = (uintptr_t)de265_get_image_user_data(image);
+      }
+
+      err = convert_libde265_image_to_heif_image(decoder, image, out_img, limits);
+      if (err.code != heif_error_Ok) {
+        return err;
+      }
+
+      heif_color_profile_nclx* nclx = heif_nclx_color_profile_alloc();
+#if LIBDE265_NUMERIC_VERSION >= 0x01000700
+      HEIF_WARN_OR_FAIL(decoder->strict_decoding, *out_img, heif_nclx_color_profile_set_color_primaries(nclx, static_cast<uint16_t>(de265_get_image_colour_primaries(image))),
+                        {
+                          heif_nclx_color_profile_free(nclx);
+                          heif_image_release(*out_img);
+                          *out_img = nullptr;
+                        });
+      HEIF_WARN_OR_FAIL(decoder->strict_decoding, *out_img, heif_nclx_color_profile_set_transfer_characteristics(nclx, static_cast<uint16_t>(de265_get_image_transfer_characteristics(image))),
+                        {
+                          heif_nclx_color_profile_free(nclx);
+                          heif_image_release(*out_img);
+                          *out_img = nullptr;
+                        });
+      HEIF_WARN_OR_FAIL(decoder->strict_decoding, *out_img, heif_nclx_color_profile_set_matrix_coefficients(nclx, static_cast<uint16_t>(de265_get_image_matrix_coefficients(image))),
+                        {
+                          heif_nclx_color_profile_free(nclx);
+                          heif_image_release(*out_img);
+                          *out_img = nullptr;
+                        });
+      nclx->full_range_flag = (bool) de265_get_image_full_range_flag(image);
+#endif
+      heif_image_set_nclx_color_profile(*out_img, nclx);
+      heif_nclx_color_profile_free(nclx);
+
+      de265_release_next_picture(decoder->ctx);
+      return heif_error_ok;
+    }
+  } while (more);
+
+  return err;
+}
+
+
+static heif_error libde265_v1_decode_next_image(void* decoder_raw,
+                                                heif_image** out_img,
+                                                const heif_security_limits* limits)
+{
+  return libde265_v1_decode_next_image2(decoder_raw, out_img, nullptr, limits);
+}
+
+static heif_error libde265_v1_decode_image(void* decoder_raw,
+                                           heif_image** out_img)
+{
+  auto* limits = heif_get_global_security_limits();
+  return libde265_v1_decode_next_image(decoder_raw, out_img, limits);
+}
+
+#endif
+
+
+#if LIBDE265_NUMERIC_VERSION >= 0x02000000
+
+static const heif_decoder_plugin decoder_libde265
+{
+  1,
+  libde265_plugin_name,
+  libde265_init_plugin,
+  libde265_deinit_plugin,
+  libde265_does_support_format,
+  libde265_new_decoder,
+  libde265_free_decoder,
+  libde265_v2_push_data,
+  libde265_v2_decode_image,
+  libde265_set_strict_decoding,
+  "libde265",
+  libde265_v2_decode_next_image
+};
+
+#else
+
+static const heif_decoder_plugin decoder_libde265
+    {
+        5,
+        libde265_plugin_name,
+        libde265_init_plugin,
+        libde265_deinit_plugin,
+        libde265_does_support_format,
+        libde265_new_decoder,
+        libde265_free_decoder,
+        libde265_v1_push_data,
+        libde265_v1_decode_image,
+        libde265_set_strict_decoding,
+        "libde265",
+        libde265_v1_decode_next_image,
+        /* minimum_required_libheif_version */ LIBHEIF_MAKE_VERSION(1,21,0),
+        libde265_does_support_format2,
+        libde265_new_decoder2,
+        libde265_v1_push_data2,
+        libde265_flush_data,
+        libde265_v1_decode_next_image2
+    };
+
+#endif
+
+const heif_decoder_plugin* get_decoder_plugin_libde265()
+{
+  return &decoder_libde265;
+}
+
+
+
+#if PLUGIN_LIBDE265
+heif_plugin_info plugin_info {
+  1,
+  heif_plugin_type_decoder,
+  &decoder_libde265
+};
+#endif
diff --git a/libheif/heif_decoder_libde265.h b/libheif/plugins/decoder_libde265.h
similarity index 82%
rename from libheif/heif_decoder_libde265.h
rename to libheif/plugins/decoder_libde265.h
index 11c47441ec..ec93a45cc8 100644
--- a/libheif/heif_decoder_libde265.h
+++ b/libheif/plugins/decoder_libde265.h
@@ -1,6 +1,6 @@
 /*
  * HEIF codec.
- * Copyright (c) 2017 struktur AG, Dirk Farin <farin@struktur.de>
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
  *
  * This file is part of libheif.
  *
@@ -21,6 +21,14 @@
 #ifndef LIBHEIF_HEIF_DECODER_DE265_H
 #define LIBHEIF_HEIF_DECODER_DE265_H
 
+#include "common_utils.h"
+
 const struct heif_decoder_plugin* get_decoder_plugin_libde265();
 
+#if PLUGIN_LIBDE265
+extern "C" {
+MAYBE_UNUSED LIBHEIF_API extern heif_plugin_info plugin_info;
+}
+#endif
+
 #endif
diff --git a/libheif/plugins/decoder_openh264.cc b/libheif/plugins/decoder_openh264.cc
new file mode 100644
index 0000000000..f76f1c38aa
--- /dev/null
+++ b/libheif/plugins/decoder_openh264.cc
@@ -0,0 +1,477 @@
+/*
+ * openh264 codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "libheif/heif.h"
+#include "libheif/heif_plugin.h"
+#include "decoder_openh264.h"
+#include <cstring>
+#include <cassert>
+#include <vector>
+#include <cstdio>
+#include <deque>
+
+#include <wels/codec_api.h>
+#include <string>
+#include <utility>
+
+// TODO: the openh264 decoder seems to fail with some images.
+//       I have not figured out yet which images are affected.
+//       Maybe it has something to do with the image size. I got the error with large images.
+
+struct openh264_decoder
+{
+  struct Packet
+  {
+    std::vector<uint8_t> data;
+    uintptr_t pts;
+  };
+
+  std::deque<Packet> input_data;
+  bool m_eof_reached = false;
+
+  std::string error_message;
+
+
+  // --- decoder
+
+  ISVCDecoder* decoder = nullptr;
+
+  ~openh264_decoder()
+  {
+    if (decoder) {
+      // Step 6:uninitialize the decoder and memory free
+
+      decoder->Uninitialize(); // TODO: do we have to Uninitialize when an error is returned?
+
+
+      WelsDestroyDecoder(decoder);
+    }
+  }
+};
+
+static const char kSuccess[] = "Success";
+
+// Reduced priority because OpenH264 cannot pass through user-data.
+// We need this feature for decoding sequences with SAI.
+// Prefer to use the FFMPEG plugin.
+static const int OpenH264_PLUGIN_PRIORITY = 70;
+
+#define MAX_PLUGIN_NAME_LENGTH 80
+
+static char plugin_name[MAX_PLUGIN_NAME_LENGTH];
+
+static heif_error kError_EOF = {heif_error_Decoder_plugin_error, heif_suberror_End_of_data, "Insufficient input data"};
+static heif_error kError_invalid_data = {heif_error_Decoder_plugin_error, heif_suberror_Invalid_parameter_value, "Invalid input data"};
+
+
+static const char* openh264_plugin_name()
+{
+  OpenH264Version version = WelsGetCodecVersion();
+
+  sprintf(plugin_name, "OpenH264 %d.%d.%d", version.uMajor, version.uMinor, version.uRevision);
+
+  return plugin_name;
+}
+
+
+static void openh264_init_plugin()
+{
+}
+
+
+static void openh264_deinit_plugin()
+{
+}
+
+
+static int openh264_does_support_format(heif_compression_format format)
+{
+  if (format == heif_compression_AVC) {
+    return OpenH264_PLUGIN_PRIORITY;
+  }
+  else {
+    return 0;
+  }
+}
+
+static int openh264_does_support_format2(const heif_decoder_plugin_compressed_format_description* format)
+{
+  return openh264_does_support_format(format->format);
+}
+
+
+heif_error openh264_new_decoder2(void** dec, const heif_decoder_plugin_options* options)
+{
+  auto* decoder = new openh264_decoder();
+  *dec = decoder;
+
+  // Step 2:decoder creation
+  WelsCreateDecoder(&decoder->decoder);
+  if (!decoder->decoder) {
+    return {
+      heif_error_Decoder_plugin_error,
+      heif_suberror_Unspecified,
+      "Cannot create OpenH264 decoder"
+    };
+  }
+
+  // Step 3:declare required parameter, used to differentiate Decoding only and Parsing only
+  SDecodingParam sDecParam{};
+  sDecParam.sVideoProperty.eVideoBsType = VIDEO_BITSTREAM_AVC;
+
+  //for Parsing only, the assignment is mandatory
+  // sDecParam.bParseOnly = true;
+
+  // Step 4:initialize the parameter and decoder context, allocate memory
+  decoder->decoder->Initialize(&sDecParam);
+
+  return {heif_error_Ok, heif_suberror_Unspecified, kSuccess};
+}
+
+
+heif_error openh264_new_decoder(void** dec)
+{
+  heif_decoder_plugin_options options;
+  options.format = heif_compression_AVC;
+  options.num_threads = 0;
+  options.strict_decoding = false;
+
+  return openh264_new_decoder2(dec, &options);
+}
+
+void openh264_free_decoder(void* decoder_raw)
+{
+  auto* decoder = (openh264_decoder*) decoder_raw;
+
+  if (!decoder) {
+    return;
+  }
+
+  delete decoder;
+}
+
+
+void openh264_set_strict_decoding(void* decoder_raw, int flag)
+{
+  //  auto* decoder = (openh264_decoder*) decoder_raw;
+}
+
+
+heif_error openh264_push_data2(void* decoder_raw, const void* frame_data, size_t frame_size, uintptr_t user_data)
+{
+  auto* decoder = (openh264_decoder*) decoder_raw;
+
+  const auto* input_data = (const uint8_t*) frame_data;
+
+  if (frame_size < 4) {
+    return kError_invalid_data;
+  }
+
+  openh264_decoder::Packet pkt;
+  pkt.data.insert(pkt.data.end(), input_data, input_data + frame_size);
+  pkt.pts = user_data;
+  decoder->input_data.push_back(std::move(pkt));
+
+  return {heif_error_Ok, heif_suberror_Unspecified, kSuccess};
+}
+
+heif_error openh264_push_data(void* decoder_raw, const void* frame_data, size_t frame_size)
+{
+  return openh264_push_data2(decoder_raw, frame_data, frame_size, 0);
+}
+
+
+heif_error openh264_decode_next_image2(void* decoder_raw, heif_image** out_img,
+                                       uintptr_t* out_user_data,
+                                       const heif_security_limits* limits)
+{
+  auto* decoder = (openh264_decoder*) decoder_raw;
+  ISVCDecoder* pSvcDecoder = decoder->decoder;
+
+  // --- Not enough data, but no EOF yet.
+
+  if (decoder->input_data.empty() && !decoder->m_eof_reached) {
+    *out_img = nullptr;
+    return heif_error_ok;
+  }
+
+
+  //output: [0~2] for Y,U,V buffer for Decoding only
+  unsigned char* pData[3] = {nullptr, nullptr, nullptr};
+
+  // in-out: for Decoding only: declare and initialize the output buffer info, this should never co-exist with Parsing only
+
+  SBufferInfo sDstBufInfo;
+  memset(&sDstBufInfo, 0, sizeof(SBufferInfo));
+
+  int iRet;
+
+  if (!decoder->input_data.empty()) {
+    sDstBufInfo.uiInBsTimeStamp = decoder->input_data.front().pts;
+
+    const std::vector<uint8_t>& indata = decoder->input_data.front().data;
+    std::vector<uint8_t> scdata;
+
+    size_t idx = 0;
+    while (idx < indata.size()) {
+      if (indata.size() - 4 < idx) {
+        return kError_EOF;
+      }
+
+      uint32_t size = ((indata[idx] << 24) | (indata[idx + 1] << 16) | (indata[idx + 2] << 8) | indata[idx + 3]);
+      idx += 4;
+
+      if (indata.size() < size || indata.size() - size < idx) {
+        return kError_EOF;
+      }
+
+      scdata.push_back(0);
+      scdata.push_back(0);
+      scdata.push_back(1);
+
+      // check for need of start code emulation prevention
+
+      bool do_start_code_emulation_check = true;
+
+      while (do_start_code_emulation_check && size >= 3) {
+        bool found_start_code_emulation = false;
+
+        for (size_t i = 0; i < size - 3; i++) {
+          if (indata[idx + 0] == 0 &&
+              indata[idx + 1] == 0 &&
+              (indata[idx + 2] >= 0 && indata[idx + 2] <= 3)) {
+            scdata.push_back(0);
+            scdata.push_back(0);
+            scdata.push_back(3);
+
+            scdata.insert(scdata.end(), &indata[idx + 2], indata.data() + idx + i + 2);
+            idx += i + 2;
+            size -= (uint32_t) (i + 2);
+            found_start_code_emulation = true;
+            break;
+          }
+        }
+
+        do_start_code_emulation_check = found_start_code_emulation;
+      }
+
+      if (size == 0) {
+        return kError_invalid_data;
+      }
+      // Note: we cannot write &indata[idx + size] since that would use the operator[] on an element beyond the vector range.
+      scdata.insert(scdata.end(), &indata[idx], indata.data() + idx + size);
+
+      idx += size;
+    }
+
+    if (idx != indata.size()) {
+      decoder->input_data.pop_front();
+      return kError_EOF;
+    }
+
+    decoder->input_data.pop_front();
+
+    // input: encoded bitstream start position; should include start code prefix
+    unsigned char* pBuf = scdata.data();
+
+    // input: encoded bit stream length; should include the size of start code prefix
+    int iSize = static_cast<int>(scdata.size());
+
+
+    // Step 5:do actual decoding process in slice level; this can be done in a loop until data ends
+
+
+    //for Decoding only
+    iRet = pSvcDecoder->DecodeFrameNoDelay(pBuf, iSize, pData, &sDstBufInfo);
+  }
+  else {
+    iRet = pSvcDecoder->FlushFrame(pData, &sDstBufInfo);
+  }
+
+  if (iRet != 0) {
+    return {
+      heif_error_Decoder_plugin_error,
+      heif_suberror_Unspecified,
+      "OpenH264 decoder error"
+    };
+  }
+
+  if (sDstBufInfo.iBufferStatus != 1) {
+    *out_img = nullptr;
+    return heif_error_ok;
+  }
+
+  if (out_user_data) {
+    *out_user_data = sDstBufInfo.uiOutYuvTimeStamp;
+  }
+
+  /*
+  // TODO: I receive an iBufferStatus==0, but the output image is still decoded
+  if (sDstBufInfo.iBufferStatus == 0) {
+    return {heif_error_Decoder_plugin_error,
+            heif_suberror_Unspecified,
+            "OpenH264 decoder did not output any image"};
+  }
+  */
+
+  uint32_t width = sDstBufInfo.UsrData.sSystemBuffer.iWidth;
+  uint32_t height = sDstBufInfo.UsrData.sSystemBuffer.iHeight;
+
+  heif_image* heif_img;
+  heif_error err{};
+
+  uint32_t cwidth, cheight;
+
+  if (sDstBufInfo.UsrData.sSystemBuffer.iFormat == videoFormatI420) {
+    cwidth = (width + 1) / 2;
+    cheight = (height + 1) / 2;
+
+    err = heif_image_create(width, height,
+                            heif_colorspace_YCbCr,
+                            heif_chroma_420,
+                            &heif_img);
+    if (err.code != heif_error_Ok) {
+      assert(heif_img == nullptr);
+      return err;
+    }
+
+    *out_img = heif_img;
+
+    err = heif_image_add_plane_safe(heif_img, heif_channel_Y, width, height, 8, limits);
+    if (err.code != heif_error_Ok) {
+      // copy error message to decoder object because heif_image will be released
+      decoder->error_message = err.message;
+      err.message = decoder->error_message.c_str();
+
+      heif_image_release(heif_img);
+      return err;
+    }
+
+    err = heif_image_add_plane_safe(heif_img, heif_channel_Cb, cwidth, cheight, 8, limits);
+    if (err.code != heif_error_Ok) {
+      // copy error message to decoder object because heif_image will be released
+      decoder->error_message = err.message;
+      err.message = decoder->error_message.c_str();
+
+      heif_image_release(heif_img);
+      return err;
+    }
+
+    err = heif_image_add_plane_safe(heif_img, heif_channel_Cr, cwidth, cheight, 8, limits);
+    if (err.code != heif_error_Ok) {
+      // copy error message to decoder object because heif_image will be released
+      decoder->error_message = err.message;
+      err.message = decoder->error_message.c_str();
+
+      heif_image_release(heif_img);
+      return err;
+    }
+
+    size_t y_stride;
+    size_t cb_stride;
+    size_t cr_stride;
+    uint8_t* py = heif_image_get_plane2(heif_img, heif_channel_Y, &y_stride);
+    uint8_t* pcb = heif_image_get_plane2(heif_img, heif_channel_Cb, &cb_stride);
+    uint8_t* pcr = heif_image_get_plane2(heif_img, heif_channel_Cr, &cr_stride);
+
+    int ystride = sDstBufInfo.UsrData.sSystemBuffer.iStride[0];
+    int cstride = sDstBufInfo.UsrData.sSystemBuffer.iStride[1];
+
+    for (uint32_t y = 0; y < height; y++) {
+      memcpy(py + y * y_stride, sDstBufInfo.pDst[0] + y * ystride, width);
+    }
+
+    for (uint32_t y = 0; y < (height + 1) / 2; y++) {
+      memcpy(pcb + y * cb_stride, sDstBufInfo.pDst[1] + y * cstride, (width + 1) / 2);
+      memcpy(pcr + y * cr_stride, sDstBufInfo.pDst[2] + y * cstride, (width + 1) / 2);
+    }
+  }
+  else {
+    return {
+      heif_error_Decoder_plugin_error,
+      heif_suberror_Unspecified,
+      "Unsupported image pixel format"
+    };
+  }
+
+  // decoder->data.clear();
+
+  return heif_error_ok;
+}
+
+
+heif_error openh264_decode_next_image(void* decoder_raw, heif_image** out_img,
+                                      const heif_security_limits* limits)
+{
+  return openh264_decode_next_image2(decoder_raw, out_img, nullptr, limits);
+}
+
+heif_error openh264_decode_image(void* decoder_raw, heif_image** out_img)
+{
+  auto* limits = heif_get_global_security_limits();
+  return openh264_decode_next_image(decoder_raw, out_img, limits);
+}
+
+
+heif_error openh264_flush_data(void* decoder_raw)
+{
+  auto* decoder = (struct openh264_decoder*) decoder_raw;
+
+  decoder->m_eof_reached = true;
+
+  return heif_error_ok;
+}
+
+
+static const heif_decoder_plugin decoder_openh264{
+  5,
+  openh264_plugin_name,
+  openh264_init_plugin,
+  openh264_deinit_plugin,
+  openh264_does_support_format,
+  openh264_new_decoder,
+  openh264_free_decoder,
+  openh264_push_data,
+  openh264_decode_image,
+  openh264_set_strict_decoding,
+  "openh264",
+  openh264_decode_next_image,
+  /* minimum_required_libheif_version */ LIBHEIF_MAKE_VERSION(1,21,0),
+  openh264_does_support_format2,
+  openh264_new_decoder2,
+  openh264_push_data2,
+  openh264_flush_data,
+  openh264_decode_next_image2
+};
+
+
+const heif_decoder_plugin* get_decoder_plugin_openh264()
+{
+  return &decoder_openh264;
+}
+
+
+#if PLUGIN_OpenH264_DECODER
+heif_plugin_info plugin_info {
+  1,
+  heif_plugin_type_decoder,
+  &decoder_openh264
+};
+#endif
diff --git a/libheif/plugins/decoder_openh264.h b/libheif/plugins/decoder_openh264.h
new file mode 100644
index 0000000000..7289b6b2fd
--- /dev/null
+++ b/libheif/plugins/decoder_openh264.h
@@ -0,0 +1,34 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_DECODER_OPENH264_H
+#define LIBHEIF_DECODER_OPENH264_H
+
+#include "common_utils.h"
+
+const struct heif_decoder_plugin* get_decoder_plugin_openh264();
+
+#if PLUGIN_OpenH264_DECODER
+extern "C" {
+MAYBE_UNUSED LIBHEIF_API extern heif_plugin_info plugin_info;
+}
+#endif
+
+#endif
diff --git a/libheif/plugins/decoder_openjpeg.cc b/libheif/plugins/decoder_openjpeg.cc
new file mode 100644
index 0000000000..6d44f5d3c2
--- /dev/null
+++ b/libheif/plugins/decoder_openjpeg.cc
@@ -0,0 +1,490 @@
+/*
+ * OpenJPEG codec.
+ * Copyright (c) 2023 Devon Sookhoo
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "libheif/heif.h"
+#include "libheif/heif_plugin.h"
+#include "decoder_openjpeg.h"
+#include <openjpeg.h>
+#include <cstring>
+
+#include <vector>
+#include <cassert>
+#include <memory>
+#include <string>
+
+static const int OPENJPEG_PLUGIN_PRIORITY = 100;
+static const int OPENJPEG_PLUGIN_PRIORITY_HTJ2K = 90;
+
+struct openjpeg_decoder
+{
+  std::vector<uint8_t> encoded_data;
+  uintptr_t user_data;
+
+  size_t read_position = 0;
+  std::string error_message;
+};
+
+
+#define MAX_PLUGIN_NAME_LENGTH 80
+static char plugin_name[MAX_PLUGIN_NAME_LENGTH];
+
+static const char* openjpeg_plugin_name()
+{
+  snprintf(plugin_name, MAX_PLUGIN_NAME_LENGTH, "OpenJPEG %s", opj_version());
+  plugin_name[MAX_PLUGIN_NAME_LENGTH - 1] = 0;
+
+  return plugin_name;
+}
+
+
+static void openjpeg_init_plugin()
+{
+}
+
+
+static void openjpeg_deinit_plugin()
+{
+}
+
+
+static int openjpeg_does_support_format(heif_compression_format format)
+{
+  if (format == heif_compression_JPEG2000) {
+    return OPENJPEG_PLUGIN_PRIORITY;
+  }
+  else if (format == heif_compression_HTJ2K) {
+    return OPENJPEG_PLUGIN_PRIORITY_HTJ2K;
+  }
+  else {
+    return 0;
+  }
+}
+
+static int openjpeg_does_support_format2(const heif_decoder_plugin_compressed_format_description* format)
+{
+  return openjpeg_does_support_format(format->format);
+}
+
+heif_error openjpeg_new_decoder2(void** dec, const heif_decoder_plugin_options* options)
+{
+  openjpeg_decoder* decoder = new openjpeg_decoder();
+
+  *dec = decoder;
+
+  return heif_error_ok;
+}
+
+heif_error openjpeg_new_decoder(void** dec)
+{
+  heif_decoder_plugin_options options;
+  options.format = heif_compression_JPEG2000;
+  options.num_threads = 0;
+  options.strict_decoding = false;
+
+  return openjpeg_new_decoder2(dec, &options);
+}
+
+void openjpeg_free_decoder(void* decoder_raw)
+{
+  openjpeg_decoder* decoder = (openjpeg_decoder*) decoder_raw;
+
+  if (!decoder) {
+    return;
+  }
+
+  delete decoder;
+}
+
+
+void openjpeg_set_strict_decoding(void* decoder_raw, int flag)
+{
+
+}
+
+
+heif_error openjpeg_push_data2(void* decoder_raw, const void* frame_data, size_t frame_size,
+                               uintptr_t user_data)
+{
+  openjpeg_decoder* decoder = (openjpeg_decoder*) decoder_raw;
+  const uint8_t* frame_data_src = (const uint8_t*) frame_data;
+
+  decoder->encoded_data.insert(decoder->encoded_data.end(), frame_data_src, frame_data_src + frame_size);
+  decoder->user_data = user_data;
+
+  return heif_error_ok;
+}
+
+heif_error openjpeg_push_data(void* decoder_raw, const void* frame_data, size_t frame_size)
+{
+  return openjpeg_push_data2(decoder_raw, frame_data, frame_size, 0);
+}
+
+//**************************************************************************
+
+//  This will read from our memory to the buffer.
+
+static OPJ_SIZE_T opj_memory_stream_read(void* p_buffer, OPJ_SIZE_T p_nb_bytes, void* p_user_data)
+{
+  openjpeg_decoder* decoder = (openjpeg_decoder*) p_user_data; // Our data.
+  size_t data_size = decoder->encoded_data.size();
+
+  OPJ_SIZE_T l_nb_bytes_read = p_nb_bytes; // Amount to move to buffer.
+
+  // Check if the current offset is outside our data buffer.
+
+  if (decoder->read_position >= data_size) {
+    return (OPJ_SIZE_T) -1;
+  }
+
+  // Check if we are reading more than we have.
+
+  if (p_nb_bytes > (data_size - decoder->read_position)) {
+    //Read all we have.
+    l_nb_bytes_read = data_size - decoder->read_position;
+  }
+
+  // Copy the data to the internal buffer.
+
+  memcpy(p_buffer, &(decoder->encoded_data[decoder->read_position]), l_nb_bytes_read);
+
+  decoder->read_position += l_nb_bytes_read; // Update the pointer to the new location.
+
+  return l_nb_bytes_read;
+}
+
+
+// This will write from the buffer to our memory.
+
+static OPJ_SIZE_T opj_memory_stream_write(void* p_buffer, OPJ_SIZE_T p_nb_bytes, void* p_user_data)
+{
+  assert(false); // We should never need to write to the buffer.
+  return 0;
+}
+
+
+// Moves the pointer forward, but never more than we have.
+
+static OPJ_OFF_T opj_memory_stream_skip(OPJ_OFF_T p_nb_bytes, void* p_user_data)
+{
+  openjpeg_decoder* decoder = (openjpeg_decoder*) p_user_data; // Our data.
+  size_t data_size = decoder->encoded_data.size();
+
+  OPJ_SIZE_T l_nb_bytes;
+
+
+  if (p_nb_bytes < 0) {
+    //No skipping backwards.
+    return -1;
+  }
+
+  l_nb_bytes = (OPJ_SIZE_T) p_nb_bytes; // Allowed because it is positive.
+
+  // Do not allow jumping past the end.
+
+  if (l_nb_bytes > data_size - decoder->read_position) {
+    l_nb_bytes = data_size - decoder->read_position;//Jump the max.
+  }
+
+  // Make the jump.
+
+  decoder->read_position += l_nb_bytes;
+
+  // Return how far we jumped.
+
+  return l_nb_bytes;
+}
+
+
+// Sets the pointer to anywhere in the memory.
+
+static OPJ_BOOL opj_memory_stream_seek(OPJ_OFF_T p_nb_bytes, void* p_user_data)
+{
+  openjpeg_decoder* decoder = (openjpeg_decoder*) p_user_data; // Our data.
+  size_t data_size = decoder->encoded_data.size();
+
+  // No before the buffer.
+  if (p_nb_bytes < 0)
+    return OPJ_FALSE;
+
+  // No after the buffer.
+  if (p_nb_bytes > (OPJ_OFF_T) data_size)
+    return OPJ_FALSE;
+
+  // Move to new position.
+  decoder->read_position = (OPJ_SIZE_T) p_nb_bytes;
+
+  return OPJ_TRUE;
+}
+
+//The system needs a routine to do when finished, the name tells you what I want it to do.
+
+static void opj_memory_stream_do_nothing(void* p_user_data)
+{
+  OPJ_ARG_NOT_USED(p_user_data);
+}
+
+
+// Create a stream to use memory as the input or output.
+
+opj_stream_t* opj_stream_create_default_memory_stream(openjpeg_decoder* p_decoder, OPJ_BOOL p_is_read_stream)
+{
+  opj_stream_t* stream;
+
+  if (!(stream = opj_stream_default_create(p_is_read_stream))) {
+    return nullptr;
+  }
+
+  // Set how to work with the frame buffer.
+
+  if (p_is_read_stream) {
+    opj_stream_set_read_function(stream, opj_memory_stream_read);
+  }
+  else {
+    opj_stream_set_write_function(stream, opj_memory_stream_write);
+  }
+
+  opj_stream_set_seek_function(stream, opj_memory_stream_seek);
+
+  opj_stream_set_skip_function(stream, opj_memory_stream_skip);
+
+  opj_stream_set_user_data(stream, p_decoder, opj_memory_stream_do_nothing);
+
+  opj_stream_set_user_data_length(stream, p_decoder->encoded_data.size());
+
+  return stream;
+}
+
+
+//**************************************************************************
+
+
+heif_error openjpeg_decode_next_image2(void* decoder_raw, heif_image** out_img,
+                                       uintptr_t* out_user_data,
+                                       const heif_security_limits* limits)
+{
+  auto* decoder = (struct openjpeg_decoder*) decoder_raw;
+
+  if (decoder->encoded_data.empty()) {
+    *out_img = nullptr;
+    return heif_error_ok;
+  }
+
+
+  OPJ_BOOL success;
+  opj_dparameters_t decompression_parameters;
+  std::unique_ptr<opj_codec_t, void (OPJ_CALLCONV *)(opj_codec_t*)> l_codec(opj_create_decompress(OPJ_CODEC_J2K),
+                                                               opj_destroy_codec);
+
+  // Initialize Decoder
+  opj_set_default_decoder_parameters(&decompression_parameters);
+  success = opj_setup_decoder(l_codec.get(), &decompression_parameters);
+  if (!success) {
+    return {heif_error_Decoder_plugin_error, heif_suberror_Unspecified, "opj_setup_decoder()"};
+  }
+
+
+  // Create Input Stream
+
+  OPJ_BOOL is_read_stream = true;
+  std::unique_ptr<opj_stream_t, void (OPJ_CALLCONV *)(opj_stream_t*)> stream(opj_stream_create_default_memory_stream(decoder, is_read_stream),
+                                                                opj_stream_destroy);
+
+
+  // Read Codestream Header
+  opj_image_t* image_ptr = nullptr;
+  success = opj_read_header(stream.get(), l_codec.get(), &image_ptr);
+  if (!success) {
+    return {heif_error_Decoder_plugin_error, heif_suberror_Unspecified, "opj_read_header()"};
+  }
+
+  std::unique_ptr<opj_image_t, void (OPJ_CALLCONV *)(opj_image_t*)> image(image_ptr, opj_image_destroy);
+
+  if (image->numcomps != 3 && image->numcomps != 1) {
+    //TODO - Handle other numbers of components
+    return {heif_error_Unsupported_feature, heif_suberror_Unsupported_data_version, "Number of components must be 3 or 1"};
+  }
+  else if ((image->color_space != OPJ_CLRSPC_UNSPECIFIED) && (image->color_space != OPJ_CLRSPC_SRGB)) {
+    //TODO - Handle other colorspaces
+    return {heif_error_Unsupported_feature, heif_suberror_Unsupported_data_version, "Colorspace must be SRGB"};
+  }
+
+  const int width = (image->x1 - image->x0);
+  const int height = (image->y1 - image->y0);
+
+
+  /* Get the decoded image */
+  success = opj_decode(l_codec.get(), stream.get(), image.get());
+  if (!success) {
+    return {heif_error_Decoder_plugin_error, heif_suberror_Unspecified, "opj_decode()"};
+  }
+
+
+  success = opj_end_decompress(l_codec.get(), stream.get());
+  if (!success) {
+    return {heif_error_Decoder_plugin_error, heif_suberror_Unspecified, "opj_end_decompress()"};
+  }
+
+
+  heif_colorspace colorspace = heif_colorspace_YCbCr;
+  heif_chroma chroma = heif_chroma_444; //heif_chroma_interleaved_RGB;
+
+  std::vector<heif_channel> channels;
+
+  if (image->numcomps == 1) {
+    colorspace = heif_colorspace_monochrome;
+    chroma = heif_chroma_monochrome;
+    channels = {heif_channel_Y};
+  }
+  else if (image->numcomps == 3 &&
+           image->comps[1].dx == 1 &&
+           image->comps[1].dy == 1) {
+    colorspace = heif_colorspace_YCbCr;
+    chroma = heif_chroma_444;
+    channels = {heif_channel_Y, heif_channel_Cb, heif_channel_Cr};
+  }
+  else if (image->numcomps == 3 &&
+           image->comps[1].dx == 2 &&
+           image->comps[1].dy == 1) {
+    colorspace = heif_colorspace_YCbCr;
+    chroma = heif_chroma_422;
+    channels = {heif_channel_Y, heif_channel_Cb, heif_channel_Cr};
+  }
+  else if (image->numcomps == 3 &&
+           image->comps[1].dx == 2 &&
+           image->comps[1].dy == 2) {
+    colorspace = heif_colorspace_YCbCr;
+    chroma = heif_chroma_420;
+    channels = {heif_channel_Y, heif_channel_Cb, heif_channel_Cr};
+  }
+  else {
+    return {heif_error_Decoder_plugin_error, heif_suberror_Unspecified, "unsupported image format"};
+  }
+
+
+  heif_error error = heif_image_create(width, height, colorspace, chroma, out_img);
+  if (error.code) {
+    return error;
+  }
+
+  for (size_t c = 0; c < image->numcomps; c++) {
+    const opj_image_comp_t& opj_comp = image->comps[c];
+
+    int bit_depth = opj_comp.prec;
+    int cwidth = opj_comp.w;
+    int cheight = opj_comp.h;
+
+    error = heif_image_add_plane_safe(*out_img, channels[c], cwidth, cheight, bit_depth, limits);
+    if (error.code) {
+      // copy error message to decoder object because heif_image will be released
+      decoder->error_message = error.message;
+      error.message = decoder->error_message.c_str();
+
+      heif_image_release(*out_img);
+      *out_img = nullptr;
+      return error;
+    }
+
+    size_t stride = 0;
+    uint8_t* p = heif_image_get_plane2(*out_img, channels[c], &stride);
+
+
+    // TODO: a SIMD implementation to convert int32 to uint8 would speed this up
+    // https://stackoverflow.com/questions/63774643/how-to-convert-uint32-to-uint8-using-simd-but-not-avx512
+
+    if (bit_depth <= 8) {
+      for (int y = 0; y < cheight; y++) {
+        for (int x = 0; x < cwidth; x++) {
+          p[y * stride + x] = (uint8_t) opj_comp.data[y * cwidth + x];
+        }
+      }
+    }
+    else {
+      uint16_t* p16 = (uint16_t*)p;
+      for (int y = 0; y < cheight; y++) {
+        for (int x = 0; x < cwidth; x++) {
+          p16[y * stride/2 + x] = (uint16_t) opj_comp.data[y * cwidth + x];
+        }
+      }
+    }
+  }
+
+  if (out_user_data) {
+    *out_user_data = decoder->user_data;
+  }
+
+  decoder->encoded_data.clear();
+  decoder->read_position = 0;
+
+  return heif_error_ok;
+}
+
+heif_error openjpeg_decode_next_image(void* decoder_raw, heif_image** out_img,
+                                      const heif_security_limits* limits)
+{
+  return openjpeg_decode_next_image2(decoder_raw, out_img, nullptr, limits);
+}
+
+heif_error openjpeg_decode_image(void* decoder_raw, heif_image** out_img)
+{
+  auto* limits = heif_get_global_security_limits();
+  return openjpeg_decode_next_image(decoder_raw, out_img, limits);
+}
+
+heif_error openjpeg_flush_data(void* decoder)
+{
+  return heif_error_ok;
+}
+
+
+static const heif_decoder_plugin decoder_openjpeg{
+    5,
+    openjpeg_plugin_name,
+    openjpeg_init_plugin,
+    openjpeg_deinit_plugin,
+    openjpeg_does_support_format,
+    openjpeg_new_decoder,
+    openjpeg_free_decoder,
+    openjpeg_push_data,
+    openjpeg_decode_image,
+    openjpeg_set_strict_decoding,
+    "openjpeg",
+    openjpeg_decode_next_image,
+    /* minimum_required_libheif_version */ LIBHEIF_MAKE_VERSION(1,21,0),
+    openjpeg_does_support_format2,
+    openjpeg_new_decoder2,
+    openjpeg_push_data2,
+    openjpeg_flush_data,
+    openjpeg_decode_next_image2
+};
+
+const heif_decoder_plugin* get_decoder_plugin_openjpeg()
+{
+  return &decoder_openjpeg;
+}
+
+
+#if PLUGIN_OPENJPEG_DECODER
+heif_plugin_info plugin_info {
+  1,
+  heif_plugin_type_decoder,
+  &decoder_openjpeg
+};
+#endif
diff --git a/libheif/plugins/decoder_openjpeg.h b/libheif/plugins/decoder_openjpeg.h
new file mode 100644
index 0000000000..8380acb9e5
--- /dev/null
+++ b/libheif/plugins/decoder_openjpeg.h
@@ -0,0 +1,36 @@
+/*
+ * OpenJPEG codec.
+ * Copyright (c) 2023 Devon Sookhoo
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_DECODER_OPENJPEG_H
+#define LIBHEIF_DECODER_OPENJPEG_H
+
+#include "common_utils.h"
+
+const struct heif_decoder_plugin* get_decoder_plugin_openjpeg();
+
+
+#if PLUGIN_OPENJPEG_DECODER
+extern "C" {
+MAYBE_UNUSED LIBHEIF_API extern heif_plugin_info plugin_info;
+}
+#endif
+
+#endif //LIBHEIF_DECODER_OPENJPEG_H
diff --git a/libheif/plugins/decoder_uncompressed.cc b/libheif/plugins/decoder_uncompressed.cc
new file mode 100644
index 0000000000..3c9f06aa14
--- /dev/null
+++ b/libheif/plugins/decoder_uncompressed.cc
@@ -0,0 +1,73 @@
+/*
+ * JPEG codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "libheif/heif.h"
+#include "libheif/heif_plugin.h"
+#include "decoder_uncompressed.h"
+
+struct uncompressed_decoder
+{
+};
+
+static const int UNCOMPRESSED_PLUGIN_PRIORITY = 100;
+
+
+static const char* uncompressed_plugin_name()
+{
+  return "builtin";
+}
+
+
+static int uncompressed_does_support_format(enum heif_compression_format format)
+{
+  if (format == heif_compression_uncompressed) {
+    return UNCOMPRESSED_PLUGIN_PRIORITY;
+  }
+  else {
+    return 0;
+  }
+}
+
+
+
+
+static const heif_decoder_plugin decoder_uncompressed
+    {
+        5,
+        uncompressed_plugin_name,
+        nullptr,
+        nullptr,
+        uncompressed_does_support_format,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr,
+        "uncompressed",
+        nullptr,
+        /* minimum_required_libheif_version */ LIBHEIF_MAKE_VERSION(1,0,0),
+        nullptr
+    };
+
+
+const heif_decoder_plugin* get_decoder_plugin_uncompressed()
+{
+  return &decoder_uncompressed;
+}
diff --git a/libheif/plugins/decoder_uncompressed.h b/libheif/plugins/decoder_uncompressed.h
new file mode 100644
index 0000000000..d20a6dd9aa
--- /dev/null
+++ b/libheif/plugins/decoder_uncompressed.h
@@ -0,0 +1,28 @@
+/*
+ * Dummy decoder plugin for the 'uncompressed' codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_DECODER_UNCOMPRESSED_H
+#define LIBHEIF_DECODER_UNCOMPRESSED_H
+
+#include "common_utils.h"
+
+const struct heif_decoder_plugin* get_decoder_plugin_uncompressed();
+
+#endif
diff --git a/libheif/plugins/decoder_vvdec.cc b/libheif/plugins/decoder_vvdec.cc
new file mode 100644
index 0000000000..14b3e9fd2b
--- /dev/null
+++ b/libheif/plugins/decoder_vvdec.cc
@@ -0,0 +1,451 @@
+/*
+ * AVIF codec.
+ * Copyright (c) 2019 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "libheif/heif.h"
+#include "libheif/heif_plugin.h"
+#include "decoder_vvdec.h"
+#include <cstring>
+#include <cassert>
+#include <vector>
+#include <algorithm>
+#include <deque>
+#include <string>
+
+#include <vvdec/vvdec.h>
+#include <utility>
+
+#if 0
+#include <iostream>
+#include <logging.h>
+#endif
+
+
+struct vvdec_decoder
+{
+  vvdecDecoder* decoder = nullptr;
+  vvdecAccessUnit* au = nullptr;
+
+  bool strict_decoding = false;
+
+  struct Packet
+  {
+    std::vector<uint8_t> data;
+    uintptr_t user_data;
+  };
+  std::deque<Packet> nalus;
+  bool end_of_stream_reached = false;
+
+  std::string error_message;
+};
+
+static const char kEmptyString[] = "";
+static const char kSuccess[] = "Success";
+
+static const int VVDEC_PLUGIN_PRIORITY = 100;
+
+#define MAX_PLUGIN_NAME_LENGTH 80
+
+static char plugin_name[MAX_PLUGIN_NAME_LENGTH];
+
+
+static const char* vvdec_plugin_name()
+{
+  const char* version = vvdec_get_version();
+
+  if (strlen(version) < 60) {
+    sprintf(plugin_name, "VVCDEC decoder (%s)", version);
+  }
+  else {
+    strcpy(plugin_name, "VVDEC decoder");
+  }
+
+  return plugin_name;
+}
+
+
+static void vvdec_init_plugin()
+{
+}
+
+
+static void vvdec_deinit_plugin()
+{
+}
+
+
+static int vvdec_does_support_format(heif_compression_format format)
+{
+  if (format == heif_compression_VVC) {
+    return VVDEC_PLUGIN_PRIORITY;
+  }
+  else {
+    return 0;
+  }
+}
+
+
+static int vvdec_does_support_format2(const heif_decoder_plugin_compressed_format_description* format)
+{
+  return vvdec_does_support_format(format->format);
+}
+
+heif_error vvdec_new_decoder2(void** dec, const heif_decoder_plugin_options* options)
+{
+  auto* decoder = new vvdec_decoder();
+
+  vvdecParams params;
+  vvdec_params_default(&params);
+  params.logLevel = VVDEC_INFO;
+
+  if (options->num_threads) {
+    params.threads = options->num_threads;
+  }
+  decoder->decoder = vvdec_decoder_open(&params);
+
+  const int MaxNaluSize = 256 * 1024;
+  decoder->au = vvdec_accessUnit_alloc();
+  vvdec_accessUnit_default(decoder->au);
+  vvdec_accessUnit_alloc_payload(decoder->au, MaxNaluSize);
+
+  *dec = decoder;
+
+  return {heif_error_Ok, heif_suberror_Unspecified, kSuccess};
+}
+
+
+heif_error vvdec_new_decoder(void** dec)
+{
+  heif_decoder_plugin_options options;
+  options.format = heif_compression_VVC;
+  options.num_threads = 0;
+  options.strict_decoding = false;
+
+  vvdec_new_decoder2(dec, &options);
+
+  return {};
+}
+
+
+void vvdec_free_decoder(void* decoder_raw)
+{
+  auto* decoder = (vvdec_decoder*) decoder_raw;
+
+  if (!decoder) {
+    return;
+  }
+
+  if (decoder->au) {
+    vvdec_accessUnit_free(decoder->au);
+    decoder->au = nullptr;
+  }
+
+  if (decoder->decoder) {
+    vvdec_decoder_close(decoder->decoder);
+    decoder->decoder = nullptr;
+  }
+
+  delete decoder;
+}
+
+
+void vvdec_set_strict_decoding(void* decoder_raw, int flag)
+{
+  auto* decoder = (vvdec_decoder*) decoder_raw;
+
+  decoder->strict_decoding = flag;
+}
+
+
+heif_error vvdec_push_data2(void* decoder_raw, const void* frame_data, size_t frame_size,
+                            uintptr_t user_data)
+{
+  auto* decoder = (vvdec_decoder*) decoder_raw;
+
+  const auto* data = (const uint8_t*) frame_data;
+
+  if (frame_size < 4) {
+    return {
+      heif_error_Decoder_plugin_error,
+      heif_suberror_End_of_data,
+      kEmptyString
+    };
+  }
+
+  for (;;) {
+    uint32_t size = four_bytes_to_uint32(data[0], data[1], data[2], data[3]);
+
+    if (frame_size < 4 + size) {
+      return {
+        heif_error_Decoder_plugin_error,
+        heif_suberror_End_of_data,
+        kEmptyString
+      };
+    }
+
+    data += 4;
+
+    std::vector<uint8_t> nalu;
+    nalu.push_back(0);
+    nalu.push_back(0);
+    nalu.push_back(1);
+    nalu.insert(nalu.end(), data, data + size);
+
+    decoder->nalus.push_back({std::move(nalu), user_data});
+    data += size;
+    frame_size -= 4 + size;
+    if (frame_size == 0) {
+      break;
+    }
+  }
+
+  return heif_error_ok;
+}
+
+heif_error vvdec_push_data(void* decoder_raw, const void* frame_data, size_t frame_size)
+{
+  return vvdec_push_data2(decoder_raw, frame_data, frame_size, 0);
+}
+
+heif_error vvdec_decode_next_image2(void* decoder_raw, heif_image** out_img,
+                                    uintptr_t* out_user_data,
+                                    const heif_security_limits* limits)
+{
+  auto* decoder = (vvdec_decoder*) decoder_raw;
+
+  vvdecFrame* frame = nullptr;
+
+  // --- prepare AU payload with maximum NALU size
+
+  size_t max_payload_size = 0;
+  for (const auto& nalu : decoder->nalus) {
+    max_payload_size = std::max(max_payload_size, nalu.data.size());
+  }
+
+  if (decoder->au == nullptr || max_payload_size > (size_t) decoder->au->payloadSize) {
+    if (decoder->au) {
+      vvdec_accessUnit_free(decoder->au);
+    }
+
+    decoder->au = vvdec_accessUnit_alloc();
+    vvdec_accessUnit_default(decoder->au);
+    vvdec_accessUnit_alloc_payload(decoder->au, (int)max_payload_size);
+  }
+
+  // --- feed NALUs into decoder, flush when done
+
+  for (;;) {
+    int ret;
+
+    // -> end of stream reached
+    if (decoder->nalus.empty() && decoder->end_of_stream_reached) {
+      ret = vvdec_flush(decoder->decoder, &frame);
+    }
+    // -> not enough data to decode an image
+    else if (decoder->nalus.empty()) {
+      *out_img = nullptr;
+      return heif_error_ok;
+    }
+    // -> push NALs from queue into decoder
+    else {
+      const auto& nalu = decoder->nalus.front();
+
+      memcpy(decoder->au->payload, nalu.data.data(), nalu.data.size());
+      decoder->au->payloadUsedSize = (int) nalu.data.size();
+      decoder->au->cts = nalu.user_data;
+      decoder->au->ctsValid = true;
+      decoder->nalus.pop_front();
+      ret = vvdec_decode(decoder->decoder, decoder->au, &frame);
+    }
+
+    if (ret == VVDEC_OK && frame) {
+      break;
+    }
+
+    if (ret == VVDEC_EOF) {
+      assert(!frame);
+      *out_img = nullptr;
+      return heif_error_ok;
+    }
+
+    if (ret != VVDEC_OK && ret != VVDEC_TRY_AGAIN) {
+      return {heif_error_Decoder_plugin_error, heif_suberror_Unspecified, "vvdec decoding error"};
+    }
+  }
+
+  if (out_user_data) {
+    *out_user_data = frame->cts;
+  }
+
+
+  // --- convert decoded frame to heif_image
+
+  heif_chroma chroma;
+  heif_colorspace colorspace;
+
+  if (frame->colorFormat == VVDEC_CF_YUV400_PLANAR) {
+    chroma = heif_chroma_monochrome;
+    colorspace = heif_colorspace_monochrome;
+  }
+  else {
+    if (frame->colorFormat == VVDEC_CF_YUV444_PLANAR) {
+      chroma = heif_chroma_444;
+    }
+    else if (frame->colorFormat == VVDEC_CF_YUV422_PLANAR) {
+      chroma = heif_chroma_422;
+    }
+    else {
+      chroma = heif_chroma_420;
+    }
+    colorspace = heif_colorspace_YCbCr;
+  }
+
+  heif_image* heif_img = nullptr;
+  heif_error err = heif_image_create((int) frame->width,
+                                     (int) frame->height,
+                                     colorspace,
+                                     chroma,
+                                     &heif_img);
+  if (err.code != heif_error_Ok) {
+    assert(heif_img == nullptr);
+    return err;
+  }
+
+
+  // --- read nclx parameters from decoded AV1 bitstream
+
+#if 0
+  heif_color_profile_nclx nclx;
+  nclx.version = 1;
+  HEIF_WARN_OR_FAIL(decoder->strict_decoding, heif_img, heif_nclx_color_profile_set_color_primaries(&nclx, static_cast<uint16_t>(img->cp)), { heif_image_release(heif_img); });
+  HEIF_WARN_OR_FAIL(decoder->strict_decoding, heif_img, heif_nclx_color_profile_set_transfer_characteristics(&nclx, static_cast<uint16_t>(img->tc)), { heif_image_release(heif_img); });
+  HEIF_WARN_OR_FAIL(decoder->strict_decoding, heif_img, heif_nclx_color_profile_set_matrix_coefficients(&nclx, static_cast<uint16_t>(img->mc)), { heif_image_release(heif_img); });
+  nclx.full_range_flag = (img->range == AOM_CR_FULL_RANGE);
+  heif_image_set_nclx_color_profile(heif_img, &nclx);
+#endif
+
+  // --- transfer data from vvdecFrame to HeifPixelImage
+
+  heif_channel channel2plane[3] = {
+      heif_channel_Y,
+      heif_channel_Cb,
+      heif_channel_Cr
+  };
+
+
+  int num_planes = (chroma == heif_chroma_monochrome ? 1 : 3);
+
+  for (int c = 0; c < num_planes; c++) {
+    int bpp = (int)frame->bitDepth;
+
+    const auto& plane = frame->planes[c];
+    const uint8_t* data = plane.ptr;
+    int stride = (int)plane.stride;
+
+    int w = (int)plane.width;
+    int h = (int)plane.height;
+
+    err = heif_image_add_plane_safe(heif_img, channel2plane[c], w, h, bpp, limits);
+    if (err.code != heif_error_Ok) {
+      // copy error message to decoder object because heif_image will be released
+      decoder->error_message = err.message;
+      err.message = decoder->error_message.c_str();
+
+      heif_image_release(heif_img);
+      return err;
+    }
+
+    size_t dst_stride;
+    uint8_t* dst_mem = heif_image_get_plane2(heif_img, channel2plane[c], &dst_stride);
+
+    int bytes_per_pixel = (bpp + 7) / 8;
+
+    for (int y = 0; y < h; y++) {
+      memcpy(dst_mem + y * dst_stride, data + y * stride, w * bytes_per_pixel);
+    }
+
+#if 0
+      std::cout << "DATA " << c << " " << w << " " << h << " bpp:" << bpp << "\n";
+      std::cout << write_raw_data_as_hex(dst_mem, w*h, {}, {});
+      std::cout << "---\n";
+#endif
+  }
+
+  *out_img = heif_img;
+
+  vvdec_frame_unref(decoder->decoder, frame);
+
+  return err;
+}
+
+heif_error vvdec_decode_next_image(void* decoder_raw, heif_image** out_img,
+                                   const heif_security_limits* limits)
+{
+  return vvdec_decode_next_image2(decoder_raw, out_img, nullptr, limits);
+}
+
+heif_error vvdec_decode_image(void* decoder_raw, heif_image** out_img)
+{
+  auto* limits = heif_get_global_security_limits();
+  return vvdec_decode_next_image(decoder_raw, out_img, limits);
+}
+
+heif_error vvdec_flush_data(void* decoder_raw)
+{
+  auto* decoder = (vvdec_decoder*) decoder_raw;
+  decoder->end_of_stream_reached = true;
+  return heif_error_ok;
+}
+
+static const heif_decoder_plugin decoder_vvdec
+    {
+      5,
+      vvdec_plugin_name,
+      vvdec_init_plugin,
+      vvdec_deinit_plugin,
+      vvdec_does_support_format,
+      vvdec_new_decoder,
+      vvdec_free_decoder,
+      vvdec_push_data,
+      vvdec_decode_image,
+      vvdec_set_strict_decoding,
+      "vvdec",
+      vvdec_decode_next_image,
+      /* minimum_required_libheif_version */ LIBHEIF_MAKE_VERSION(1,21,0),
+      vvdec_does_support_format2,
+      vvdec_new_decoder2,
+      vvdec_push_data2,
+      vvdec_flush_data,
+      vvdec_decode_next_image2
+    };
+
+
+const heif_decoder_plugin* get_decoder_plugin_vvdec()
+{
+  return &decoder_vvdec;
+}
+
+
+#if PLUGIN_VVDEC
+heif_plugin_info plugin_info {
+  1,
+  heif_plugin_type_decoder,
+  &decoder_vvdec
+};
+#endif
diff --git a/libheif/plugins/decoder_vvdec.h b/libheif/plugins/decoder_vvdec.h
new file mode 100644
index 0000000000..15f01df2c6
--- /dev/null
+++ b/libheif/plugins/decoder_vvdec.h
@@ -0,0 +1,34 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_DECODER_VVDEC_H
+#define LIBHEIF_DECODER_VVDEC_H
+
+#include "common_utils.h"
+
+const struct heif_decoder_plugin* get_decoder_plugin_vvdec();
+
+#if PLUGIN_VVDEC
+extern "C" {
+MAYBE_UNUSED LIBHEIF_API extern heif_plugin_info plugin_info;
+}
+#endif
+
+#endif
diff --git a/libheif/plugins/decoder_webcodecs.cc b/libheif/plugins/decoder_webcodecs.cc
new file mode 100644
index 0000000000..a6b2388038
--- /dev/null
+++ b/libheif/plugins/decoder_webcodecs.cc
@@ -0,0 +1,910 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2025 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "decoder_webcodecs.h"
+#include "libheif/heif_plugin.h"
+#include "codecs/hevc_boxes.h"
+#include "bitstream.h"
+#include "nalu_utils.h"
+
+#include <algorithm>
+#include <assert.h>
+#include <cstring>
+#include <emscripten/emscripten.h>
+#include <cstdio>
+#include <emscripten/bind.h>
+#include <memory>
+#include <queue>
+#include <string>
+#include <vector>
+
+
+struct NALUnit {
+  void* data;
+  size_t size;
+};
+
+struct webcodecs_decoder
+{
+  std::queue<NALUnit> data_queue;
+};
+
+static const char kEmptyString[] = "";
+static const char kSuccess[] = "Success";
+
+static const int WEBCODECS_PLUGIN_PRIORITY = 80;
+
+#define MAX_PLUGIN_NAME_LENGTH 80
+
+static char plugin_name[MAX_PLUGIN_NAME_LENGTH];
+
+/** 
+ * Decodes a HEVC frame using the browser's WebCodecs API. This implementation
+ * prefers hardware decoding when available.
+ *
+ * As of this writing, most HEIC images will be decoded directly into the NV12
+ * pixel format. For images returned in NV12 or planar YUV format (I420, I422,
+ * I444), the format will be preserved when returning the data to C++.
+ *
+ * Any other image format returned by the WebCodecs API will be converted to
+ * RGBA before being returned to C++ to ensure that the result can be
+ * properly interpreted by the plugin.
+ * 
+ * Note that the WebCodecs API don't support converting into NV12 format in
+ * cases where the native pixel format is something else. That's why RGBA is
+ * used as a fallback format, b/c the browser can always convert to it.
+ */
+EM_JS(emscripten::EM_VAL, decode_with_browser_hevc, (const char *codec_ptr, uintptr_t hvcc_record_ptr, size_t hvcc_record_size, uintptr_t data_ptr, size_t data_size), {
+  return Asyncify.handleSleep((callback) => {
+    const codec = UTF8ToString(codec_ptr);
+    const data = HEAPU8.subarray(data_ptr, data_ptr + data_size);
+    const description = HEAPU8.subarray(hvcc_record_ptr, hvcc_record_ptr + hvcc_record_size);
+    let returnedError = false;
+
+    function returnError(err) {
+      if (!returnedError) {
+        returnedError = true;
+
+        console.error(err);
+        callback({'error': err.stack});
+      }
+    }
+
+    function handleEmptyFormat(decoded) {
+      const canvas = new OffscreenCanvas(decoded.codedWidth, decoded.codedHeight);
+      const context = canvas.getContext('2d');
+      context.drawImage(decoded, 0, 0);
+      const imageData = context.getImageData(0, 0, decoded.codedWidth, decoded.codedHeight);
+      const data = imageData.data;
+      const format = 'RGBA';
+      const planes = [{offset: 0, stride: decoded.codedWidth * 4}];
+      callback(Emval.toHandle({
+        'buffer': data,
+        'format': format,
+        'planes': planes,
+        'codedWidth': decoded.codedWidth, 
+        'codedHeight': decoded.codedHeight,
+      }));
+
+      decoded.close();
+    }
+
+    if (typeof VideoDecoder === 'undefined') {
+      returnError(new Error('VideoDecoder API is not available'));
+
+      return;
+    }
+
+    const decoder = new VideoDecoder({
+      output: (decoded) => {
+        // For 10-bit color images, the format is observed to be null. In this
+        // case the VideoFrame.copyTo API doesn't work, however, it does work
+        // to draw the VideoFrame to a Canvas and then extract the image bytes.
+        // Drawing to a canvas is slower than copyTo, so only use it when
+        // necessary.
+        if (!decoded.format) {
+          handleEmptyFormat(decoded);
+          return;
+        }
+
+        const nativeFormats = ['NV12', 'I420', 'I422', 'I444'];
+        const format = nativeFormats.includes(decoded.format) ? decoded.format : 'RGBA';
+        const fullRange = decoded.colorSpace ? decoded.colorSpace.fullRange : false;
+        const formatOptions = nativeFormats.includes(format) ?
+          {} :
+          {'format': format, 'colorSpace': 'srgb'};
+        const bufferSize = nativeFormats.includes(format) ?
+          decoded.allocationSize() :
+          decoded.codedWidth * decoded.codedHeight * 4;
+
+        const buffer = new Uint8Array(bufferSize);
+
+        Promise.resolve().then(
+          () => decoded.copyTo(buffer, formatOptions)
+        ).then((planes) => {
+          callback(Emval.toHandle({
+            'buffer': buffer,
+            'format': format,
+            'planes': planes,
+            'codedWidth': decoded.codedWidth, 
+            'codedHeight': decoded.codedHeight,
+            'fullRange': fullRange,
+          }));
+
+          decoded.close();
+        }).catch((e) => {
+          returnError(e);
+        });
+      },
+      error: (e) => {
+        returnError(e);
+      }
+    });
+
+    try {
+      decoder.configure({
+        codec,
+        hardwareAcceleration: 'prefer-hardware',
+        optimizeForLatency: true,
+        description,
+      });
+
+      const chunk = new EncodedVideoChunk({
+        timestamp: 0,
+        type: 'key',
+        data: data,
+      });
+
+      decoder.decode(chunk);
+      decoder.flush();
+    } catch (e) {
+      returnError(e);
+    }
+  });
+});
+
+
+static std::vector<uint8_t> remove_start_code_emulation2(const uint8_t* sps, size_t size)
+{
+  std::vector<uint8_t> out_data;
+
+  for (size_t i = 0; i < size; i++) {
+    if (i + 2 < size &&
+        sps[i] == 0 &&
+        sps[i + 1] == 0 &&
+        sps[i + 2] == 3) {
+      out_data.push_back(0);
+      out_data.push_back(0);
+      i += 2;
+    }
+    else {
+      out_data.push_back(sps[i]);
+    }
+  }
+
+  return out_data;
+}
+
+
+Error parse_sps_for_hvcC_configuration2(const uint8_t* sps, size_t size,
+                                       HEVCDecoderConfigurationRecord* config,
+                                       int* width, int* height)
+{
+  // remove start-code emulation bytes from SPS header stream
+
+  std::vector<uint8_t> sps_no_emul = remove_start_code_emulation2(sps, size);
+
+  sps = sps_no_emul.data();
+  size = sps_no_emul.size();
+
+
+  BitReader reader(sps, (int) size);
+
+  // skip NAL header
+  reader.skip_bits(2 * 8);
+
+  // skip VPS ID
+  reader.skip_bits(4);
+
+  uint8_t nMaxSubLayersMinus1 = reader.get_bits8(3);
+
+  config->temporal_id_nested = reader.get_bits8(1);
+
+  // --- profile_tier_level ---
+
+  config->general_profile_space = reader.get_bits8(2);
+  config->general_tier_flag = reader.get_bits8(1);
+  config->general_profile_idc = reader.get_bits8(5);
+  config->general_profile_compatibility_flags = reader.get_bits32(32);
+
+  reader.skip_bits(16); // skip reserved bits
+  reader.skip_bits(16); // skip reserved bits
+  reader.skip_bits(16); // skip reserved bits
+
+  config->general_level_idc = reader.get_bits8(8);
+
+  std::vector<bool> layer_profile_present(nMaxSubLayersMinus1);
+  std::vector<bool> layer_level_present(nMaxSubLayersMinus1);
+
+  for (int i = 0; i < nMaxSubLayersMinus1; i++) {
+    layer_profile_present[i] = reader.get_bits(1);
+    layer_level_present[i] = reader.get_bits(1);
+  }
+
+  if (nMaxSubLayersMinus1 > 0) {
+    for (int i = nMaxSubLayersMinus1; i < 8; i++) {
+      reader.skip_bits(2);
+    }
+  }
+
+  for (int i = 0; i < nMaxSubLayersMinus1; i++) {
+    if (layer_profile_present[i]) {
+      reader.skip_bits(2 + 1 + 5);
+      reader.skip_bits(32);
+      reader.skip_bits(16);
+    }
+
+    if (layer_level_present[i]) {
+      reader.skip_bits(8);
+    }
+  }
+
+
+  // --- SPS continued ---
+
+  int dummy, value;
+  reader.get_uvlc(&dummy); // skip seq_parameter_seq_id
+
+  reader.get_uvlc(&value);
+  config->chroma_format = (uint8_t) value;
+
+  if (config->chroma_format == 3) {
+    reader.skip_bits(1);
+  }
+
+  reader.get_uvlc(width);
+  reader.get_uvlc(height);
+
+  bool conformance_window = reader.get_bits(1);
+  if (conformance_window) {
+    int left, right, top, bottom;
+    reader.get_uvlc(&left);
+    reader.get_uvlc(&right);
+    reader.get_uvlc(&top);
+    reader.get_uvlc(&bottom);
+
+    //printf("conformance borders: %d %d %d %d\n",left,right,top,bottom);
+
+    int subH = 1, subV = 1;
+    if (config->chroma_format == 1) {
+      subV = 2;
+      subH = 2;
+    }
+    if (config->chroma_format == 2) { subH = 2; }
+
+    *width -= subH * (left + right);
+    *height -= subV * (top + bottom);
+  }
+
+  reader.get_uvlc(&value);
+  config->bit_depth_luma = (uint8_t) (value + 8);
+
+  reader.get_uvlc(&value);
+  config->bit_depth_chroma = (uint8_t) (value + 8);
+
+
+
+  // --- init static configuration fields ---
+
+  config->configuration_version = 1;
+  config->min_spatial_segmentation_idc = 0; // TODO: get this value from the VUI, 0 should be safe
+  config->parallelism_type = 0; // TODO, 0 should be safe
+  config->avg_frame_rate = 0; // makes no sense for HEIF
+  config->constant_frame_rate = 0; // makes no sense for HEIF
+  config->num_temporal_layers = 1; // makes no sense for HEIF
+
+  return Error::Ok;
+}
+
+
+static const char* webcodecs_plugin_name()
+{
+  strcpy(plugin_name, "Webcodecs HEVC decoder");
+
+  const char* webcodecs_version = "1";
+
+  if (strlen(webcodecs_version) + 10 < MAX_PLUGIN_NAME_LENGTH) {
+    strcat(plugin_name, ", version ");
+    strcat(plugin_name, webcodecs_version);
+  }
+
+  return plugin_name;
+}
+
+
+static void webcodecs_init_plugin()
+{
+
+}
+
+
+static void webcodecs_deinit_plugin()
+{
+
+}
+
+
+static int webcodecs_does_support_format(enum heif_compression_format format)
+{
+  if (format == heif_compression_HEVC) {
+    return WEBCODECS_PLUGIN_PRIORITY;
+  }
+  else {
+    return 0;
+  }
+}
+
+
+static struct heif_error webcodecs_new_decoder(void** dec)
+{
+  struct webcodecs_decoder* decoder = new webcodecs_decoder();
+  struct heif_error err = {heif_error_Ok, heif_suberror_Unspecified, kSuccess};
+
+  *dec = decoder;
+  return err;
+}
+
+
+static void webcodecs_free_decoder(void* decoder_raw)
+{
+  struct webcodecs_decoder* decoder = (struct webcodecs_decoder*) decoder_raw;
+
+  delete decoder;
+}
+
+
+static struct heif_error webcodecs_push_data(void* decoder_raw, const void* data, size_t size)
+{
+  struct webcodecs_decoder* decoder = (struct webcodecs_decoder*) decoder_raw;
+
+  const uint8_t* cdata = (const uint8_t*) data;
+
+  size_t ptr = 0;
+  while (ptr < size) {
+    if (4 > size - ptr) {
+      struct heif_error err = {heif_error_Decoder_plugin_error,
+                               heif_suberror_End_of_data,
+                               kEmptyString};
+      return err;
+    }
+
+    uint32_t nal_size = static_cast<uint32_t>((cdata[ptr] << 24) | (cdata[ptr + 1] << 16) | (cdata[ptr + 2] << 8) | (cdata[ptr + 3]));
+    ptr += 4;
+
+    if (nal_size > size - ptr) {
+      struct heif_error err = {heif_error_Decoder_plugin_error,
+                               heif_suberror_End_of_data,
+                               kEmptyString};
+      return err;
+    }
+
+    NALUnit nal_unit = {(void*)(cdata + ptr), nal_size};
+    decoder->data_queue.push(nal_unit);
+    ptr += nal_size;
+  }
+
+
+  struct heif_error err = {heif_error_Ok, heif_suberror_Unspecified, kSuccess};
+  return err;
+}
+
+
+static void normalize_luma_range(uint8_t* dst, int stride, int width, int height) {
+  // Luma data coming from the browser's VideoDecoder API may be using a
+  // limited range (16-235) instead of the full range (0-255). If this is the
+  // case, we need to normalize the data to the full range.
+  for (int y = 0; y < height; y++) {
+    uint8_t* p = dst + y * stride;
+    for (int x = 0; x < width; x++) {
+      float v = (static_cast<float>(p[x]) - 16.0f) * 255.0f / 219.0f;
+      p[x] = static_cast<uint8_t>(std::min(255.0f, std::max(0.0f, v + 0.5f)));
+    }
+  }
+}
+
+static void normalize_chroma_range(uint8_t* dst, int stride, int width, int height) {
+  // Chroma data coming from the browser's VideoDecoder API may be using a
+  // limited range (16-240) instead of the full range (0-255). If this is the
+  // case, we need to normalize the data to the full range.
+  for (int y = 0; y < height; y++) {
+    uint8_t* p = dst + y * stride;
+    for (int x = 0; x < width; x++) {
+      float v = (static_cast<float>(p[x]) - 16.0f) * 255.0f / 224.0f;
+      p[x] = static_cast<uint8_t>(std::min(255.0f, std::max(0.0f, v + 0.5f)));
+    }
+  }
+}
+
+static struct heif_error convert_planar_yuv_to_heif_image(
+    const uint8_t* y_src, int y_src_stride,
+    const uint8_t* u_src, int u_src_stride,
+    const uint8_t* v_src, int v_src_stride,
+    int width, int height,
+    struct heif_image** out_img,
+    heif_chroma chroma,
+    bool is_full_range) {
+  heif_error err;
+  bool is_mono = chroma == heif_chroma_monochrome;
+
+  int chroma_w = width;
+  int chroma_h = height;
+  if (chroma == heif_chroma_420 || is_mono) {
+    chroma_w = width / 2;
+    chroma_h = height / 2;
+  } else if (chroma == heif_chroma_422) {
+    chroma_w = width / 2;
+  }
+
+  err = heif_image_create(
+      width, height,
+      is_mono ? heif_colorspace_monochrome
+              : heif_colorspace_YCbCr,
+      is_mono ? heif_chroma_monochrome : chroma,
+      out_img);
+  if (err.code) {
+    return err;
+  }
+
+  err = heif_image_add_plane(
+      *out_img, heif_channel_Y, width, height, 8);
+  if (err.code) {
+    heif_image_release(*out_img);
+    return err;
+  }
+
+  int y_stride;
+  uint8_t* y_dst = heif_image_get_plane(
+      *out_img, heif_channel_Y, &y_stride);
+  for (int i = 0; i < height; ++i) {
+    memcpy(y_dst + i * y_stride,
+           y_src + i * y_src_stride,
+           width);
+  }
+
+  if (!is_full_range) {
+    normalize_luma_range(y_dst, y_stride, width, height);
+  }
+
+  if (!is_mono) {
+    err = heif_image_add_plane(
+        *out_img, heif_channel_Cb,
+        chroma_w, chroma_h, 8);
+    if (err.code) {
+      heif_image_release(*out_img);
+      return err;
+    }
+
+    err = heif_image_add_plane(
+        *out_img, heif_channel_Cr,
+        chroma_w, chroma_h, 8);
+    if (err.code) {
+      heif_image_release(*out_img);
+      return err;
+    }
+
+    int cb_stride;
+    uint8_t* cb_dst = heif_image_get_plane(
+        *out_img, heif_channel_Cb, &cb_stride);
+    for (int i = 0; i < chroma_h; ++i) {
+      memcpy(cb_dst + i * cb_stride,
+             u_src + i * u_src_stride,
+             chroma_w);
+    }
+
+    int cr_stride;
+    uint8_t* cr_dst = heif_image_get_plane(
+        *out_img, heif_channel_Cr, &cr_stride);
+    for (int i = 0; i < chroma_h; ++i) {
+      memcpy(cr_dst + i * cr_stride,
+             v_src + i * v_src_stride,
+             chroma_w);
+    }
+
+    if (!is_full_range) {
+      normalize_chroma_range(
+          cb_dst, cb_stride, chroma_w, chroma_h);
+      normalize_chroma_range(
+          cr_dst, cr_stride, chroma_w, chroma_h);
+    }
+  }
+
+  return {heif_error_Ok, heif_suberror_Unspecified, kSuccess};
+}
+
+static struct heif_error convert_nv12_to_heif_image(
+    const std::unique_ptr<uint8_t[]>& buffer,
+    int width, int height,
+    int y_offset, int y_src_stride,
+    int uv_offset, int uv_src_stride,
+    struct heif_image** out_img,
+    heif_chroma chroma,
+    bool is_full_range) {
+  bool is_mono = chroma == heif_chroma_monochrome;
+
+  if (is_mono) {
+    return convert_planar_yuv_to_heif_image(
+        buffer.get() + y_offset, y_src_stride,
+        nullptr, 0, nullptr, 0,
+        width, height, out_img,
+        heif_chroma_monochrome, is_full_range);
+  }
+
+  int chroma_w = width / 2;
+  int chroma_h = height / 2;
+  std::vector<uint8_t> u_buf(chroma_w * chroma_h);
+  std::vector<uint8_t> v_buf(chroma_w * chroma_h);
+
+  for (int i = 0; i < chroma_h; ++i) {
+    const uint8_t* uv_row =
+        buffer.get() + uv_offset + i * uv_src_stride;
+    for (int j = 0; j < chroma_w; ++j) {
+      u_buf[i * chroma_w + j] = uv_row[j * 2];
+      v_buf[i * chroma_w + j] = uv_row[j * 2 + 1];
+    }
+  }
+
+  return convert_planar_yuv_to_heif_image(
+      buffer.get() + y_offset, y_src_stride,
+      u_buf.data(), chroma_w,
+      v_buf.data(), chroma_w,
+      width, height, out_img,
+      heif_chroma_420, is_full_range);
+}
+
+/** 
+ * Generates a HEVC codec string as defined in ISO/IEC 14496-15 specification,
+ * Annex E.3.
+ */
+static std::string get_hevc_codec_string(const HEVCDecoderConfigurationRecord& config) {
+  std::string codec_string = "hvc1.";
+
+  // Profile IDC
+  codec_string += std::to_string(config.general_profile_idc);
+  codec_string += ".";
+
+  // Profile Compatibility Flags
+  uint32_t profile_compatibility_flags = config.general_profile_compatibility_flags;
+  char buffer[9];
+  snprintf(buffer, sizeof(buffer), "%X", profile_compatibility_flags);
+  codec_string += buffer;
+  codec_string += ".";
+
+  // Tier and Level
+  codec_string += (config.general_tier_flag ? "H" : "L");
+  codec_string += std::to_string(config.general_level_idc);
+  codec_string += ".";
+
+  // Constraint Indicator Flags
+  uint64_t constraint_flags = 0;
+  for (int i = 0; i < 48; ++i) {
+    if (config.general_constraint_indicator_flags[i]) {
+      constraint_flags |= (1ULL << (47 - i));
+    }
+  }
+  snprintf(buffer, sizeof(buffer), "%06X",
+           (unsigned int)(constraint_flags >> 24));
+  codec_string += buffer;
+
+  return codec_string;
+}
+
+
+
+
+static void get_nal_units(struct webcodecs_decoder* decoder,
+                          NALUnit& vps_nal_unit,
+                          NALUnit& sps_nal_unit,
+                          NALUnit& pps_nal_unit,
+                          NALUnit& data_unit) {
+  // This code parses the NAL units to find the VPS, SPS, PPS, and data NAL
+  // units. It handles cases where the NAL units are not in the expected order
+  // and where there are extra NAL units that should be ignored. The last seen
+  // VPS, SPS, PPS, and VCL data are used.
+  while (!decoder->data_queue.empty()) {
+    NALUnit nal_unit = decoder->data_queue.front();
+    decoder->data_queue.pop();
+
+    if (nal_unit.size == 0) {
+      continue;
+    }
+
+    const auto* nal_data = static_cast<const uint8_t*>(nal_unit.data);
+    const uint8_t nal_type = (nal_data[0] >> 1) & 0x3F;
+
+    if (nal_type == NAL_UNIT_VPS_NUT) {
+      vps_nal_unit = nal_unit;
+    } else if (nal_type == NAL_UNIT_SPS_NUT) {
+      sps_nal_unit = nal_unit;
+    } else if (nal_type == NAL_UNIT_PPS_NUT) {
+      pps_nal_unit = nal_unit;
+    } else if (nal_type <= NAL_UNIT_MAX_VCL) {
+      // Assume the plugin will only receive one VCL NAL unit.
+      data_unit = nal_unit;
+    }
+  }
+}
+
+
+static struct heif_error webcodecs_decode_image(void* decoder_raw,
+                                                  struct heif_image** out_img)
+{
+  struct webcodecs_decoder* decoder = (struct webcodecs_decoder*) decoder_raw;
+  *out_img = nullptr;
+
+  NALUnit vps_nal_unit = {nullptr, 0};
+  NALUnit sps_nal_unit = {nullptr, 0};
+  NALUnit pps_nal_unit = {nullptr, 0};
+  NALUnit data_unit = {nullptr, 0};
+
+  get_nal_units(decoder, vps_nal_unit, sps_nal_unit, pps_nal_unit, data_unit);
+
+  if (!vps_nal_unit.data || !sps_nal_unit.data || !pps_nal_unit.data || !data_unit.data) {
+    return {heif_error_Decoder_plugin_error,
+            heif_suberror_End_of_data,
+            "Missing required NAL units (VPS, SPS, PPS, or data)"};
+  }
+
+  HEVCDecoderConfigurationRecord config;
+  int w, h;
+  Error err = parse_sps_for_hvcC_configuration2((const uint8_t*)sps_nal_unit.data, sps_nal_unit.size, &config, &w, &h);
+  if (err != Error::Ok) {
+    return {heif_error_Decoder_plugin_error,
+            heif_suberror_Unspecified,
+            "Failed to parse SPS"};
+  }
+
+  config.m_nal_array.push_back(HEVCDecoderConfigurationRecord::NalArray{0, NAL_UNIT_VPS_NUT, {std::vector<uint8_t>((uint8_t*)vps_nal_unit.data, (uint8_t*)vps_nal_unit.data + vps_nal_unit.size)}});
+  config.m_nal_array.push_back(HEVCDecoderConfigurationRecord::NalArray{0, NAL_UNIT_SPS_NUT, {std::vector<uint8_t>((uint8_t*)sps_nal_unit.data, (uint8_t*)sps_nal_unit.data + sps_nal_unit.size)}});
+  config.m_nal_array.push_back(HEVCDecoderConfigurationRecord::NalArray{0, NAL_UNIT_PPS_NUT, {std::vector<uint8_t>((uint8_t*)pps_nal_unit.data, (uint8_t*)pps_nal_unit.data + pps_nal_unit.size)}});
+
+  StreamWriter writer;
+  config.write(writer);
+  std::vector<uint8_t> hvcc_record = writer.get_data();
+
+  // The WebCodecs API expects the NAL unit to be prefixed with its size (4 bytes, big-endian).
+  size_t nal_size = data_unit.size;
+  std::vector<uint8_t> data_with_size(4 + nal_size);
+  // Write length in Big Endian
+  data_with_size[0] = (nal_size >> 24) & 0xFF;
+  data_with_size[1] = (nal_size >> 16) & 0xFF;
+  data_with_size[2] = (nal_size >> 8) & 0xFF;
+  data_with_size[3] = nal_size & 0xFF;
+  // Append NAL payload
+  memcpy(data_with_size.data() + 4, data_unit.data, nal_size);
+
+  std::string codec_string = get_hevc_codec_string(config);
+
+  emscripten::val result = emscripten::val::take_ownership(
+    decode_with_browser_hevc(
+      codec_string.c_str(),
+      (uintptr_t)hvcc_record.data(),
+      hvcc_record.size(),
+      (uintptr_t)data_with_size.data(),
+      data_with_size.size()
+    )
+  );
+
+  if (!result["error"].isUndefined()) {
+    static char error_message[256];
+    std::string error_str = result["error"].as<std::string>();
+    snprintf(error_message, sizeof(error_message), "%s", error_str.c_str());
+    return {heif_error_Decoder_plugin_error,
+            heif_suberror_Unspecified,
+            error_message};
+  }
+
+  if (result.isUndefined()) {
+    return {heif_error_Decoder_plugin_error,
+            heif_suberror_Unspecified,
+            "Decoding failed: decode_with_browser_hevc returned undefined"};
+  }
+
+  emscripten::val js_array = result["buffer"];
+  if (js_array.isUndefined()) {
+    return {heif_error_Decoder_plugin_error,
+            heif_suberror_Unspecified,
+            "Decoding failed: result.buffer is undefined"};
+  }
+
+  const size_t len = js_array["length"].as<size_t>();
+  std::unique_ptr<uint8_t[]> buffer(new uint8_t[len]);
+  emscripten::val memory_view(emscripten::typed_memory_view(len, buffer.get()));
+  memory_view.call<void>("set", js_array);
+
+  const int width = result["codedWidth"].as<int>();
+  const int height = result["codedHeight"].as<int>();
+  std::string format = result["format"].as<std::string>();
+
+  emscripten::val planes = result["planes"];
+  if (planes.isUndefined() || !planes.isArray()) {
+    return {heif_error_Decoder_plugin_error,
+            heif_suberror_Unspecified,
+            "Decoding failed: result.planes is undefined or not an array"};
+  }
+
+  bool is_full_range = !result["fullRange"].isUndefined() && result["fullRange"].as<bool>();
+
+  // Most HEIC images in the browser will be decoded natively in NV12 pixel
+  // format. Using the bytes directly helps retain the original image fidelity.
+  if (format == "NV12") {
+    bool is_mono = config.chroma_format == 0;
+    if (!is_mono && planes["length"].as<size_t>() < 2) {
+      return {heif_error_Decoder_plugin_error,
+              heif_suberror_Unspecified,
+              "Decoding failed: NV12 format requires at least 2 planes"};
+    } else if (is_mono && planes["length"].as<size_t>() < 1) {
+      return {heif_error_Decoder_plugin_error,
+              heif_suberror_Unspecified,
+              "Decoding failed: NV12 monochrome format requires at least 1 plane"};
+    }
+
+    emscripten::val y_plane = planes[0];
+    if (y_plane.isUndefined()) {
+      return {heif_error_Decoder_plugin_error,
+              heif_suberror_Unspecified,
+              "Decoding failed: result.planes[0] is undefined"};
+    }
+
+    const int y_offset = y_plane["offset"].as<int>();
+    const int y_src_stride = y_plane["stride"].as<int>();
+    int uv_offset = 0;
+    int uv_src_stride = 0;
+
+    if (!is_mono) {
+      emscripten::val uv_plane = planes[1];
+      if (uv_plane.isUndefined()) {
+        return {heif_error_Decoder_plugin_error,
+                heif_suberror_Unspecified,
+                "Decoding failed: result.planes[1] is undefined"};
+      }
+
+      uv_offset = uv_plane["offset"].as<int>();
+      uv_src_stride = uv_plane["stride"].as<int>();
+    }
+
+    return convert_nv12_to_heif_image(buffer, width, height, y_offset, y_src_stride, uv_offset, uv_src_stride, out_img, (heif_chroma)config.chroma_format, is_full_range);
+  } else if (format == "I420" || format == "I422" || format == "I444") {
+    if (planes["length"].as<size_t>() < 3) {
+      return {heif_error_Decoder_plugin_error,
+              heif_suberror_Unspecified,
+              "Decoding failed: planar YUV format requires 3 planes"};
+    }
+
+    emscripten::val y_plane = planes[0];
+    emscripten::val u_plane = planes[1];
+    emscripten::val v_plane = planes[2];
+    if (y_plane.isUndefined() || u_plane.isUndefined() || v_plane.isUndefined()) {
+      return {heif_error_Decoder_plugin_error,
+              heif_suberror_Unspecified,
+              "Decoding failed: one or more YUV planes are undefined"};
+    }
+
+    heif_chroma chroma = heif_chroma_420;
+    if (format == "I422") {
+      chroma = heif_chroma_422;
+    } else if (format == "I444") {
+      chroma = heif_chroma_444;
+    }
+
+    return convert_planar_yuv_to_heif_image(
+        buffer.get() + y_plane["offset"].as<int>(),
+        y_plane["stride"].as<int>(),
+        buffer.get() + u_plane["offset"].as<int>(),
+        u_plane["stride"].as<int>(),
+        buffer.get() + v_plane["offset"].as<int>(),
+        v_plane["stride"].as<int>(),
+        width, height,
+        out_img, chroma, is_full_range);
+  } else if (format == "RGBA") {
+    if (planes["length"].as<size_t>() < 1) {
+      return {heif_error_Decoder_plugin_error,
+              heif_suberror_Unspecified,
+              "Decoding failed: RGBA format requires at least 1 plane"};
+    }
+
+    emscripten::val rgba_plane = planes[0];
+    if (rgba_plane.isUndefined()) {
+      return {heif_error_Decoder_plugin_error,
+              heif_suberror_Unspecified,
+              "Decoding failed: result.planes[0] is undefined"};
+    }
+
+    const int rgba_offset = rgba_plane["offset"].as<int>();
+    const int rgba_src_stride = rgba_plane["stride"].as<int>();
+
+    heif_error err;
+    err = heif_image_create(width,
+                            height,
+                            heif_colorspace_RGB,
+                            heif_chroma_interleaved_RGBA,
+                            out_img);
+    if (err.code) {
+      return err;
+    }
+
+    err = heif_image_add_plane(*out_img, heif_channel_interleaved, width, height, 8);
+    if (err.code) {
+      heif_image_release(*out_img);
+      return err;
+    }
+
+    int stride;
+    uint8_t* dst = heif_image_get_plane(*out_img, heif_channel_interleaved, &stride);
+
+    for (int i = 0; i < height; ++i) {
+      memcpy(dst + i * stride,
+             buffer.get() + rgba_offset + i * rgba_src_stride,
+             width * 4);
+    }
+
+    return {heif_error_Ok, heif_suberror_Unspecified, kSuccess};
+  } else {
+    return {heif_error_Decoder_plugin_error,
+            heif_suberror_Unsupported_color_conversion,
+            "Decoding failed: unsupported pixel format"};
+  }
+}
+
+
+void webcodecs_set_strict_decoding(void* decoder_raw, int flag)
+{
+
+}
+
+
+static const struct heif_decoder_plugin decoder_webcodecs
+    {
+        1,
+        webcodecs_plugin_name,
+        webcodecs_init_plugin,
+        webcodecs_deinit_plugin,
+        webcodecs_does_support_format,
+        webcodecs_new_decoder,
+        webcodecs_free_decoder,
+        webcodecs_push_data,
+        webcodecs_decode_image,
+        webcodecs_set_strict_decoding,
+        "webcodecs"
+    };
+
+
+
+const struct heif_decoder_plugin* get_decoder_plugin_webcodecs()
+{
+  return &decoder_webcodecs;
+}
+
+#if PLUGIN_WEBCODECS
+heif_plugin_info plugin_info {
+  1,
+  heif_plugin_type_decoder,
+  &decoder_webcodecs
+};
+#endif
diff --git a/libheif/plugins/decoder_webcodecs.h b/libheif/plugins/decoder_webcodecs.h
new file mode 100644
index 0000000000..c9803d001e
--- /dev/null
+++ b/libheif/plugins/decoder_webcodecs.h
@@ -0,0 +1,34 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2025 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef THIRD_PARTY_LIBHEIF_LIBHEIF_PLUGINS_DECODER_WEBCODECS_H_
+#define THIRD_PARTY_LIBHEIF_LIBHEIF_PLUGINS_DECODER_WEBCODECS_H_
+
+#include "common_utils.h"
+
+const struct heif_decoder_plugin* get_decoder_plugin_webcodecs();
+
+#if PLUGIN_WEBCODECS
+extern "C" {
+MAYBE_UNUSED LIBHEIF_API extern heif_plugin_info plugin_info;
+}
+#endif
+
+#endif  // THIRD_PARTY_LIBHEIF_LIBHEIF_PLUGINS_DECODER_WEBCODECS_H_
diff --git a/libheif/plugins/encoder_aom.cc b/libheif/plugins/encoder_aom.cc
new file mode 100644
index 0000000000..6e58a8aa0d
--- /dev/null
+++ b/libheif/plugins/encoder_aom.cc
@@ -0,0 +1,1421 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "libheif/heif.h"
+#include "libheif/heif_plugin.h"
+#include "common_utils.h"
+#include <algorithm>
+#include <cstring>
+#include <cassert>
+#include <sstream>
+#include <vector>
+#include <string>
+#include <thread>
+#include <memory>
+#include <utility>
+#include "encoder_aom.h"
+
+#include <deque>
+#include <aom/aom_encoder.h>
+#include <aom/aomcx.h>
+#include <mutex>
+
+// Detect whether the aom_codec_set_option() function is available.
+// See https://aomedia.googlesource.com/aom/+/c1d42fe6615c96fc929257ed53c41fa094f38836%5E%21/aom/aom_codec.h.
+#if AOM_CODEC_ABI_VERSION >= (6 + AOM_IMAGE_ABI_VERSION)
+#define HAVE_AOM_CODEC_SET_OPTION 1
+#endif
+
+#if defined(HAVE_AOM_CODEC_SET_OPTION)
+struct custom_option
+{
+    std::string name;
+    std::string value;
+};
+#endif
+
+struct encoder_struct_aom
+{
+  ~encoder_struct_aom()
+  {
+    for (auto* error : aom_errors) {
+      delete[] error;
+    }
+
+    // automatically destroy aom_codec_ctx_t when we leave the function
+//    auto codec_ctx_deleter = std::unique_ptr<aom_codec_ctx_t, aom_codec_err_t (*)(aom_codec_ctx_t*)>(&codec, aom_codec_destroy);
+
+    aom_codec_destroy(&codec);
+  }
+
+  aom_codec_ctx_t codec;
+
+  // --- parameters
+
+  bool realtime_mode;
+  int cpu_used;  // = parameter 'speed'. I guess this is a better name than 'cpu_used'.
+
+  int quality;
+  int alpha_quality;
+  int min_q;
+  int max_q;
+  int alpha_min_q;
+  int alpha_max_q;
+  int threads;
+  bool lossless;
+  bool lossless_alpha;
+  bool auto_tiles;
+  bool enable_intra_block_copy;
+
+#if defined(HAVE_AOM_CODEC_SET_OPTION)
+  std::vector<custom_option> custom_options;
+
+  void add_custom_option(const custom_option&);
+
+  void add_custom_option(std::string name, std::string value);
+#endif
+
+  aom_tune_metric tune;
+
+  heif_chroma chroma = heif_chroma_420;
+
+  // --- input
+
+  bool alpha_quality_set = false;
+  bool alpha_min_q_set = false;
+  bool alpha_max_q_set = false;
+
+  // --- output
+
+  struct Packet
+  {
+    std::vector<uint8_t> compressedData;
+    uintptr_t frameNr = 0;
+    bool is_keyframe = false;
+  };
+
+  std::deque<Packet> output_packets;
+  std::vector<uint8_t> active_output_data;
+
+  //bool data_read = false;
+
+  // --- error message copies
+
+  std::mutex aom_errors_mutex;
+  std::vector<const char*> aom_errors;
+
+  const char* set_aom_error(const char* aom_error_detail);
+};
+
+#if defined(HAVE_AOM_CODEC_SET_OPTION)
+
+void encoder_struct_aom::add_custom_option(const custom_option& p)
+{
+  // if there is already a parameter of that name, remove it from list
+
+  for (auto iter = custom_options.begin(); iter != custom_options.end(); ++iter) {
+    if (iter->name == p.name) {
+      custom_options.erase(iter);
+      break;
+    }
+  }
+
+  // and add the new parameter at the end of the list
+
+  custom_options.push_back(p);
+}
+
+void encoder_struct_aom::add_custom_option(std::string name, std::string value)
+{
+  custom_option p;
+  p.name = std::move(name);
+  p.value = std::move(value);
+  add_custom_option(p);
+}
+
+#endif
+
+static const char* kError_undefined_error = "Undefined AOM error";
+static const char* kError_codec_enc_config_default = "Error creating the default encoder config";
+
+const char* encoder_struct_aom::set_aom_error(const char* aom_error)
+{
+  if (aom_error) {
+    // We have to make a copy because the error returned from aom_codec_error_detail() is only valid
+    // while the codec structure exists.
+
+    char* err_copy = new char[strlen(aom_error) + 1];
+    strcpy(err_copy, aom_error);
+
+    std::lock_guard<std::mutex> lock(aom_errors_mutex);
+    aom_errors.push_back(err_copy);
+
+    return err_copy;
+  }
+  else {
+    return kError_undefined_error;
+  }
+}
+
+static const char* kParam_min_q = "min-q";
+static const char* kParam_max_q = "max-q";
+static const char* kParam_alpha_quality = "alpha-quality";
+static const char* kParam_alpha_min_q = "alpha-min-q";
+static const char* kParam_alpha_max_q = "alpha-max-q";
+static const char* kParam_lossless_alpha = "lossless-alpha";
+static const char* kParam_auto_tiles = "auto-tiles";
+static const char* kParam_enable_intra_block_copy = "enable-intrabc";
+static const char* kParam_threads = "threads";
+static const char* kParam_realtime = "realtime";
+static const char* kParam_speed = "speed";
+
+static const char* kParam_chroma = "chroma";
+static const char* const kParam_chroma_valid_values[] = {
+    "420", "422", "444", nullptr
+};
+
+static const char* kParam_tune = "tune";
+static const char* const kParam_tune_valid_values[] = {
+    "psnr", "ssim", "iq", nullptr
+};
+
+static const int AOM_PLUGIN_PRIORITY = 60;
+
+#define MAX_PLUGIN_NAME_LENGTH 80
+
+static char plugin_name[MAX_PLUGIN_NAME_LENGTH];
+
+
+static void aom_set_default_parameters(void* encoder);
+
+
+static const char* aom_plugin_name()
+{
+  const char* encoder_name = aom_codec_iface_name(aom_codec_av1_cx());
+  if (strlen(encoder_name) < MAX_PLUGIN_NAME_LENGTH) {
+    strcpy(plugin_name, encoder_name);
+  }
+  else {
+    strcpy(plugin_name, "AOMedia AV1 encoder");
+  }
+
+  return plugin_name;
+}
+
+
+#define MAX_NPARAMETERS 16
+
+static heif_encoder_parameter aom_encoder_params[MAX_NPARAMETERS];
+static const heif_encoder_parameter* aom_encoder_parameter_ptrs[MAX_NPARAMETERS + 1];
+
+static void aom_init_parameters()
+{
+  heif_encoder_parameter* p = aom_encoder_params;
+  const heif_encoder_parameter** d = aom_encoder_parameter_ptrs;
+  int i = 0;
+
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = kParam_realtime;
+  p->type = heif_encoder_parameter_type_boolean;
+  p->boolean.default_value = false;
+  p->has_default = true;
+  d[i++] = p++;
+
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = kParam_speed;
+  p->type = heif_encoder_parameter_type_integer;
+  p->integer.default_value = 6;
+  p->has_default = true;
+  p->integer.have_minimum_maximum = true;
+  p->integer.minimum = 0;
+  if (aom_codec_version_major() >= 3) {
+    p->integer.maximum = 9;
+  }
+  else {
+    p->integer.maximum = 8;
+  }
+  p->integer.valid_values = NULL;
+  p->integer.num_valid_values = 0;
+  d[i++] = p++;
+
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = kParam_threads;
+  p->type = heif_encoder_parameter_type_integer;
+  p->has_default = true;
+  p->integer.have_minimum_maximum = true;
+  p->integer.minimum = 1;
+  p->integer.maximum = 64;
+  int threads = static_cast<int>(std::thread::hardware_concurrency());
+  if (threads == 0) {
+    // Could not autodetect, use previous default value.
+    threads = 4;
+  }
+  threads = std::min(threads, p->integer.maximum);
+  p->integer.default_value = threads;
+  p->integer.valid_values = NULL;
+  p->integer.num_valid_values = 0;
+  d[i++] = p++;
+
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = heif_encoder_parameter_name_quality;
+  p->type = heif_encoder_parameter_type_integer;
+  p->integer.default_value = 50;
+  p->has_default = true;
+  p->integer.have_minimum_maximum = true;
+  p->integer.minimum = 0;
+  p->integer.maximum = 100;
+  p->integer.valid_values = NULL;
+  p->integer.num_valid_values = 0;
+  d[i++] = p++;
+
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = heif_encoder_parameter_name_lossless;
+  p->type = heif_encoder_parameter_type_boolean;
+  p->boolean.default_value = false;
+  p->has_default = true;
+  d[i++] = p++;
+
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = kParam_chroma;
+  p->type = heif_encoder_parameter_type_string;
+  p->string.default_value = "420";
+  p->has_default = true;
+  p->string.valid_values = kParam_chroma_valid_values;
+  d[i++] = p++;
+
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = kParam_tune;
+  p->type = heif_encoder_parameter_type_string;
+  p->string.default_value = "ssim";
+  p->has_default = true;
+  p->string.valid_values = kParam_tune_valid_values;
+  d[i++] = p++;
+
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = kParam_min_q;
+  p->type = heif_encoder_parameter_type_integer;
+  p->integer.default_value = 0;
+  p->has_default = true;
+  p->integer.have_minimum_maximum = true;
+  p->integer.minimum = 0;
+  p->integer.maximum = 63;
+  p->integer.valid_values = NULL;
+  p->integer.num_valid_values = 0;
+  d[i++] = p++;
+
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = kParam_max_q;
+  p->type = heif_encoder_parameter_type_integer;
+  p->integer.default_value = 63;
+  p->has_default = true;
+  p->integer.have_minimum_maximum = true;
+  p->integer.minimum = 0;
+  p->integer.maximum = 63;
+  p->integer.valid_values = NULL;
+  p->integer.num_valid_values = 0;
+  d[i++] = p++;
+
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = kParam_alpha_quality;
+  p->type = heif_encoder_parameter_type_integer;
+  p->has_default = false;
+  p->integer.have_minimum_maximum = true;
+  p->integer.minimum = 0;
+  p->integer.maximum = 100;
+  p->integer.valid_values = NULL;
+  p->integer.num_valid_values = 0;
+  d[i++] = p++;
+
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = kParam_alpha_min_q;
+  p->type = heif_encoder_parameter_type_integer;
+  p->has_default = false;
+  p->integer.have_minimum_maximum = true;
+  p->integer.minimum = 0;
+  p->integer.maximum = 63;
+  p->integer.valid_values = NULL;
+  p->integer.num_valid_values = 0;
+  d[i++] = p++;
+
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = kParam_alpha_max_q;
+  p->type = heif_encoder_parameter_type_integer;
+  p->has_default = false;
+  p->integer.have_minimum_maximum = true;
+  p->integer.minimum = 0;
+  p->integer.maximum = 63;
+  p->integer.valid_values = NULL;
+  p->integer.num_valid_values = 0;
+  d[i++] = p++;
+
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = kParam_lossless_alpha;
+  p->type = heif_encoder_parameter_type_boolean;
+  p->boolean.default_value = false;
+  p->has_default = true;
+  d[i++] = p++;
+
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = kParam_auto_tiles;
+  p->type = heif_encoder_parameter_type_boolean;
+  p->boolean.default_value = false;
+  p->has_default = true;
+  d[i++] = p++;
+
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = kParam_enable_intra_block_copy;
+  p->type = heif_encoder_parameter_type_boolean;
+  p->boolean.default_value = true;
+  p->has_default = true;
+  d[i++] = p++;
+
+  assert(i < MAX_NPARAMETERS + 1);
+  d[i++] = nullptr;
+}
+
+
+const heif_encoder_parameter** aom_list_parameters(void* encoder)
+{
+  return aom_encoder_parameter_ptrs;
+}
+
+static void aom_init_plugin()
+{
+  aom_init_parameters();
+}
+
+
+static void aom_cleanup_plugin()
+{
+}
+
+heif_error aom_new_encoder(void** enc)
+{
+  encoder_struct_aom* encoder = new encoder_struct_aom();
+  heif_error err = heif_error_ok;
+
+  *enc = encoder;
+
+  // set default parameters
+
+  aom_set_default_parameters(encoder);
+
+  return err;
+}
+
+void aom_free_encoder(void* encoder_raw)
+{
+  struct encoder_struct_aom* encoder = (encoder_struct_aom*) encoder_raw;
+
+  delete encoder;
+}
+
+
+heif_error aom_set_parameter_quality(void* encoder_raw, int quality)
+{
+  encoder_struct_aom* encoder = (encoder_struct_aom*) encoder_raw;
+
+  if (quality < 0 || quality > 100) {
+    return heif_error_invalid_parameter_value;
+  }
+
+  encoder->quality = quality;
+
+  return heif_error_ok;
+}
+
+heif_error aom_get_parameter_quality(void* encoder_raw, int* quality)
+{
+  encoder_struct_aom* encoder = (encoder_struct_aom*) encoder_raw;
+
+  *quality = encoder->quality;
+
+  return heif_error_ok;
+}
+
+heif_error aom_set_parameter_lossless(void* encoder_raw, int enable)
+{
+  encoder_struct_aom* encoder = (encoder_struct_aom*) encoder_raw;
+
+  if (enable) {
+    encoder->min_q = 0;
+    encoder->max_q = 0;
+    encoder->alpha_min_q = 0;
+    encoder->alpha_min_q_set = true;
+    encoder->alpha_max_q = 0;
+    encoder->alpha_max_q_set = true;
+  }
+
+  encoder->lossless = enable;
+
+  return heif_error_ok;
+}
+
+heif_error aom_get_parameter_lossless(void* encoder_raw, int* enable)
+{
+  encoder_struct_aom* encoder = (encoder_struct_aom*) encoder_raw;
+
+  *enable = encoder->lossless;
+
+  return heif_error_ok;
+}
+
+struct heif_error aom_set_parameter_logging_level(void* encoder_raw, int logging)
+{
+#if 0
+  struct encoder_struct_x265* encoder = (struct encoder_struct_x265*)encoder_raw;
+
+  if (logging<0 || logging>4) {
+    return heif_error_invalid_parameter_value;
+  }
+
+  encoder->logLevel = logging;
+#endif
+
+  return heif_error_ok;
+}
+
+struct heif_error aom_get_parameter_logging_level(void* encoder_raw, int* loglevel)
+{
+#if 0
+  struct encoder_struct_x265* encoder = (struct encoder_struct_x265*)encoder_raw;
+
+  *loglevel = encoder->logLevel;
+#else
+  *loglevel = 0;
+#endif
+
+  return heif_error_ok;
+}
+
+#define set_value(paramname, paramvar) if (strcmp(name, paramname)==0) { encoder->paramvar = value; return heif_error_ok; }
+#define get_value(paramname, paramvar) if (strcmp(name, paramname)==0) { *value = encoder->paramvar; return heif_error_ok; }
+
+
+heif_error aom_set_parameter_integer(void* encoder_raw, const char* name, int value)
+{
+  encoder_struct_aom* encoder = (encoder_struct_aom*) encoder_raw;
+
+  if (strcmp(name, heif_encoder_parameter_name_quality) == 0) {
+    return aom_set_parameter_quality(encoder, value);
+  }
+  else if (strcmp(name, heif_encoder_parameter_name_lossless) == 0) {
+    return aom_set_parameter_lossless(encoder, value);
+  }
+  else if (strcmp(name, kParam_alpha_quality) == 0) {
+      if (value < 0 || value > 100) {
+          return heif_error_invalid_parameter_value;
+      }
+
+      encoder->alpha_quality = value;
+      encoder->alpha_quality_set = true;
+      return heif_error_ok;
+  }
+  else if (strcmp(name, kParam_alpha_min_q) == 0) {
+      encoder->alpha_min_q = value;
+      encoder->alpha_min_q_set = true;
+      return heif_error_ok;
+  }
+  else if (strcmp(name, kParam_alpha_max_q) == 0) {
+      encoder->alpha_max_q = value;
+      encoder->alpha_max_q_set = true;
+      return heif_error_ok;
+  }
+
+  set_value(kParam_min_q, min_q);
+  set_value(kParam_max_q, max_q);
+  set_value(kParam_threads, threads);
+  set_value(kParam_speed, cpu_used);
+
+  return heif_error_unsupported_parameter;
+}
+
+heif_error aom_get_parameter_integer(void* encoder_raw, const char* name, int* value)
+{
+  encoder_struct_aom* encoder = (encoder_struct_aom*) encoder_raw;
+
+  if (strcmp(name, heif_encoder_parameter_name_quality) == 0) {
+    return aom_get_parameter_quality(encoder, value);
+  }
+  else if (strcmp(name, heif_encoder_parameter_name_lossless) == 0) {
+    return aom_get_parameter_lossless(encoder, value);
+  }
+  else if (strcmp(name, kParam_alpha_quality) == 0) {
+      *value = encoder->alpha_quality_set ? encoder->alpha_quality : encoder->quality;
+      return heif_error_ok;
+  }
+  else if (strcmp(name, kParam_alpha_max_q) == 0) {
+      *value = encoder->alpha_max_q_set ? encoder->alpha_max_q : encoder->max_q;
+      return heif_error_ok;
+  }
+  else if (strcmp(name, kParam_alpha_min_q) == 0) {
+      *value = encoder->alpha_min_q_set ? encoder->alpha_min_q : encoder->min_q;
+      return heif_error_ok;
+  }
+
+  get_value(kParam_min_q, min_q);
+  get_value(kParam_max_q, max_q);
+  get_value(kParam_threads, threads);
+  get_value(kParam_speed, cpu_used);
+
+  return heif_error_unsupported_parameter;
+}
+
+
+heif_error aom_set_parameter_boolean(void* encoder_raw, const char* name, int value)
+{
+  encoder_struct_aom* encoder = (encoder_struct_aom*) encoder_raw;
+
+  if (strcmp(name, heif_encoder_parameter_name_lossless) == 0) {
+    return aom_set_parameter_lossless(encoder, value);
+  }
+  else if (strcmp(name, kParam_lossless_alpha) == 0) {
+      encoder->lossless_alpha = value;
+      if (value) {
+          encoder->alpha_max_q = 0;
+          encoder->alpha_max_q_set = true;
+          encoder->alpha_min_q = 0;
+          encoder->alpha_min_q_set = true;
+      }
+      return heif_error_ok;
+  } else if (strcmp(name, kParam_auto_tiles) == 0) {
+      encoder->auto_tiles = value;
+      return heif_error_ok;
+  } else if (strcmp(name, kParam_enable_intra_block_copy) == 0) {
+      encoder->enable_intra_block_copy = value;
+      return heif_error_ok;
+  }
+
+  set_value(kParam_realtime, realtime_mode);
+
+  return heif_error_unsupported_parameter;
+}
+
+heif_error aom_get_parameter_boolean(void* encoder_raw, const char* name, int* value)
+{
+  encoder_struct_aom* encoder = (encoder_struct_aom*) encoder_raw;
+
+  if (strcmp(name, heif_encoder_parameter_name_lossless) == 0) {
+    return aom_get_parameter_lossless(encoder, value);
+  }
+
+  get_value(kParam_realtime, realtime_mode);
+  get_value(kParam_lossless_alpha, lossless_alpha);
+  get_value(kParam_auto_tiles, auto_tiles);
+  get_value(kParam_enable_intra_block_copy, enable_intra_block_copy);
+
+  return heif_error_unsupported_parameter;
+}
+
+
+heif_error aom_set_parameter_string(void* encoder_raw, const char* name, const char* value)
+{
+  encoder_struct_aom* encoder = (encoder_struct_aom*) encoder_raw;
+
+  if (strcmp(name, kParam_chroma) == 0) {
+    if (strcmp(value, "420") == 0) {
+      encoder->chroma = heif_chroma_420;
+      return heif_error_ok;
+    }
+    else if (strcmp(value, "422") == 0) {
+      encoder->chroma = heif_chroma_422;
+      return heif_error_ok;
+    }
+    else if (strcmp(value, "444") == 0) {
+      encoder->chroma = heif_chroma_444;
+      return heif_error_ok;
+    }
+    else {
+      return heif_error_invalid_parameter_value;
+    }
+  }
+
+  if (strcmp(name, kParam_tune) == 0) {
+    if (strcmp(value, "psnr") == 0) {
+      encoder->tune = AOM_TUNE_PSNR;
+      return heif_error_ok;
+    }
+    else if (strcmp(value, "ssim") == 0) {
+      encoder->tune = AOM_TUNE_SSIM;
+      return heif_error_ok;
+    }
+#if defined(AOM_HAVE_TUNE_IQ)
+    else if (strcmp(value, "iq") == 0) {
+      encoder->tune = AOM_TUNE_IQ;
+      return heif_error_ok;
+    }
+#endif
+    else {
+      return heif_error_invalid_parameter_value;
+    }
+  }
+
+#if defined(HAVE_AOM_CODEC_SET_OPTION)
+  if (strncmp(name, "aom:", 4) == 0) {
+    encoder->add_custom_option(std::string(name).substr(4), std::string(value));
+    return heif_error_ok;
+  }
+#endif
+
+  return heif_error_unsupported_parameter;
+}
+
+
+static void save_strcpy(char* dst, int dst_size, const char* src)
+{
+  strncpy(dst, src, dst_size - 1);
+  dst[dst_size - 1] = 0;
+}
+
+
+heif_error aom_get_parameter_string(void* encoder_raw, const char* name,
+                                    char* value, int value_size)
+{
+  encoder_struct_aom* encoder = (encoder_struct_aom*) encoder_raw;
+
+  if (strcmp(name, kParam_chroma) == 0) {
+    switch (encoder->chroma) {
+      case heif_chroma_420:
+        save_strcpy(value, value_size, "420");
+        break;
+      case heif_chroma_422:
+        save_strcpy(value, value_size, "422");
+        break;
+      case heif_chroma_444:
+        save_strcpy(value, value_size, "444");
+        break;
+      default:
+        assert(false);
+        return heif_error_invalid_parameter_value;
+    }
+    return heif_error_ok;
+  }
+  else if (strcmp(name, kParam_tune) == 0) {
+    switch (encoder->tune) {
+      case AOM_TUNE_PSNR:
+        save_strcpy(value, value_size, "psnr");
+        break;
+      case AOM_TUNE_SSIM:
+        save_strcpy(value, value_size, "ssim");
+        break;
+#if defined(AOM_HAVE_TUNE_IQ)
+      case AOM_TUNE_IQ:
+        save_strcpy(value, value_size, "iq");
+        break;
+#endif
+      default:
+        assert(false);
+        return heif_error_invalid_parameter_value;
+    }
+    return heif_error_ok;
+  }
+
+  return heif_error_unsupported_parameter;
+}
+
+
+static void aom_set_default_parameters(void* encoder)
+{
+  for (const heif_encoder_parameter** p = aom_encoder_parameter_ptrs; *p; p++) {
+    const heif_encoder_parameter* param = *p;
+
+    if (param->has_default) {
+      switch (param->type) {
+        case heif_encoder_parameter_type_integer:
+          aom_set_parameter_integer(encoder, param->name, param->integer.default_value);
+          break;
+        case heif_encoder_parameter_type_boolean:
+          aom_set_parameter_boolean(encoder, param->name, param->boolean.default_value);
+          break;
+        case heif_encoder_parameter_type_string:
+          aom_set_parameter_string(encoder, param->name, param->string.default_value);
+          break;
+      }
+    }
+  }
+}
+
+
+void aom_query_input_colorspace(heif_colorspace* colorspace, heif_chroma* chroma)
+{
+  *colorspace = heif_colorspace_YCbCr;
+  *chroma = heif_chroma_420;
+}
+
+
+void aom_query_input_colorspace2(void* encoder_raw, heif_colorspace* colorspace, heif_chroma* chroma)
+{
+  encoder_struct_aom* encoder = (encoder_struct_aom*) encoder_raw;
+
+  if (*colorspace == heif_colorspace_monochrome) {
+    // keep the monochrome colorspace
+  }
+  else {
+    *colorspace = heif_colorspace_YCbCr;
+    *chroma = encoder->chroma;
+  }
+}
+
+// returns 'true' when an error was detected
+// Note: some older AOM versions take a non-const pointer to aom_codec_error(). Thus, we also have to use a non-const pointer here.
+static bool check_aom_error(aom_codec_err_t aom_error, /*const*/ aom_codec_ctx_t* codec, encoder_struct_aom* encoder, struct heif_error* heif_error)
+{
+  if (aom_error == AOM_CODEC_OK) {
+    return false;
+  }
+
+  std::stringstream sstr;
+  sstr << "AOM encoder error: " << aom_codec_error(codec) << " - " << aom_codec_error_detail(codec);
+
+  heif_error->code = heif_error_Encoder_plugin_error;
+  heif_error->subcode = heif_suberror_Unsupported_parameter;
+  heif_error->message = encoder->set_aom_error(sstr.str().c_str());
+
+  return true;
+}
+
+#define CHECK_ERROR \
+if (check_aom_error(aom_error, &codec, encoder, &err)) { \
+  return err; \
+}
+
+struct chroma_info
+{
+  aom_img_fmt_t img_format = AOM_IMG_FMT_NONE;
+  int chroma_height = 0;
+  int chroma_sample_position = AOM_CSP_UNKNOWN;
+};
+
+
+chroma_info get_chroma_info(heif_chroma chroma,
+                            int bpp_y, int source_height)
+{
+  chroma_info info;
+
+  switch (chroma) {
+    case heif_chroma_420:
+    case heif_chroma_monochrome:
+      info.img_format = AOM_IMG_FMT_I420;
+      info.chroma_height = (source_height+1)/2;
+      info.chroma_sample_position = AOM_CSP_UNKNOWN; // TODO: change this to CSP_CENTER in the future (https://github.com/AOMediaCodec/av1-avif/issues/88)
+      break;
+    case heif_chroma_422:
+      info.img_format = AOM_IMG_FMT_I422;
+      info.chroma_height = (source_height+1)/2;
+      info.chroma_sample_position = AOM_CSP_COLOCATED;
+      break;
+    case heif_chroma_444:
+      info.img_format = AOM_IMG_FMT_I444;
+      info.chroma_height = source_height;
+      info.chroma_sample_position = AOM_CSP_COLOCATED;
+      break;
+    default:
+      info.img_format = AOM_IMG_FMT_NONE;
+      info.chroma_sample_position = AOM_CSP_UNKNOWN;
+      assert(false);
+      break;
+  }
+
+  if (bpp_y > 8) {
+    info.img_format = (aom_img_fmt_t) (info.img_format | AOM_IMG_FMT_HIGHBITDEPTH);
+  }
+
+  return info;
+}
+
+
+
+static heif_error aom_start_sequence_encoding_intern(void* encoder_raw, const heif_image* image,
+                                                     enum heif_image_input_class input_class,
+                                                     uint32_t framerate_num, uint32_t framerate_denom,
+                                                     const heif_sequence_encoding_options* options,
+                                                     bool image_sequence)
+{
+  encoder_struct_aom* encoder = (encoder_struct_aom*) encoder_raw;
+
+  heif_error err;
+
+  const int source_width = heif_image_get_width(image, heif_channel_Y);
+  const int source_height = heif_image_get_height(image, heif_channel_Y);
+
+  const heif_chroma chroma = heif_image_get_chroma_format(image);
+
+  int bpp_y = heif_image_get_bits_per_pixel_range(image, heif_channel_Y);
+
+
+  // --- check for AOM 3.6.0 bug
+
+  bool is_aom_3_6_0 = (aom_codec_version() == 0x030600);
+
+  if (is_aom_3_6_0) {
+    // This bound might be too tight, as I still could encode images with 8193 x 4353 correctly. Even 8200x4400, but 8200x4800 fails.
+    // Let's still keep it as most images will be smaller anyway.
+    if (!(source_width <= 8192 * 2 && source_height <= 4352 * 2 && source_width * source_height <= 8192 * 4352)) {
+      err = {heif_error_Encoding_error,
+             heif_suberror_Encoder_encoding,
+             "AOM v3.6.0 has a bug when encoding large images. Please upgrade to at least AOM v3.6.1."};
+      return err;
+    }
+  }
+
+
+  // --- copy libheif image to aom image
+
+  chroma_info chroma_info = get_chroma_info(chroma, bpp_y, source_height);
+
+
+  // --- configure codec
+
+  aom_codec_iface_t* iface;
+  aom_codec_ctx_t& codec = encoder->codec;
+
+  iface = aom_codec_av1_cx();
+  //encoder->encoder = get_aom_encoder_by_name("av1");
+  if (!iface) {
+    return {
+      heif_error_Unsupported_feature,
+      heif_suberror_Unsupported_codec,
+      "Unsupported codec: AOMedia Project AV1 Encoder"
+    };
+  }
+
+
+#if defined(AOM_USAGE_ALL_INTRA)
+  // aom 3.1.0
+  unsigned int aomUsage = AOM_USAGE_ALL_INTRA;
+#else
+  // aom 2.0
+  unsigned int aomUsage = AOM_USAGE_GOOD_QUALITY;
+#endif
+
+  if (image_sequence &&
+      options->gop_structure != heif_sequence_gop_structure_intra_only &&
+      options->keyframe_distance_max != 1) {
+    aomUsage = AOM_USAGE_GOOD_QUALITY;
+  }
+
+  if (encoder->realtime_mode) {
+    aomUsage = AOM_USAGE_REALTIME;
+  }
+
+  aom_codec_enc_cfg_t cfg;
+  aom_codec_err_t res = aom_codec_enc_config_default(iface, &cfg, aomUsage);
+  if (res) {
+    err = {heif_error_Encoder_plugin_error,
+           heif_suberror_Encoder_initialization,
+           kError_codec_enc_config_default};
+    return err;
+  }
+
+  int seq_profile = compute_avif_profile(heif_image_get_bits_per_pixel_range(image, heif_channel_Y),
+                                         heif_image_get_chroma_format(image));
+
+  cfg.g_w = source_width;
+  cfg.g_h = source_height;
+  // Set the max number of frames to encode to 1. This makes the libaom encoder
+  // set still_picture and reduced_still_picture_header to 1 in the AV1 sequence
+  // header OBU.
+  if (!image_sequence) {
+    cfg.g_limit = 1;
+  }
+
+  // Use the default settings of the new AOM_USAGE_ALL_INTRA (added in
+  // https://crbug.com/aomedia/2959).
+  //
+  // Set g_lag_in_frames to 0 to reduce the number of frame buffers (from 20
+  // to 2) in libaom's lookahead structure. This reduces memory consumption when
+  // encoding a single image.
+  cfg.g_lag_in_frames = 0;
+  // Disable automatic placement of key frames by the encoder.
+  cfg.kf_mode = AOM_KF_DISABLED;
+
+  if (!image_sequence) {
+    // Tell libaom that all frames will be key frames.
+    cfg.kf_max_dist = 0;
+  }
+  else if (options->gop_structure == heif_sequence_gop_structure_intra_only) {
+    cfg.kf_max_dist = 0;
+  }
+  else {
+    if (options->keyframe_distance_min) {
+      cfg.kf_min_dist = options->keyframe_distance_min;
+    }
+
+    if (options->keyframe_distance_max) {
+      cfg.kf_max_dist = options->keyframe_distance_max;
+    }
+  }
+
+  cfg.g_profile = seq_profile;
+  cfg.g_bit_depth = (aom_bit_depth_t) bpp_y;
+  cfg.g_input_bit_depth = bpp_y;
+
+  cfg.rc_end_usage = AOM_Q;
+
+  int min_q = encoder->min_q;
+  int max_q = encoder->max_q;
+
+  if (input_class == heif_image_input_class_alpha && encoder->alpha_min_q_set && encoder->alpha_max_q_set) {
+    min_q = encoder->alpha_min_q;
+    max_q = encoder->alpha_max_q;
+  }
+
+  int quality = encoder->quality;
+
+  if (input_class == heif_image_input_class_alpha && encoder->alpha_quality_set) {
+    quality = encoder->alpha_quality;
+  }
+
+  int cq_level = ((100 - quality) * 63 + 50) / 100;
+
+  // Work around the bug in libaom v2.0.2 or older fixed by
+  // https://aomedia-review.googlesource.com/c/aom/+/113064. If using a libaom
+  // release with the bug, set cfg.rc_min_quantizer to cq_level to prevent
+  // libaom from incorrectly using a quantizer index lower than cq_level.
+  bool aom_2_0_2_or_older = aom_codec_version() <= 0x020002;
+
+  cfg.rc_min_quantizer = aom_2_0_2_or_older ? cq_level : min_q;
+  cfg.rc_max_quantizer = max_q;
+  cfg.g_error_resilient = 0;
+  cfg.g_threads = encoder->threads;
+
+  if (chroma == heif_chroma_monochrome) {
+    cfg.monochrome = 1;
+  }
+
+  cfg.g_timebase.num = static_cast<int>(framerate_num);
+  cfg.g_timebase.den = static_cast<int>(framerate_denom);
+
+  // --- initialize codec
+
+  aom_codec_flags_t encoder_flags = 0;
+  if (bpp_y > 8) {
+    encoder_flags = (aom_codec_flags_t) (encoder_flags | AOM_CODEC_USE_HIGHBITDEPTH);
+  }
+
+  // allocate aom_codec_ctx_t
+  if (aom_codec_enc_init(&codec, iface, &cfg, encoder_flags)) {
+    // AOM makes sure that the error text returned by aom_codec_error_detail() is always a static
+    // text that is valid even though the codec allocation failed (#788).
+    err = {heif_error_Encoder_plugin_error,
+           heif_suberror_Encoder_initialization,
+           encoder->set_aom_error(aom_codec_error_detail(&codec))};
+    return err;
+  }
+
+  aom_codec_err_t aom_error;
+
+  aom_error = aom_codec_control(&codec, AOME_SET_CPUUSED, encoder->cpu_used); CHECK_ERROR;
+
+  aom_error = aom_codec_control(&codec, AOME_SET_CQ_LEVEL, cq_level); CHECK_ERROR;
+
+  if (encoder->threads > 1) {
+#if defined(AOM_CTRL_AV1E_SET_ROW_MT)
+    // aom 2.0
+    aom_error = aom_codec_control(&codec, AV1E_SET_ROW_MT, 1); CHECK_ERROR;
+#endif
+  }
+
+#if defined(AOM_CTRL_AV1E_SET_AUTO_TILES)
+  // aom 3.10.0
+  aom_error = aom_codec_control(&codec, AV1E_SET_AUTO_TILES, encoder->auto_tiles); CHECK_ERROR;
+#endif
+
+  // TODO: set AV1E_SET_TILE_ROWS and AV1E_SET_TILE_COLUMNS.
+
+
+  heif_color_profile_nclx* nclx = nullptr;
+  err = heif_image_get_nclx_color_profile(image, &nclx);
+  if (err.code != heif_error_Ok) {
+    assert(nclx == nullptr);
+  }
+
+  // make sure NCLX profile is deleted at end of function
+  auto nclx_deleter = std::unique_ptr<heif_color_profile_nclx, void (*)(heif_color_profile_nclx*)>(nclx, heif_nclx_color_profile_free);
+
+  // In aom, color_range defaults to limited range (0). Set it to full range (1).
+  aom_error = aom_codec_control(&codec, AV1E_SET_COLOR_RANGE, nclx ? nclx->full_range_flag : 1); CHECK_ERROR;
+  aom_error = aom_codec_control(&codec, AV1E_SET_CHROMA_SAMPLE_POSITION, chroma_info.chroma_sample_position); CHECK_ERROR;
+
+  if (nclx &&
+      (input_class == heif_image_input_class_normal ||
+       input_class == heif_image_input_class_thumbnail)) {
+    aom_error = aom_codec_control(&codec, AV1E_SET_COLOR_PRIMARIES, nclx->color_primaries); CHECK_ERROR
+    aom_error = aom_codec_control(&codec, AV1E_SET_MATRIX_COEFFICIENTS, nclx->matrix_coefficients); CHECK_ERROR;
+    aom_error = aom_codec_control(&codec, AV1E_SET_TRANSFER_CHARACTERISTICS, nclx->transfer_characteristics); CHECK_ERROR;
+       }
+
+  aom_error = aom_codec_control(&codec, AOME_SET_TUNING, encoder->tune); CHECK_ERROR;
+
+  if (encoder->lossless || (input_class == heif_image_input_class_alpha && encoder->lossless_alpha)) {
+    aom_error = aom_codec_control(&codec, AV1E_SET_LOSSLESS, 1); CHECK_ERROR;
+  }
+
+#if defined(AOM_CTRL_AV1E_SET_SKIP_POSTPROC_FILTERING)
+  if (cfg.g_usage == AOM_USAGE_ALL_INTRA) {
+    // Enable AV1E_SET_SKIP_POSTPROC_FILTERING for still-picture encoding,
+    // which is disabled by default.
+    aom_error = aom_codec_control(&codec, AV1E_SET_SKIP_POSTPROC_FILTERING, 1); CHECK_ERROR;
+  }
+#endif
+
+  aom_error = aom_codec_control(&codec, AV1E_SET_ENABLE_INTRABC, encoder->enable_intra_block_copy); CHECK_ERROR;
+
+#if defined(HAVE_AOM_CODEC_SET_OPTION)
+  // Apply the custom AOM encoder options.
+  // These should always be applied last as they can override the values that were set above.
+  for (const auto& p : encoder->custom_options) {
+    if (aom_codec_set_option(&codec, p.name.c_str(), p.value.c_str()) != AOM_CODEC_OK) {
+      std::stringstream sstr;
+      sstr << "Cannot set AOM encoder option (name: " << p.name << ", value: " << p.value << "): "
+           << aom_codec_error(&codec) << " - " << aom_codec_error_detail(&codec);
+
+      err = {
+        heif_error_Encoder_plugin_error,
+        heif_suberror_Unsupported_parameter,
+        encoder->set_aom_error(sstr.str().c_str())
+      };
+      return err;
+    }
+  }
+#endif
+
+  return {};
+}
+
+
+
+static heif_error aom_start_sequence_encoding(void* encoder_raw, const heif_image* image,
+                                       enum heif_image_input_class input_class,
+                                       uint32_t framerate_num, uint32_t framerate_denom,
+                                       const heif_sequence_encoding_options* options)
+{
+  return aom_start_sequence_encoding_intern(encoder_raw, image, input_class, framerate_num, framerate_denom, options,
+    true);
+}
+
+
+static heif_error aom_encode_sequence_frame(void* encoder_raw, const heif_image* image,
+                                            uintptr_t frame_nr)
+{
+  encoder_struct_aom* encoder = (encoder_struct_aom*) encoder_raw;
+  aom_codec_ctx_t& codec = encoder->codec;
+
+  heif_error err;
+
+  const int source_width = heif_image_get_width(image, heif_channel_Y);
+  const int source_height = heif_image_get_height(image, heif_channel_Y);
+
+  const heif_chroma chroma = heif_image_get_chroma_format(image);
+
+  int bpp_y = heif_image_get_bits_per_pixel_range(image, heif_channel_Y);
+
+  chroma_info chroma_info = get_chroma_info(chroma, bpp_y, source_height);
+
+  std::unique_ptr<aom_image_t, void (*)(aom_image_t*)> input_image(aom_img_alloc(nullptr,
+                                                                                 chroma_info.img_format,
+                                                                                 source_width,
+                                                                                 source_height,
+                                                                                 1),
+                                                                   aom_img_free);
+  if (!input_image) {
+    err = {heif_error_Memory_allocation_error,
+           heif_suberror_Unspecified,
+           "Failed to allocate image"};
+    return err;
+  }
+
+
+  for (int plane = 0; plane < 3; plane++) {
+    unsigned char* buf = input_image->planes[plane];
+    const int stride = input_image->stride[plane];
+
+    if (chroma == heif_chroma_monochrome && plane != 0) {
+      if (bpp_y == 8) {
+        memset(buf, 128, chroma_info.chroma_height * stride);
+      }
+      else {
+        uint16_t* buf16 = (uint16_t*) buf;
+        uint16_t half_range = (uint16_t) (1 << (bpp_y - 1));
+        for (int i = 0; i < chroma_info.chroma_height * stride / 2; i++) {
+          buf16[i] = half_range;
+        }
+      }
+
+      continue;
+    }
+
+    /*
+    const int w = aom_img_plane_width(img, plane) *
+                  ((img->fmt & AOM_IMG_FMT_HIGHBITDEPTH) ? 2 : 1);
+    const int h = aom_img_plane_height(img, plane);
+    */
+
+    size_t in_stride = 0;
+    const uint8_t* in_p = heif_image_get_plane_readonly2(image, (heif_channel) plane, &in_stride);
+
+    int w = source_width;
+    int h = source_height;
+
+    if (plane != 0) {
+      if (chroma != heif_chroma_444) { w = (w + 1) / 2; }
+      if (chroma == heif_chroma_420) { h = (h + 1) / 2; }
+
+      assert(w == heif_image_get_width(image, (heif_channel) plane));
+      assert(h == heif_image_get_height(image, (heif_channel) plane));
+    }
+
+    if (bpp_y > 8) {
+      w *= 2;
+    }
+
+    for (int y = 0; y < h; y++) {
+      memcpy(buf, &in_p[y * in_stride], w);
+      buf += stride;
+    }
+  }
+
+  //input_image->user_priv = (void*)frame_nr;
+
+  // --- encode frame
+
+  aom_codec_err_t res = aom_codec_encode(&codec, input_image.get(),
+                                         frame_nr, // PTS (only encoding a single frame) TODO
+                                         1,
+                                         0); // no flags
+
+  if (res != AOM_CODEC_OK) {
+    err = {
+        heif_error_Encoder_plugin_error,
+        heif_suberror_Encoder_encoding,
+        encoder->set_aom_error(aom_codec_error_detail(&codec))
+    };
+    return err;
+  }
+
+  // TODO: do we need this ? encoder->compressedData.clear();
+
+  const aom_codec_cx_pkt_t* pkt = NULL;
+  aom_codec_iter_t iter = NULL; // for extracting the compressed packets
+
+  while ((pkt = aom_codec_get_cx_data(&codec, &iter)) != NULL) {
+
+    if (pkt->kind == AOM_CODEC_CX_FRAME_PKT) {
+      //std::cerr.write((char*)pkt->data.frame.buf, pkt->data.frame.sz);
+
+      //printf("packet of size: %d\n",(int)pkt->data.frame.sz);
+
+
+      // TODO: split the received data into separate OBUs
+      // This allows libheif to easily extract the sequence header for the av1C header
+
+      size_t n = pkt->data.frame.sz;
+
+      encoder_struct_aom::Packet output_packet;
+      output_packet.frameNr = pkt->data.frame.pts;
+      output_packet.is_keyframe = (pkt->data.frame.flags & AOM_FRAME_IS_INTRAONLY);
+
+      encoder->output_packets.emplace_back(output_packet);
+      encoder->output_packets.back().compressedData.resize(n);
+
+      memcpy(encoder->output_packets.back().compressedData.data(),
+             pkt->data.frame.buf,
+             n);
+    }
+  }
+
+
+  return heif_error_ok;
+}
+
+
+static heif_error aom_end_sequence_encoding(void *encoder_raw)
+{
+  encoder_struct_aom* encoder = (encoder_struct_aom*) encoder_raw;
+  aom_codec_ctx_t& codec = encoder->codec;
+
+  heif_error err;
+
+  int flags = 0;
+  aom_codec_err_t res = aom_codec_encode(&codec, NULL, -1, 0, flags);
+  if (res != AOM_CODEC_OK) {
+    err = {heif_error_Encoder_plugin_error,
+           heif_suberror_Encoder_encoding,
+           encoder->set_aom_error(aom_codec_error_detail(&codec))};
+    return err;
+  }
+
+
+  aom_codec_iter_t iter = NULL; // for extracting the compressed packets
+
+  const aom_codec_cx_pkt_t* pkt = NULL;
+  while ((pkt = aom_codec_get_cx_data(&codec, &iter)) != NULL) {
+
+    if (pkt->kind == AOM_CODEC_CX_FRAME_PKT) {
+      //std::cerr.write((char*)pkt->data.frame.buf, pkt->data.frame.sz);
+
+      //printf("packet of size: %d\n",(int)pkt->data.frame.sz);
+
+
+      // TODO: split the received data into separate OBUs
+      // This allows libheif to easily extract the sequence header for the av1C header
+
+      size_t n = pkt->data.frame.sz;
+
+      encoder_struct_aom::Packet output_packet;
+      output_packet.frameNr = pkt->data.frame.pts;
+
+      encoder->output_packets.emplace_back(output_packet);
+      encoder->output_packets.back().compressedData.resize(n);
+
+      memcpy(encoder->output_packets.back().compressedData.data(),
+             pkt->data.frame.buf,
+             n);
+    }
+  }
+
+  return {};
+}
+
+
+static heif_error aom_encode_image(void* encoder_raw, const heif_image* image,
+                                   heif_image_input_class input_class)
+{
+  heif_error err;
+  err = aom_start_sequence_encoding_intern(encoder_raw, image, input_class, 1,25, nullptr, false);
+  if (err.code) {
+    return err;
+  }
+
+  err = aom_encode_sequence_frame(encoder_raw, image, 0);
+  if (err.code) {
+    return err;
+  }
+
+  return aom_end_sequence_encoding(encoder_raw);
+}
+
+
+heif_error aom_get_compressed_data2(void* encoder_raw, uint8_t** data, int* size,
+                                    uintptr_t* out_framenr, int* out_is_keyframe,
+                                    int* more_frame_packets)
+{
+  encoder_struct_aom* encoder = (encoder_struct_aom*) encoder_raw;
+
+  encoder->active_output_data.clear();
+
+  if (encoder->output_packets.empty()) {
+    *size = 0;
+    *data = nullptr;
+  }
+  else {
+    encoder->active_output_data = std::move(encoder->output_packets.front().compressedData);
+    if (out_framenr) {
+      *out_framenr = encoder->output_packets.front().frameNr;
+    }
+
+    if (out_is_keyframe) {
+      *out_is_keyframe = encoder->output_packets.front().is_keyframe;
+    }
+
+    encoder->output_packets.pop_front();
+
+    *size = (int) encoder->active_output_data.size();
+    *data = encoder->active_output_data.data();
+  }
+
+  return heif_error_ok;
+}
+
+
+static heif_error aom_get_compressed_data(void* encoder_raw, uint8_t** data, int* size,
+                                          heif_encoded_data_type* type)
+{
+  return aom_get_compressed_data2(encoder_raw, data, size, nullptr, nullptr, nullptr);
+}
+
+
+static const heif_encoder_plugin encoder_plugin_aom
+    {
+        /* plugin_api_version */ 4,
+        /* compression_format */ heif_compression_AV1,
+        /* id_name */ "aom",
+        /* priority */ AOM_PLUGIN_PRIORITY,
+        /* supports_lossy_compression */ true,
+        /* supports_lossless_compression */ true,
+        /* get_plugin_name */ aom_plugin_name,
+        /* init_plugin */ aom_init_plugin,
+        /* cleanup_plugin */ aom_cleanup_plugin,
+        /* new_encoder */ aom_new_encoder,
+        /* free_encoder */ aom_free_encoder,
+        /* set_parameter_quality */ aom_set_parameter_quality,
+        /* get_parameter_quality */ aom_get_parameter_quality,
+        /* set_parameter_lossless */ aom_set_parameter_lossless,
+        /* get_parameter_lossless */ aom_get_parameter_lossless,
+        /* set_parameter_logging_level */ aom_set_parameter_logging_level,
+        /* get_parameter_logging_level */ aom_get_parameter_logging_level,
+        /* list_parameters */ aom_list_parameters,
+        /* set_parameter_integer */ aom_set_parameter_integer,
+        /* get_parameter_integer */ aom_get_parameter_integer,
+        /* set_parameter_boolean */ aom_set_parameter_boolean,
+        /* get_parameter_boolean */ aom_get_parameter_boolean,
+        /* set_parameter_string */ aom_set_parameter_string,
+        /* get_parameter_string */ aom_get_parameter_string,
+        /* query_input_colorspace */ aom_query_input_colorspace,
+        /* encode_image */ aom_encode_image,
+        /* get_compressed_data */ aom_get_compressed_data,
+        /* query_input_colorspace (v2) */ aom_query_input_colorspace2,
+        /* query_encoded_size (v3) */ nullptr,
+        /* minimum_required_libheif_version */ LIBHEIF_MAKE_VERSION(1,21,0),
+        /* start_sequence_encoding (v4) */ aom_start_sequence_encoding,
+        /* encode_sequence_frame (v4) */ aom_encode_sequence_frame,
+        /* end_sequence_encoding (v4) */ aom_end_sequence_encoding,
+        /* get_compressed_data2 (v4) */ aom_get_compressed_data2,
+        /* does_indicate_keyframes (v4) */ 1
+    };
+
+const heif_encoder_plugin* get_encoder_plugin_aom()
+{
+  return &encoder_plugin_aom;
+}
+
+
+#if PLUGIN_AOM_ENCODER
+heif_plugin_info plugin_info {
+  1,
+  heif_plugin_type_encoder,
+  &encoder_plugin_aom
+};
+#endif
diff --git a/libheif/heif_encoder_aom.h b/libheif/plugins/encoder_aom.h
similarity index 75%
rename from libheif/heif_encoder_aom.h
rename to libheif/plugins/encoder_aom.h
index 0e6cf99b01..f1717e3588 100644
--- a/libheif/heif_encoder_aom.h
+++ b/libheif/plugins/encoder_aom.h
@@ -1,6 +1,6 @@
 /*
  * HEIF codec.
- * Copyright (c) 2017 struktur AG, Dirk Farin <farin@struktur.de>
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
  *
  * This file is part of libheif.
  *
@@ -18,10 +18,17 @@
  * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef LIBHEIF_HEIF_ENCODER_AOM_H
-#define LIBHEIF_HEIF_ENCODER_AOM_H
+#ifndef LIBHEIF_ENCODER_AOM_H
+#define LIBHEIF_ENCODER_AOM_H
 
+#include "common_utils.h"
 
 const struct heif_encoder_plugin* get_encoder_plugin_aom();
 
+#if PLUGIN_AOM_ENCODER
+extern "C" {
+MAYBE_UNUSED LIBHEIF_API extern heif_plugin_info plugin_info;
+}
+#endif
+
 #endif
diff --git a/libheif/plugins/encoder_jpeg.cc b/libheif/plugins/encoder_jpeg.cc
new file mode 100644
index 0000000000..7dde0e4358
--- /dev/null
+++ b/libheif/plugins/encoder_jpeg.cc
@@ -0,0 +1,534 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "libheif/heif.h"
+#include "libheif/heif_plugin.h"
+#include "encoder_jpeg.h"
+#include <vector>
+#include <cstring>
+#include <cassert>
+#include <algorithm>
+#include <memory>
+#include <cstdio>
+#include <csetjmp>
+
+extern "C" {
+#include <jpeglib.h>
+}
+
+
+struct encoder_struct_jpeg
+{
+  int quality;
+
+  // --- output
+
+  std::vector<uint8_t> compressed_data;
+  bool data_read = false;
+};
+
+
+static const int JPEG_PLUGIN_PRIORITY = 100;
+
+#define MAX_PLUGIN_NAME_LENGTH 80
+
+static char plugin_name[MAX_PLUGIN_NAME_LENGTH];
+
+
+static void jpeg_set_default_parameters(void* encoder);
+
+
+#define xstr(s) str(s)
+#define str(s) #s
+
+static const char* jpeg_plugin_name()
+{
+#ifdef LIBJPEG_TURBO_VERSION
+  snprintf(plugin_name, MAX_PLUGIN_NAME_LENGTH - 1, "libjpeg-turbo " xstr(LIBJPEG_TURBO_VERSION) " (libjpeg %d.%d)", JPEG_LIB_VERSION / 10, JPEG_LIB_VERSION % 10);
+  plugin_name[MAX_PLUGIN_NAME_LENGTH - 1] = 0;
+#else
+  sprintf(plugin_name, "libjpeg %d.%d", JPEG_LIB_VERSION/10, JPEG_LIB_VERSION%10);
+#endif
+
+  return plugin_name;
+}
+
+#define MAX_NPARAMETERS 10
+
+static heif_encoder_parameter jpeg_encoder_params[MAX_NPARAMETERS];
+static const heif_encoder_parameter* jpeg_encoder_parameter_ptrs[MAX_NPARAMETERS + 1];
+
+static void jpeg_init_parameters()
+{
+  heif_encoder_parameter* p = jpeg_encoder_params;
+  const heif_encoder_parameter** d = jpeg_encoder_parameter_ptrs;
+  int i = 0;
+
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = heif_encoder_parameter_name_quality;
+  p->type = heif_encoder_parameter_type_integer;
+  p->integer.default_value = 50;
+  p->has_default = true;
+  p->integer.have_minimum_maximum = true;
+  p->integer.minimum = 0;
+  p->integer.maximum = 100;
+  p->integer.valid_values = NULL;
+  p->integer.num_valid_values = 0;
+  d[i++] = p++;
+
+  /*
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = heif_encoder_parameter_name_lossless;
+  p->type = heif_encoder_parameter_type_boolean;
+  p->boolean.default_value = false;
+  p->has_default = true;
+  d[i++] = p++;
+*/
+
+  d[i++] = nullptr;
+}
+
+
+const heif_encoder_parameter** jpeg_list_parameters(void* encoder)
+{
+  return jpeg_encoder_parameter_ptrs;
+}
+
+static void jpeg_init_plugin()
+{
+  jpeg_init_parameters();
+}
+
+
+static void jpeg_cleanup_plugin()
+{
+}
+
+heif_error jpeg_new_encoder(void** enc)
+{
+  auto* encoder = new encoder_struct_jpeg();
+  heif_error err = heif_error_ok;
+
+  *enc = encoder;
+
+  // set default parameters
+
+  jpeg_set_default_parameters(encoder);
+
+  return err;
+}
+
+void jpeg_free_encoder(void* encoder_raw)
+{
+  auto* encoder = (encoder_struct_jpeg*) encoder_raw;
+
+  delete encoder;
+}
+
+
+heif_error jpeg_set_parameter_quality(void* encoder_raw, int quality)
+{
+  auto* encoder = (encoder_struct_jpeg*) encoder_raw;
+
+  if (quality < 0 || quality > 100) {
+    return heif_error_invalid_parameter_value;
+  }
+
+  encoder->quality = quality;
+
+  return heif_error_ok;
+}
+
+heif_error jpeg_get_parameter_quality(void* encoder_raw, int* quality)
+{
+  auto* encoder = (encoder_struct_jpeg*) encoder_raw;
+
+  *quality = encoder->quality;
+
+  return heif_error_ok;
+}
+
+heif_error jpeg_set_parameter_lossless(void* encoder_raw, int enable)
+{
+  auto* encoder = (encoder_struct_jpeg*) encoder_raw;
+
+  if (enable) {
+    encoder->quality = 100; // not really lossless, but the best we can do
+  }
+
+  return heif_error_ok;
+}
+
+heif_error jpeg_get_parameter_lossless(void* encoder_raw, int* enable)
+{
+  auto* encoder = (encoder_struct_jpeg*) encoder_raw;
+
+  *enable = (encoder->quality == 100);  // not really correct, but matches the setting above
+
+  return heif_error_ok;
+}
+
+heif_error jpeg_set_parameter_logging_level(void* encoder_raw, int logging)
+{
+  return heif_error_ok;
+}
+
+heif_error jpeg_get_parameter_logging_level(void* encoder_raw, int* loglevel)
+{
+  *loglevel = 0;
+
+  return heif_error_ok;
+}
+
+#define set_value(paramname, paramvar) if (strcmp(name, paramname)==0) { encoder->paramvar = value; return heif_error_ok; }
+#define get_value(paramname, paramvar) if (strcmp(name, paramname)==0) { *value = encoder->paramvar; return heif_error_ok; }
+
+
+heif_error jpeg_set_parameter_integer(void* encoder_raw, const char* name, int value)
+{
+  encoder_struct_jpeg* encoder = (encoder_struct_jpeg*) encoder_raw;
+
+  if (strcmp(name, heif_encoder_parameter_name_quality) == 0) {
+    return jpeg_set_parameter_quality(encoder, value);
+  }
+  else if (strcmp(name, heif_encoder_parameter_name_lossless) == 0) {
+    return jpeg_set_parameter_lossless(encoder, value);
+  }
+
+  return heif_error_unsupported_parameter;
+}
+
+heif_error jpeg_get_parameter_integer(void* encoder_raw, const char* name, int* value)
+{
+  auto* encoder = (encoder_struct_jpeg*) encoder_raw;
+
+  if (strcmp(name, heif_encoder_parameter_name_quality) == 0) {
+    return jpeg_get_parameter_quality(encoder, value);
+  }
+  else if (strcmp(name, heif_encoder_parameter_name_lossless) == 0) {
+    return jpeg_get_parameter_lossless(encoder, value);
+  }
+
+  return heif_error_unsupported_parameter;
+}
+
+
+heif_error jpeg_set_parameter_boolean(void* encoder_raw, const char* name, int value)
+{
+  auto* encoder = (encoder_struct_jpeg*) encoder_raw;
+
+  if (strcmp(name, heif_encoder_parameter_name_lossless) == 0) {
+    return jpeg_set_parameter_lossless(encoder, value);
+  }
+
+  //set_value(kParam_realtime, realtime_mode);
+
+  return heif_error_unsupported_parameter;
+}
+
+heif_error jpeg_get_parameter_boolean(void* encoder_raw, const char* name, int* value)
+{
+  auto* encoder = (encoder_struct_jpeg*) encoder_raw;
+
+  if (strcmp(name, heif_encoder_parameter_name_lossless) == 0) {
+    return jpeg_get_parameter_lossless(encoder, value);
+  }
+
+  //get_value(kParam_realtime, realtime_mode);
+
+  return heif_error_unsupported_parameter;
+}
+
+
+heif_error jpeg_set_parameter_string(void* encoder_raw, const char* name, const char* value)
+{
+  //auto* encoder = (struct encoder_struct_jpeg*) encoder_raw;
+
+  return heif_error_unsupported_parameter;
+}
+
+
+heif_error jpeg_get_parameter_string(void* encoder_raw, const char* name,
+                                     char* value, int value_size)
+{
+  //auto* encoder = (struct encoder_struct_jpeg*) encoder_raw;
+
+  return heif_error_unsupported_parameter;
+}
+
+
+static void jpeg_set_default_parameters(void* encoder)
+{
+  for (const heif_encoder_parameter** p = jpeg_encoder_parameter_ptrs; *p; p++) {
+    const heif_encoder_parameter* param = *p;
+
+    if (param->has_default) {
+      switch (param->type) {
+        case heif_encoder_parameter_type_integer:
+          jpeg_set_parameter_integer(encoder, param->name, param->integer.default_value);
+          break;
+        case heif_encoder_parameter_type_boolean:
+          jpeg_set_parameter_boolean(encoder, param->name, param->boolean.default_value);
+          break;
+        case heif_encoder_parameter_type_string:
+          // NOLINTNEXTLINE(build/include_what_you_use)
+          jpeg_set_parameter_string(encoder, param->name, param->string.default_value);
+          break;
+      }
+    }
+  }
+}
+
+
+void jpeg_query_input_colorspace(heif_colorspace* colorspace, heif_chroma* chroma)
+{
+  *colorspace = heif_colorspace_YCbCr;
+  *chroma = heif_chroma_420;
+}
+
+
+void jpeg_query_input_colorspace2(void* encoder_raw, heif_colorspace* colorspace, heif_chroma* chroma)
+{
+  //auto* encoder = (struct encoder_struct_jpeg*) encoder_raw;
+
+  // TODO: support encoding greyscale JPEGs
+
+  *colorspace = heif_colorspace_YCbCr;
+  *chroma = heif_chroma_420;
+}
+
+
+void jpeg_query_encoded_size(void* encoder_raw, uint32_t input_width, uint32_t input_height,
+                             uint32_t* encoded_width, uint32_t* encoded_height)
+{
+  *encoded_width = input_width;
+  *encoded_height = input_height;
+}
+
+
+struct ErrorHandler
+{
+  jpeg_error_mgr pub;  /* "public" fields */
+  jmp_buf setjmp_buffer;  /* for return to caller */
+};
+
+static void OnJpegError(j_common_ptr cinfo)
+{
+  ErrorHandler* handler = reinterpret_cast<ErrorHandler*>(cinfo->err);
+  longjmp(handler->setjmp_buffer, 1);
+}
+
+
+heif_error jpeg_encode_image(void* encoder_raw, const heif_image* image,
+                             heif_image_input_class input_class)
+{
+  auto* encoder = (encoder_struct_jpeg*) encoder_raw;
+
+
+  jpeg_compress_struct cinfo;
+  ErrorHandler jerr;
+  cinfo.err = jpeg_std_error(reinterpret_cast<jpeg_error_mgr*>(&jerr));
+  jerr.pub.error_exit = &OnJpegError;
+  if (setjmp(jerr.setjmp_buffer)) {
+    cinfo.err->output_message(reinterpret_cast<j_common_ptr>(&cinfo));
+    jpeg_destroy_compress(&cinfo);
+    return heif_error{heif_error_Encoding_error, heif_suberror_Encoder_encoding, "JPEG encoding error"};
+  }
+
+  if (heif_image_get_bits_per_pixel(image, heif_channel_Y) != 8) {
+    jpeg_destroy_compress(&cinfo);
+    return heif_error{heif_error_Encoding_error, heif_suberror_Encoder_encoding, "Cannot write JPEG image with >8 bpp."};
+  }
+
+  uint8_t* outbuffer = nullptr;
+#if defined(LIBJPEG_TURBO_VERSION) || (JPEG_LIB_VERSION_MAJOR < 9 || (JPEG_LIB_VERSION_MAJOR == 9 && JPEG_LIB_VERSION_MINOR < 4))
+  unsigned long outlength = 0;
+#else
+  size_t outlength = 0;
+#endif
+
+  jpeg_create_compress(&cinfo);
+  jpeg_mem_dest(&cinfo, &outbuffer, &outlength);
+
+  cinfo.image_width = heif_image_get_width(image, heif_channel_Y);
+  cinfo.image_height = heif_image_get_height(image, heif_channel_Y);
+  cinfo.input_components = 3;
+  cinfo.in_color_space = JCS_YCbCr;
+  jpeg_set_defaults(&cinfo);
+  static const boolean kForceBaseline = TRUE;
+  jpeg_set_quality(&cinfo, encoder->quality, kForceBaseline);
+  static const boolean kWriteAllTables = TRUE;
+  jpeg_start_compress(&cinfo, kWriteAllTables);
+
+
+
+  size_t stride_y;
+  const uint8_t* row_y = heif_image_get_plane_readonly2(image, heif_channel_Y,
+                                                        &stride_y);
+  size_t stride_u;
+  const uint8_t* row_u = heif_image_get_plane_readonly2(image, heif_channel_Cb,
+                                                        &stride_u);
+  size_t stride_v;
+  const uint8_t* row_v = heif_image_get_plane_readonly2(image, heif_channel_Cr,
+                                                        &stride_v);
+
+  JSAMPARRAY buffer = cinfo.mem->alloc_sarray(
+      reinterpret_cast<j_common_ptr>(&cinfo), JPOOL_IMAGE,
+      cinfo.image_width * cinfo.input_components, 1);
+  JSAMPROW row[1] = {buffer[0]};
+
+  while (cinfo.next_scanline < cinfo.image_height) {
+    size_t offset_y = cinfo.next_scanline * stride_y;
+    const uint8_t* start_y = &row_y[offset_y];
+    size_t offset_u = (cinfo.next_scanline / 2) * stride_u;
+    const uint8_t* start_u = &row_u[offset_u];
+    size_t offset_v = (cinfo.next_scanline / 2) * stride_v;
+    const uint8_t* start_v = &row_v[offset_v];
+
+    JOCTET* bufp = buffer[0];
+    for (JDIMENSION x = 0; x < cinfo.image_width; ++x) {
+      *bufp++ = start_y[x];
+      *bufp++ = start_u[x / 2];
+      *bufp++ = start_v[x / 2];
+    }
+    jpeg_write_scanlines(&cinfo, row, 1);
+  }
+  jpeg_finish_compress(&cinfo);
+  jpeg_destroy_compress(&cinfo);
+
+  encoder->data_read = false;
+  encoder->compressed_data.resize(outlength);
+  memcpy(encoder->compressed_data.data(), outbuffer, outlength);
+
+  free(outbuffer);
+
+  return heif_error_ok;
+}
+
+
+heif_error jpeg_get_compressed_data(void* encoder_raw, uint8_t** data, int* size,
+                                    heif_encoded_data_type* type)
+{
+  auto* encoder = (encoder_struct_jpeg*) encoder_raw;
+
+  if (encoder->data_read) {
+    *data = nullptr;
+    *size = 0;
+  }
+  else {
+    *data = encoder->compressed_data.data();
+    *size = (int) encoder->compressed_data.size();
+    encoder->data_read = true;
+  }
+
+  return heif_error_ok;
+}
+
+
+heif_error jpeg_start_sequence_encoding(void* encoder, const heif_image* image,
+                                       enum heif_image_input_class image_class,
+                                       uint32_t framerate_num, uint32_t framerate_denom,
+                                       const heif_sequence_encoding_options* options)
+{
+  return heif_error_ok;
+}
+
+heif_error jpeg_encode_sequence_frame(void* encoder, const heif_image* image, uintptr_t frame_nr)
+{
+  return jpeg_encode_image(encoder, image, heif_image_input_class_normal);
+}
+
+heif_error jpeg_end_sequence_encoding(void* encoder)
+{
+  return heif_error_ok;
+}
+
+heif_error jpeg_get_compressed_data2(void* encoder, uint8_t** data, int* size,
+                                    uintptr_t* frame_nr,
+                                    int* is_keyframe, int* more_frame_packets)
+{
+  heif_error err = jpeg_get_compressed_data(encoder, data, size, nullptr);
+
+  if (is_keyframe) {
+    *is_keyframe = true;
+  }
+
+  if (more_frame_packets) {
+    *more_frame_packets = true;
+  }
+
+  return err;
+}
+
+
+static const heif_encoder_plugin encoder_plugin_jpeg
+    {
+        /* plugin_api_version */ 4,
+        /* compression_format */ heif_compression_JPEG,
+        /* id_name */ "jpeg",
+        /* priority */ JPEG_PLUGIN_PRIORITY,
+        /* supports_lossy_compression */ true,
+        /* supports_lossless_compression */ false,
+        /* get_plugin_name */ jpeg_plugin_name,
+        /* init_plugin */ jpeg_init_plugin,
+        /* cleanup_plugin */ jpeg_cleanup_plugin,
+        /* new_encoder */ jpeg_new_encoder,
+        /* free_encoder */ jpeg_free_encoder,
+        /* set_parameter_quality */ jpeg_set_parameter_quality,
+        /* get_parameter_quality */ jpeg_get_parameter_quality,
+        /* set_parameter_lossless */ jpeg_set_parameter_lossless,
+        /* get_parameter_lossless */ jpeg_get_parameter_lossless,
+        /* set_parameter_logging_level */ jpeg_set_parameter_logging_level,
+        /* get_parameter_logging_level */ jpeg_get_parameter_logging_level,
+        /* list_parameters */ jpeg_list_parameters,
+        /* set_parameter_integer */ jpeg_set_parameter_integer,
+        /* get_parameter_integer */ jpeg_get_parameter_integer,
+        /* set_parameter_boolean */ jpeg_set_parameter_boolean,
+        /* get_parameter_boolean */ jpeg_get_parameter_boolean,
+        /* set_parameter_string */ jpeg_set_parameter_string,
+        /* get_parameter_string */ jpeg_get_parameter_string,
+        /* query_input_colorspace */ jpeg_query_input_colorspace,
+        /* encode_image */ jpeg_encode_image,
+        /* get_compressed_data */ jpeg_get_compressed_data,
+        /* query_input_colorspace (v2) */ jpeg_query_input_colorspace2,
+        /* query_encoded_size (v3) */ jpeg_query_encoded_size,
+        /* minimum_required_libheif_version */ LIBHEIF_MAKE_VERSION(1,21,0),
+        /* start_sequence_encoding (v4) */ jpeg_start_sequence_encoding,
+        /* encode_sequence_frame (v4) */ jpeg_encode_sequence_frame,
+        /* end_sequence_encoding (v4) */ jpeg_end_sequence_encoding,
+        /* get_compressed_data2 (v4) */ jpeg_get_compressed_data2,
+        /* does_indicate_keyframes (v4) */ 1
+    };
+
+const heif_encoder_plugin* get_encoder_plugin_jpeg()
+{
+  return &encoder_plugin_jpeg;
+}
+
+
+#if PLUGIN_JPEG_ENCODER
+heif_plugin_info plugin_info{
+    1,
+    heif_plugin_type_encoder,
+    &encoder_plugin_jpeg
+};
+#endif
diff --git a/libheif/plugins/encoder_jpeg.h b/libheif/plugins/encoder_jpeg.h
new file mode 100644
index 0000000000..bd59aa660d
--- /dev/null
+++ b/libheif/plugins/encoder_jpeg.h
@@ -0,0 +1,34 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_ENCODER_JPEG_H
+#define LIBHEIF_ENCODER_JPEG_H
+
+#include "common_utils.h"
+
+const struct heif_encoder_plugin* get_encoder_plugin_jpeg();
+
+#if PLUGIN_JPEG_ENCODER
+extern "C" {
+MAYBE_UNUSED LIBHEIF_API extern heif_plugin_info plugin_info;
+}
+#endif
+
+#endif
diff --git a/libheif/plugins/encoder_kvazaar.cc b/libheif/plugins/encoder_kvazaar.cc
new file mode 100644
index 0000000000..318e60291c
--- /dev/null
+++ b/libheif/plugins/encoder_kvazaar.cc
@@ -0,0 +1,978 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "libheif/heif.h"
+#include "libheif/heif_plugin.h"
+#include "encoder_kvazaar.h"
+#include <memory>
+#include <string>   // apparently, this is a false positive of cpplint
+#include <cstring>
+#include <cassert>
+#include <vector>
+#include <algorithm>
+#include <deque>
+#include <iostream>
+#include <utility>
+
+extern "C" {
+#include <kvazaar.h>
+}
+
+
+static const char* kError_unspecified_error = "Unspecified encoder error";
+static const char* kError_unsupported_bit_depth = "Bit depth not supported by kvazaar";
+static const char* kError_unsupported_chroma = "Unsupported chroma type";
+//static const char* kError_unsupported_image_size = "Images smaller than 16 pixels are not supported";
+
+
+struct encoder_struct_kvazaar
+{
+  // --- parameters
+
+  int quality = 75;
+  bool lossless = false;
+
+  // --- input config
+
+  //heif_color_profile_nclx* nclx = nullptr;
+
+  // --- encoder
+
+  const kvz_api* api = nullptr;
+  kvz_config* config = nullptr;
+  kvz_encoder* kvzencoder = nullptr;
+
+  // --- output
+
+  struct Packet
+  {
+    std::vector<uint8_t> data;
+    uintptr_t frameNr = 0;
+  };
+
+  std::deque<Packet> output_data;
+
+  std::vector<uint8_t> active_data; // holds the data that we just returned
+
+
+  ~encoder_struct_kvazaar()
+  {
+    /*
+    if (nclx) {
+      heif_nclx_color_profile_free(nclx);
+    }
+    */
+
+    if (kvzencoder) {
+      api->encoder_close(kvzencoder);
+    }
+
+    if (config) {
+      api->config_destroy(config);
+    }
+  }
+};
+
+static const int kvazaar_PLUGIN_PRIORITY = 100;
+
+#define MAX_PLUGIN_NAME_LENGTH 80
+
+static char plugin_name[MAX_PLUGIN_NAME_LENGTH];
+
+
+static void kvazaar_set_default_parameters(void* encoder);
+
+
+static const char* kvazaar_plugin_name()
+{
+#if HAVE_KVAZAAR_VERSION_STRING
+  snprintf(plugin_name, MAX_PLUGIN_NAME_LENGTH, "kvazaar HEVC encoder %s", kvz_get_version_string());
+#else
+  strcpy(plugin_name, "kvazaar HEVC encoder");
+#endif
+  return plugin_name;
+}
+
+
+#define MAX_NPARAMETERS 10
+
+static heif_encoder_parameter kvazaar_encoder_params[MAX_NPARAMETERS];
+static const heif_encoder_parameter* kvazaar_encoder_parameter_ptrs[MAX_NPARAMETERS + 1];
+
+static void kvazaar_init_parameters()
+{
+  heif_encoder_parameter* p = kvazaar_encoder_params;
+  const heif_encoder_parameter** d = kvazaar_encoder_parameter_ptrs;
+  int i = 0;
+
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = heif_encoder_parameter_name_quality;
+  p->type = heif_encoder_parameter_type_integer;
+  p->integer.default_value = 50;
+  p->has_default = true;
+  p->integer.have_minimum_maximum = true;
+  p->integer.minimum = 0;
+  p->integer.maximum = 100;
+  p->integer.valid_values = NULL;
+  p->integer.num_valid_values = 0;
+  d[i++] = p++;
+
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = heif_encoder_parameter_name_lossless;
+  p->type = heif_encoder_parameter_type_boolean;
+  p->boolean.default_value = false;
+  p->has_default = true;
+  d[i++] = p++;
+
+  d[i++] = nullptr;
+}
+
+
+const heif_encoder_parameter** kvazaar_list_parameters(void* encoder)
+{
+  return kvazaar_encoder_parameter_ptrs;
+}
+
+
+static void kvazaar_init_plugin()
+{
+  kvazaar_init_parameters();
+}
+
+
+static void kvazaar_cleanup_plugin()
+{
+}
+
+
+static heif_error kvazaar_new_encoder(void** enc)
+{
+  encoder_struct_kvazaar* encoder = new encoder_struct_kvazaar();
+  heif_error err = heif_error_ok;
+
+  *enc = encoder;
+
+  // set default parameters
+
+  kvazaar_set_default_parameters(encoder);
+
+  return err;
+}
+
+static void kvazaar_free_encoder(void* encoder_raw)
+{
+  encoder_struct_kvazaar* encoder = (encoder_struct_kvazaar*) encoder_raw;
+
+  delete encoder;
+}
+
+static heif_error kvazaar_set_parameter_quality(void* encoder_raw, int quality)
+{
+  encoder_struct_kvazaar* encoder = (encoder_struct_kvazaar*) encoder_raw;
+
+  if (quality < 0 || quality > 100) {
+    return heif_error_invalid_parameter_value;
+  }
+
+  encoder->quality = quality;
+
+  return heif_error_ok;
+}
+
+static heif_error kvazaar_get_parameter_quality(void* encoder_raw, int* quality)
+{
+  encoder_struct_kvazaar* encoder = (encoder_struct_kvazaar*) encoder_raw;
+
+  *quality = encoder->quality;
+
+  return heif_error_ok;
+}
+
+static heif_error kvazaar_set_parameter_lossless(void* encoder_raw, int enable)
+{
+  encoder_struct_kvazaar* encoder = (encoder_struct_kvazaar*) encoder_raw;
+
+  encoder->lossless = enable ? 1 : 0;
+
+  return heif_error_ok;
+}
+
+static heif_error kvazaar_get_parameter_lossless(void* encoder_raw, int* enable)
+{
+  encoder_struct_kvazaar* encoder = (encoder_struct_kvazaar*) encoder_raw;
+
+  *enable = encoder->lossless;
+
+  return heif_error_ok;
+}
+
+static heif_error kvazaar_set_parameter_logging_level(void* encoder_raw, int logging)
+{
+//  struct encoder_struct_kvazaar* encoder = (struct encoder_struct_kvazaar*) encoder_raw;
+
+// return heif_error_invalid_parameter_value;
+
+  return heif_error_ok;
+}
+
+static heif_error kvazaar_get_parameter_logging_level(void* encoder_raw, int* loglevel)
+{
+//  struct encoder_struct_kvazaar* encoder = (struct encoder_struct_kvazaar*) encoder_raw;
+
+  *loglevel = 0;
+
+  return heif_error_ok;
+}
+
+
+static heif_error kvazaar_set_parameter_integer(void* encoder_raw, const char* name, int value)
+{
+  encoder_struct_kvazaar* encoder = (encoder_struct_kvazaar*) encoder_raw;
+
+  if (strcmp(name, heif_encoder_parameter_name_quality) == 0) {
+    return kvazaar_set_parameter_quality(encoder, value);
+  }
+  else if (strcmp(name, heif_encoder_parameter_name_lossless) == 0) {
+    return kvazaar_set_parameter_lossless(encoder, value);
+  }
+
+  return heif_error_unsupported_parameter;
+}
+
+static heif_error kvazaar_get_parameter_integer(void* encoder_raw, const char* name, int* value)
+{
+  encoder_struct_kvazaar* encoder = (encoder_struct_kvazaar*) encoder_raw;
+
+  if (strcmp(name, heif_encoder_parameter_name_quality) == 0) {
+    return kvazaar_get_parameter_quality(encoder, value);
+  }
+  else if (strcmp(name, heif_encoder_parameter_name_lossless) == 0) {
+    return kvazaar_get_parameter_lossless(encoder, value);
+  }
+
+  return heif_error_unsupported_parameter;
+}
+
+
+static heif_error kvazaar_set_parameter_boolean(void* encoder, const char* name, int value)
+{
+  if (strcmp(name, heif_encoder_parameter_name_lossless) == 0) {
+    return kvazaar_set_parameter_lossless(encoder, value);
+  }
+
+  return heif_error_unsupported_parameter;
+}
+
+// Unused, will use "kvazaar_get_parameter_integer" instead.
+/*
+static struct heif_error kvazaar_get_parameter_boolean(void* encoder, const char* name, int* value)
+{
+  if (strcmp(name, heif_encoder_parameter_name_lossless)==0) {
+    return kvazaar_get_parameter_lossless(encoder,value);
+  }
+
+  return heif_error_unsupported_parameter;
+}
+*/
+
+
+static heif_error kvazaar_set_parameter_string(void* encoder_raw, const char* name, const char* value)
+{
+  return heif_error_unsupported_parameter;
+}
+
+static heif_error kvazaar_get_parameter_string(void* encoder_raw, const char* name,
+                                               char* value, int value_size)
+{
+  return heif_error_unsupported_parameter;
+}
+
+
+static void kvazaar_set_default_parameters(void* encoder)
+{
+  for (const heif_encoder_parameter** p = kvazaar_encoder_parameter_ptrs; *p; p++) {
+    const heif_encoder_parameter* param = *p;
+
+    if (param->has_default) {
+      switch (param->type) {
+        case heif_encoder_parameter_type_integer:
+          kvazaar_set_parameter_integer(encoder, param->name, param->integer.default_value);
+          break;
+        case heif_encoder_parameter_type_boolean:
+          kvazaar_set_parameter_boolean(encoder, param->name, param->boolean.default_value);
+          break;
+        case heif_encoder_parameter_type_string:
+          kvazaar_set_parameter_string(encoder, param->name, param->string.default_value);
+          break;
+      }
+    }
+  }
+}
+
+
+static void kvazaar_query_input_colorspace(heif_colorspace* colorspace, heif_chroma* chroma)
+{
+  if (*colorspace == heif_colorspace_monochrome) {
+    *colorspace = heif_colorspace_monochrome;
+    *chroma = heif_chroma_monochrome;
+  }
+  else {
+    *colorspace = heif_colorspace_YCbCr;
+    *chroma = heif_chroma_420;
+  }
+}
+
+
+static void kvazaar_query_input_colorspace2(void* encoder_raw, heif_colorspace* colorspace, heif_chroma* chroma)
+{
+  if (*colorspace == heif_colorspace_monochrome) {
+    *colorspace = heif_colorspace_monochrome;
+    *chroma = heif_chroma_monochrome;
+  }
+  else {
+    *colorspace = heif_colorspace_YCbCr;
+    if (*chroma != heif_chroma_420) {
+      // Encoding to 4:2:2 and 4:4:4 currently does not work with Kvazaar (https://github.com/ultravideo/kvazaar/issues/418).
+      *chroma = heif_chroma_420;
+    }
+  }
+}
+
+void kvazaar_query_encoded_size(void* encoder_raw, uint32_t input_width, uint32_t input_height,
+                                uint32_t* encoded_width, uint32_t* encoded_height)
+{
+  *encoded_width = (input_width + 7) & ~0x7;
+  *encoded_height = (input_height + 7) & ~0x7;
+}
+
+
+#if 0
+static int rounded_size(int s)
+{
+  s = (s + 1) & ~1;
+
+  if (s < 64) {
+    s = 64;
+  }
+
+  return s;
+}
+#endif
+
+static void append_chunk_data(kvz_data_chunk* data, encoder_struct_kvazaar* encoder, uintptr_t pts)
+{
+  if (!data || data->len == 0) {
+    return;
+  }
+
+  std::vector<uint8_t> input_data;
+  while (data) {
+    input_data.insert(input_data.end(), data->data, data->data + data->len);
+    data = data->next;
+  }
+
+  //std::vector<uint8_t>& pktdata = encoder->output_data.front().data;
+  size_t start_idx = 0;
+
+  for (;;)
+  {
+    while (start_idx < input_data.size() - 3 &&
+           (input_data[start_idx] != 0 ||
+            input_data[start_idx + 1] != 0 ||
+            input_data[start_idx + 2] != 1)) {
+      start_idx++;
+    }
+
+    size_t end_idx = start_idx + 1;
+
+    while (end_idx < input_data.size() - 3 &&
+           (input_data[end_idx] != 0 ||
+            input_data[end_idx + 1] != 0 ||
+            input_data[end_idx + 2] != 1)) {
+      end_idx++;
+    }
+
+    if (end_idx == input_data.size() - 3) {
+      end_idx = input_data.size();
+    }
+
+    encoder_struct_kvazaar::Packet pkt;
+    pkt.data.resize(end_idx - start_idx - 3);
+    memcpy(pkt.data.data(), input_data.data() + start_idx + 3, pkt.data.size());
+    pkt.frameNr = pts;
+
+    // std::cout << "append frameNr=" << pts << " NAL:" << ((int)pkt.data[0]>>1) << " size:" << pkt.data.size() << "\n";
+
+    encoder->output_data.emplace_back(std::move(pkt));
+
+    if (end_idx == input_data.size()) {
+      break;
+    }
+
+    start_idx = end_idx;
+  }
+}
+
+
+static void copy_plane(kvz_pixel* out_p, size_t out_stride, const uint8_t* in_p, size_t in_stride,
+                       uint32_t w, uint32_t h, uint32_t padded_width, uint32_t padded_height,
+                       int bit_depth)
+{
+  int bpp = (bit_depth > 8) ? 2 : 1;
+
+  for (uint32_t y = 0; y < padded_height; y++) {
+    int sy = std::min(y, h - 1); // source y
+    memcpy(out_p + y * out_stride, in_p + sy * in_stride, w * bpp);
+
+    if (padded_width > w) {
+      memset(out_p + y * out_stride + w, *(in_p + sy * in_stride + w - 1), (padded_width - w) * bpp);
+    }
+  }
+}
+
+
+template<typename T, typename D>
+std::unique_ptr<T, D> make_guard(T* ptr, D&& deleter) {
+    return std::unique_ptr<T, D>(ptr, deleter);
+}
+
+static heif_error kvazaar_start_sequence_encoding_intern(void* encoder_raw, const heif_image* image,
+                                                         enum heif_image_input_class input_class,
+                                                         uint32_t framerate_num, uint32_t framerate_denom,
+                                                         const heif_sequence_encoding_options* options,
+                                                         bool image_sequence)
+{
+  encoder_struct_kvazaar* encoder = (encoder_struct_kvazaar*) encoder_raw;
+
+  int bit_depth = heif_image_get_bits_per_pixel_range(image, heif_channel_Y);
+
+  // Kvazaar uses a hard-coded bit depth (https://github.com/ultravideo/kvazaar/issues/399).
+  // Check whether this matches to the image bit depth.
+  // TODO: we should check the bit depth supported by the encoder (like query_input_colorspace2()) and output a warning
+  //       if we have to encode at a different bit depth than requested.
+  if (bit_depth != KVZ_BIT_DEPTH) {
+    return {
+      heif_error_Encoder_plugin_error,
+      heif_suberror_Unsupported_bit_depth,
+      kError_unsupported_bit_depth
+  };
+  }
+
+  const kvz_api* api = encoder->api = kvz_api_get(bit_depth);
+  if (api == nullptr) {
+    return {
+      heif_error_Encoder_plugin_error,
+      heif_suberror_Unspecified,
+      "Could not initialize Kvazaar API"
+  };
+  }
+
+  kvz_config* config = encoder->config = api->config_alloc();
+  api->config_init(config); // param, encoder->preset.c_str(), encoder->tune.c_str());
+
+#if HAVE_KVAZAAR_ENABLE_LOGGING
+  config->enable_logging_output = 0;
+#endif
+
+#if !ENABLE_MULTITHREADING_SUPPORT
+  // 0: Process everything with main thread
+  // -1 (default): Select automatically.
+  config->threads = 0;
+#endif
+
+  heif_chroma chroma = heif_image_get_chroma_format(image);
+  bool isGreyscale = (heif_image_get_colorspace(image) == heif_colorspace_monochrome);
+
+  int input_width = heif_image_get_width(image, heif_channel_Y);
+  int input_height = heif_image_get_height(image, heif_channel_Y);
+
+  uint32_t encoded_width, encoded_height;
+  kvazaar_query_encoded_size(encoder_raw, input_width, input_height, &encoded_width, &encoded_height);
+
+  config->framerate_num = framerate_num;
+  config->framerate_denom = framerate_denom;
+
+  if (isGreyscale) {
+    config->input_format = KVZ_FORMAT_P400;
+  }
+  else if (chroma == heif_chroma_420) {
+    config->input_format = KVZ_FORMAT_P420;
+  }
+  else if (chroma == heif_chroma_422) {
+    config->input_format = KVZ_FORMAT_P422;
+  }
+  else if (chroma == heif_chroma_444) {
+    config->input_format = KVZ_FORMAT_P444;
+  }
+  else {
+    return heif_error{
+      heif_error_Encoder_plugin_error,
+      heif_suberror_Unsupported_image_type,
+      kError_unsupported_chroma
+    };
+  }
+
+
+  heif_color_profile_nclx* nclx = nullptr;
+  heif_error err = heif_image_get_nclx_color_profile(image, &nclx);
+  if (err.code != heif_error_Ok) {
+    nclx = nullptr;
+  }
+
+  // make sure NCLX profile is deleted at end of function
+  auto nclx_deleter = std::unique_ptr<heif_color_profile_nclx, void (*)(heif_color_profile_nclx*)>(nclx, heif_nclx_color_profile_free);
+
+  if (nclx) {
+    config->vui.fullrange = nclx->full_range_flag;
+  }
+  else {
+    config->vui.fullrange = 1;
+  }
+
+  if (nclx &&
+      (input_class == heif_image_input_class_normal ||
+       input_class == heif_image_input_class_thumbnail)) {
+    config->vui.colorprim = nclx->color_primaries;
+    config->vui.transfer = nclx->transfer_characteristics;
+    config->vui.colormatrix = nclx->matrix_coefficients;
+  }
+
+  config->qp = ((100 - encoder->quality) * 51 + 50) / 100;
+  config->lossless = encoder->lossless ? 1 : 0;
+
+  config->width = encoded_width;
+  config->height = encoded_height;
+
+  if (image_sequence) {
+    // TODO
+    /*
+    config->target_bitrate = options->sequence_bitrate;
+    */
+
+    if (options->keyframe_distance_max) {
+      config->intra_period = options->keyframe_distance_max;
+    }
+
+    switch (options->gop_structure) {
+      case heif_sequence_gop_structure_intra_only:
+        config->intra_period = 1;
+        break;
+      case heif_sequence_gop_structure_lowdelay:
+        config->gop_lowdelay = 1;
+        break;
+      case heif_sequence_gop_structure_unrestricted:
+        break;
+    }
+  }
+
+  kvz_encoder* kvzencoder = encoder->kvzencoder = api->encoder_open(config);
+  if (!kvzencoder) {
+    return heif_error{
+      heif_error_Encoder_plugin_error,
+      heif_suberror_Encoder_encoding,
+      kError_unspecified_error
+  };
+  }
+
+
+  // --- encode headers
+
+  // Not needed. Headers are also output by kvazaar together with the images.
+#if 0
+  kvz_data_chunk* data = nullptr;
+  uint32_t data_len;
+  int success;
+  success = api->encoder_headers(encoder->kvzencoder, &data, &data_len);
+  if (!success) {
+    return heif_error{
+      heif_error_Encoder_plugin_error,
+      heif_suberror_Encoder_encoding,
+      kError_unspecified_error
+  };
+  }
+
+  append_chunk_data(data, encoder, 0);
+
+  if (data) {
+    api->chunk_free(data);
+    data = nullptr;
+  }
+#endif
+
+  return heif_error_ok;
+}
+
+
+
+
+static heif_error kvazaar_encode_sequence_frame(void* encoder_raw, const heif_image* image,
+                                             uintptr_t frame_nr)
+{
+  encoder_struct_kvazaar* encoder = (encoder_struct_kvazaar*) encoder_raw;
+
+  // Note: it is ok to cast away the const, as the image content is not changed.
+  // However, we have to guarantee that there are no plane pointers or stride values kept over calling the svt_encode_image() function.
+  /*
+  err = heif_image_extend_padding_to_size(const_cast<struct heif_image*>(image),
+                                          param->sourceWidth,
+                                          param->sourceHeight);
+  if (err.code) {
+    return err;
+  }
+*/
+
+  const kvz_api* api = encoder->api;
+
+  bool isGreyscale = (heif_image_get_colorspace(image) == heif_colorspace_monochrome);
+  heif_chroma chroma = heif_image_get_chroma_format(image);
+
+  int input_width = heif_image_get_width(image, heif_channel_Y);
+  int input_height = heif_image_get_height(image, heif_channel_Y);
+
+  uint32_t encoded_width, encoded_height;
+  kvazaar_query_encoded_size(encoder_raw, input_width, input_height, &encoded_width, &encoded_height);
+
+  kvz_chroma_format kvzChroma;
+  int chroma_stride_shift = 0;
+  int chroma_height_shift = 0;
+  int input_chroma_width = 0;
+  int input_chroma_height = 0;
+
+  if (isGreyscale) {
+    kvzChroma = KVZ_CSP_400;
+  }
+  else if (chroma == heif_chroma_420) {
+    kvzChroma = KVZ_CSP_420;
+    chroma_stride_shift = 1;
+    chroma_height_shift = 1;
+    input_chroma_width = (input_width + 1) / 2;
+    input_chroma_height = (input_height + 1) / 2;
+  }
+  else if (chroma == heif_chroma_422) {
+    kvzChroma = KVZ_CSP_422;
+    chroma_stride_shift = 1;
+    chroma_height_shift = 0;
+    input_chroma_width = (input_width + 1) / 2;
+    input_chroma_height = input_height;
+  }
+  else if (chroma == heif_chroma_444) {
+    kvzChroma = KVZ_CSP_444;
+    chroma_stride_shift = 0;
+    chroma_height_shift = 0;
+    input_chroma_width = input_width;
+    input_chroma_height = input_height;
+  }
+  else {
+    return heif_error{
+      heif_error_Encoder_plugin_error,
+      heif_suberror_Unsupported_image_type,
+      kError_unsupported_chroma
+    };
+  }
+
+
+  if (chroma != heif_chroma_monochrome) {
+    int w = heif_image_get_width(image, heif_channel_Y);
+    int h = heif_image_get_height(image, heif_channel_Y);
+    if (chroma != heif_chroma_444) { w = (w + 1) / 2; }
+    if (chroma == heif_chroma_420) { h = (h + 1) / 2; }
+
+    assert(heif_image_get_width(image, heif_channel_Cb) == w);
+    assert(heif_image_get_width(image, heif_channel_Cr) == w);
+    assert(heif_image_get_height(image, heif_channel_Cb) == h);
+    assert(heif_image_get_height(image, heif_channel_Cr) == h);
+    (void) w;
+    (void) h;
+  }
+
+
+  auto upic = make_guard(api->picture_alloc_csp(kvzChroma, encoded_width, encoded_height), [api](kvz_picture* pic) { api->picture_free(pic); });
+  kvz_picture* pic = upic.get();
+  if (!pic) {
+    return heif_error{
+        heif_error_Encoder_plugin_error,
+        heif_suberror_Encoder_encoding,
+        kError_unspecified_error
+    };
+  }
+
+  int bit_depth = heif_image_get_bits_per_pixel_range(image, heif_channel_Y);
+  int bit_depth_chroma = 0;
+
+  if (!isGreyscale) {
+    bit_depth_chroma = heif_image_get_bits_per_pixel_range(image, heif_channel_Cb);
+    if (bit_depth != bit_depth_chroma) {
+      return {
+        heif_error_Encoder_plugin_error,
+        heif_suberror_Unsupported_bit_depth,
+        "Luma bit depth must equal the chroma bit depth"
+      };
+    }
+  }
+
+  if (isGreyscale) {
+    size_t stride;
+    const uint8_t* data = heif_image_get_plane_readonly2(image, heif_channel_Y, &stride);
+
+    copy_plane(pic->y, pic->stride, data, stride, input_width, input_height, encoded_width, encoded_height, bit_depth);
+  }
+  else {
+    size_t stride;
+    const uint8_t* data;
+
+    data = heif_image_get_plane_readonly2(image, heif_channel_Y, &stride);
+    copy_plane(pic->y, pic->stride, data, stride, input_width, input_height, encoded_width, encoded_height, bit_depth);
+
+    data = heif_image_get_plane_readonly2(image, heif_channel_Cb, &stride);
+    copy_plane(pic->u, pic->stride >> chroma_stride_shift, data, stride, input_chroma_width, input_chroma_height,
+               encoded_width >> chroma_stride_shift, encoded_height >> chroma_height_shift, bit_depth_chroma);
+
+    data = heif_image_get_plane_readonly2(image, heif_channel_Cr, &stride);
+    copy_plane(pic->v, pic->stride >> chroma_stride_shift, data, stride, input_chroma_width, input_chroma_height,
+               encoded_width >> chroma_stride_shift, encoded_height >> chroma_height_shift, bit_depth_chroma);
+  }
+
+  pic->pts = frame_nr;
+
+  kvz_data_chunk* data = nullptr;
+  uint32_t data_len;
+
+  kvz_picture* picture_out = nullptr;
+
+  int success;
+  success = api->encoder_encode(encoder->kvzencoder,
+                                pic,
+                                &data, &data_len,
+                                &picture_out, nullptr, nullptr);
+  if (!success) {
+    return heif_error{
+        heif_error_Encoder_plugin_error,
+        heif_suberror_Encoder_encoding,
+        kError_unspecified_error
+    };
+  }
+
+  append_chunk_data(data, encoder, picture_out ? picture_out->pts : 0);
+
+  if (data) {
+    api->chunk_free(data);
+    data = nullptr;
+  }
+
+  api->picture_free(picture_out);
+
+  (void) success;
+  return heif_error_ok;
+}
+
+
+static heif_error kvazaar_end_sequence_encoding(void* encoder_raw)
+{
+  encoder_struct_kvazaar* encoder = (encoder_struct_kvazaar*) encoder_raw;
+  const kvz_api* api = encoder->api;
+
+
+  for (;;) {
+    kvz_data_chunk* data = nullptr;
+    uint32_t data_len;
+
+    kvz_picture* picture_out;
+
+    int success = api->encoder_encode(encoder->kvzencoder,
+                                  nullptr,
+                                  &data, &data_len,
+                                  &picture_out, nullptr, nullptr);
+    if (!success) {
+      return heif_error{
+        heif_error_Encoder_plugin_error,
+        heif_suberror_Encoder_encoding,
+        kError_unspecified_error
+    };
+    }
+
+    if (data == nullptr || data->len == 0) {
+      break;
+    }
+
+    append_chunk_data(data, encoder, picture_out->pts);
+
+    api->picture_free(picture_out);
+    api->chunk_free(data);
+  }
+
+  return heif_error_ok;
+}
+
+
+static heif_error kvazaar_get_compressed_data_intern(void* encoder_raw, uint8_t** data, int* size,
+                                              uintptr_t* frame_nr, int* more_frame_packets)
+{
+  encoder_struct_kvazaar* encoder = (encoder_struct_kvazaar*) encoder_raw;
+
+  if (encoder->output_data.empty()) {
+    *data = nullptr;
+    *size = 0;
+
+    return heif_error_ok;
+  }
+
+  std::vector<uint8_t>& pktdata = encoder->output_data.front().data;
+#if 0
+  size_t start_idx = 0;
+
+  while (start_idx < pktdata.size() - 3 &&
+         (pktdata[start_idx] != 0 ||
+          pktdata[start_idx + 1] != 0 ||
+          pktdata[start_idx + 2] != 1)) {
+    start_idx++;
+  }
+
+  size_t end_idx = start_idx + 1;
+
+  while (end_idx < pktdata.size() - 3 &&
+         (pktdata[end_idx] != 0 ||
+          pktdata[end_idx + 1] != 0 ||
+          pktdata[end_idx + 2] != 1)) {
+    end_idx++;
+  }
+
+  if (end_idx == encoder->output_data.size() - 3) {
+    end_idx = encoder->output_data.size();
+  }
+#endif
+
+  if (frame_nr) {
+    *frame_nr = encoder->output_data.front().frameNr;
+  }
+
+  if (more_frame_packets) {
+    if (encoder->output_data.size() > 1 &&
+        encoder->output_data[0].frameNr == encoder->output_data[1].frameNr) {
+      *more_frame_packets = 1;
+    }
+    else {
+      *more_frame_packets = 0;
+    }
+  }
+
+  encoder->active_data = std::move(pktdata);
+  encoder->output_data.pop_front();
+
+  *data = encoder->active_data.data();
+  *size = static_cast<int>(encoder->active_data.size());
+
+  return heif_error_ok;
+}
+
+
+static heif_error kvazaar_get_compressed_data(void* encoder_raw, uint8_t** data, int* size,
+                                           heif_encoded_data_type* type)
+{
+  return kvazaar_get_compressed_data_intern(encoder_raw, data, size, nullptr, nullptr);
+}
+
+static heif_error kvazaar_get_compressed_data2(void* encoder_raw, uint8_t** data, int* size,
+                                            uintptr_t* frame_nr, int* is_keyframe, int* more_frame_packets)
+{
+  return kvazaar_get_compressed_data_intern(encoder_raw, data, size, frame_nr, more_frame_packets);
+}
+
+
+static heif_error kvazaar_start_sequence_encoding(void* encoder_raw, const heif_image* image,
+                                                  enum heif_image_input_class input_class,
+                                                  uint32_t framerate_num, uint32_t framerate_denom,
+                                                  const heif_sequence_encoding_options* options)
+{
+  return kvazaar_start_sequence_encoding_intern(encoder_raw, image, input_class, framerate_num, framerate_denom, options, true);
+}
+
+
+static heif_error kvazaar_encode_image(void* encoder_raw, const heif_image* image,
+                                       heif_image_input_class input_class)
+{
+  heif_error err;
+  err = kvazaar_start_sequence_encoding_intern(encoder_raw, image, input_class, 1,25, nullptr, false);
+  if (err.code) {
+    return err;
+  }
+
+  err = kvazaar_encode_sequence_frame(encoder_raw, image, 0);
+  if (err.code) {
+    return err;
+  }
+
+  return kvazaar_end_sequence_encoding(encoder_raw);
+}
+
+
+static const heif_encoder_plugin encoder_plugin_kvazaar
+    {
+        /* plugin_api_version */ 4,
+        /* compression_format */ heif_compression_HEVC,
+        /* id_name */ "kvazaar",
+        /* priority */ kvazaar_PLUGIN_PRIORITY,
+        /* supports_lossy_compression */ true,
+        /* supports_lossless_compression */ true,
+        /* get_plugin_name */ kvazaar_plugin_name,
+        /* init_plugin */ kvazaar_init_plugin,
+        /* cleanup_plugin */ kvazaar_cleanup_plugin,
+        /* new_encoder */ kvazaar_new_encoder,
+        /* free_encoder */ kvazaar_free_encoder,
+        /* set_parameter_quality */ kvazaar_set_parameter_quality,
+        /* get_parameter_quality */ kvazaar_get_parameter_quality,
+        /* set_parameter_lossless */ kvazaar_set_parameter_lossless,
+        /* get_parameter_lossless */ kvazaar_get_parameter_lossless,
+        /* set_parameter_logging_level */ kvazaar_set_parameter_logging_level,
+        /* get_parameter_logging_level */ kvazaar_get_parameter_logging_level,
+        /* list_parameters */ kvazaar_list_parameters,
+        /* set_parameter_integer */ kvazaar_set_parameter_integer,
+        /* get_parameter_integer */ kvazaar_get_parameter_integer,
+        /* set_parameter_boolean */ kvazaar_set_parameter_integer, // boolean also maps to integer function
+        /* get_parameter_boolean */ kvazaar_get_parameter_integer, // boolean also maps to integer function
+        /* set_parameter_string */ kvazaar_set_parameter_string,
+        /* get_parameter_string */ kvazaar_get_parameter_string,
+        /* query_input_colorspace */ kvazaar_query_input_colorspace,
+        /* encode_image */ kvazaar_encode_image,
+        /* get_compressed_data */ kvazaar_get_compressed_data,
+        /* query_input_colorspace (v2) */ kvazaar_query_input_colorspace2,
+        /* query_encoded_size (v3) */ kvazaar_query_encoded_size,
+        /* minimum_required_libheif_version */ LIBHEIF_MAKE_VERSION(1,21,0),
+        /* start_sequence_encoding (v4) */ kvazaar_start_sequence_encoding,
+        /* encode_sequence_frame (v4) */ kvazaar_encode_sequence_frame,
+        /* end_sequence_encoding (v4) */ kvazaar_end_sequence_encoding,
+        /* get_compressed_data2 (v4) */ kvazaar_get_compressed_data2,
+        /* does_indicate_keyframes (v4) */ 0
+    };
+
+const heif_encoder_plugin* get_encoder_plugin_kvazaar()
+{
+  return &encoder_plugin_kvazaar;
+}
+
+
+#if PLUGIN_KVAZAAR
+heif_plugin_info plugin_info {
+  1,
+  heif_plugin_type_encoder,
+  &encoder_plugin_kvazaar
+};
+#endif
diff --git a/libheif/plugins/encoder_kvazaar.h b/libheif/plugins/encoder_kvazaar.h
new file mode 100644
index 0000000000..772d4419b6
--- /dev/null
+++ b/libheif/plugins/encoder_kvazaar.h
@@ -0,0 +1,47 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_ENCODER_KVAZAAR_H
+#define LIBHEIF_ENCODER_KVAZAAR_H
+
+#include "common_utils.h"
+
+/* TODO: check whether this is also the case with kvazaar.
+ *
+ * Image sizes in HEVC: since HEVC does not allow for odd image dimensions when
+   using chroma 4:2:0, our strategy is as follows.
+
+   - Images with odd dimensions are extended with an extra row/column which
+     contains a copy of the border.
+   - The HEVC image size generated by kvazaar is rounded up to the CTU size (?)
+     and the conformance window has to be respected.
+   - We add an additional crop transform to remove the extra row/column.
+ */
+
+
+const struct heif_encoder_plugin* get_encoder_plugin_kvazaar();
+
+#if PLUGIN_KVAZAAR
+extern "C" {
+MAYBE_UNUSED LIBHEIF_API extern heif_plugin_info plugin_info;
+}
+#endif
+
+#endif
diff --git a/libheif/plugins/encoder_mask.cc b/libheif/plugins/encoder_mask.cc
new file mode 100644
index 0000000000..922cfe9d66
--- /dev/null
+++ b/libheif/plugins/encoder_mask.cc
@@ -0,0 +1,304 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "encoder_mask.h"
+#include "libheif/heif.h"
+#include "libheif/heif_plugin.h"
+#include <algorithm>
+#include <cstring>
+#include <cassert>
+#include <vector>
+#include <string>
+#include <memory>
+
+#include <mutex>
+
+
+static const char* kParam_interleave = "interleave";
+
+static const int PLUGIN_PRIORITY = 60;
+
+static const char* plugin_name = "mask";
+
+
+static void mask_set_default_parameters(void* encoder);
+
+
+static const char* mask_plugin_name()
+{
+  return plugin_name;
+}
+
+
+#define MAX_NPARAMETERS 14
+
+static heif_encoder_parameter mask_encoder_params[MAX_NPARAMETERS];
+static const heif_encoder_parameter* mask_encoder_parameter_ptrs[MAX_NPARAMETERS + 1];
+
+static void mask_init_parameters()
+{
+  heif_encoder_parameter* p = mask_encoder_params;
+  const heif_encoder_parameter** d = mask_encoder_parameter_ptrs;
+  int i = 0;
+
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = kParam_interleave;
+  p->type = heif_encoder_parameter_type_string;
+  p->string.default_value = "planar";
+  p->has_default = true;
+  d[i++] = p++;
+
+  assert(i < MAX_NPARAMETERS + 1);
+  d[i++] = nullptr;
+}
+
+
+const heif_encoder_parameter** mask_list_parameters(void* encoder)
+{
+  return mask_encoder_parameter_ptrs;
+}
+
+static void mask_init_plugin()
+{
+  mask_init_parameters();
+}
+
+
+static void mask_cleanup_plugin()
+{
+}
+
+heif_error mask_new_encoder(void** enc)
+{
+  encoder_struct_mask* encoder = new encoder_struct_mask();
+  heif_error err = heif_error_ok;
+
+  *enc = encoder;
+
+  // set default parameters
+
+  mask_set_default_parameters(encoder);
+
+  return err;
+}
+
+void mask_free_encoder(void* encoder_raw)
+{
+  encoder_struct_mask* encoder = (encoder_struct_mask*) encoder_raw;
+
+  delete encoder;
+}
+
+
+heif_error mask_set_parameter_quality(void* encoder_raw, int quality)
+{
+  //struct encoder_struct_mask* encoder = (struct encoder_struct_mask*) encoder_raw;
+
+  return heif_error_ok;
+}
+
+heif_error mask_get_parameter_quality(void* encoder_raw, int* quality)
+{
+  *quality = 100;
+
+  return heif_error_ok;
+}
+
+heif_error mask_set_parameter_lossless(void* encoder_raw, int enable)
+{
+  return heif_error_ok;
+}
+
+heif_error mask_get_parameter_lossless(void* encoder_raw, int* enable)
+{
+  *enable = true;
+
+  return heif_error_ok;
+}
+
+heif_error mask_set_parameter_logging_level(void* encoder_raw, int logging)
+{
+  return heif_error_ok;
+}
+
+heif_error mask_get_parameter_logging_level(void* encoder_raw, int* loglevel)
+{
+  *loglevel = 0;
+
+  return heif_error_ok;
+}
+
+#define set_value(paramname, paramvar) if (strcmp(name, paramname)==0) { encoder->paramvar = value; return heif_error_ok; }
+#define get_value(paramname, paramvar) if (strcmp(name, paramname)==0) { *value = encoder->paramvar; return heif_error_ok; }
+
+
+heif_error mask_set_parameter_integer(void* encoder_raw, const char* name, int value)
+{
+  //struct encoder_struct_mask* encoder = (struct encoder_struct_mask*) encoder_raw;
+
+  return heif_error_unsupported_parameter;
+}
+
+heif_error mask_get_parameter_integer(void* encoder_raw, const char* name, int* value)
+{
+  //struct encoder_struct_mask* encoder = (struct encoder_struct_mask*) encoder_raw;
+
+  return heif_error_unsupported_parameter;
+}
+
+
+heif_error mask_set_parameter_boolean(void* encoder_raw, const char* name, int value)
+{
+  //struct encoder_struct_mask* encoder = (struct encoder_struct_mask*) encoder_raw;
+
+  return heif_error_unsupported_parameter;
+}
+
+heif_error mask_get_parameter_boolean(void* encoder_raw, const char* name, int* value)
+{
+  //struct encoder_struct_mask* encoder = (struct encoder_struct_mask*) encoder_raw;
+
+  return heif_error_unsupported_parameter;
+}
+
+
+heif_error mask_set_parameter_string(void* encoder_raw, const char* name, const char* value)
+{
+  //struct encoder_struct_mask* encoder = (struct encoder_struct_mask*) encoder_raw;
+
+  return heif_error_unsupported_parameter;
+}
+
+
+heif_error mask_get_parameter_string(void* encoder_raw, const char* name,
+                                                    char* value, int value_size)
+{
+  //struct encoder_struct_mask* encoder = (struct encoder_struct_mask*) encoder_raw;
+
+  return heif_error_unsupported_parameter;
+}
+
+
+static void mask_set_default_parameters(void* encoder)
+{
+  for (const heif_encoder_parameter** p = mask_encoder_parameter_ptrs; *p; p++) {
+    const heif_encoder_parameter* param = *p;
+
+    if (param->has_default) {
+      switch (param->type) {
+        case heif_encoder_parameter_type_integer:
+          mask_set_parameter_integer(encoder, param->name, param->integer.default_value);
+          break;
+        case heif_encoder_parameter_type_boolean:
+          mask_set_parameter_boolean(encoder, param->name, param->boolean.default_value);
+          break;
+        case heif_encoder_parameter_type_string:
+          mask_set_parameter_string(encoder, param->name, param->string.default_value);
+          break;
+      }
+    }
+  }
+}
+
+
+void mask_query_input_colorspace(heif_colorspace* colorspace, heif_chroma* chroma)
+{
+}
+
+
+void mask_query_input_colorspace2(void* encoder_raw, heif_colorspace* colorspace, heif_chroma* chroma)
+{
+  //struct encoder_struct_mask* encoder = (struct encoder_struct_mask*) encoder_raw;
+
+  if (*colorspace == heif_colorspace_monochrome) {
+    // keep the monochrome colorspace
+  }
+  else {
+    //*colorspace = heif_colorspace_YCbCr;
+    //*chroma = encoder->chroma;
+  }
+}
+
+
+heif_error mask_encode_image(void* encoder_raw, const heif_image* image,
+                             heif_image_input_class input_class)
+{
+  //struct encoder_struct_mask* encoder = (struct encoder_struct_mask*) encoder_raw;
+
+  // Note: this is not used. It is a dummy plugin.
+
+  return heif_error_ok;
+}
+
+
+heif_error mask_get_compressed_data(void* encoder_raw, uint8_t** data, int* size,
+                                    heif_encoded_data_type* type)
+{
+  return heif_error_ok;
+}
+
+
+static const heif_encoder_plugin encoder_plugin_mask
+    {
+        /* plugin_api_version */ 3,
+        /* compression_format */ heif_compression_mask,
+        /* id_name */ "mask",
+        /* priority */ PLUGIN_PRIORITY,
+        /* supports_lossy_compression */ true,
+        /* supports_lossless_compression */ true,
+        /* get_plugin_name */ mask_plugin_name,
+        /* init_plugin */ mask_init_plugin,
+        /* cleanup_plugin */ mask_cleanup_plugin,
+        /* new_encoder */ mask_new_encoder,
+        /* free_encoder */ mask_free_encoder,
+        /* set_parameter_quality */ mask_set_parameter_quality,
+        /* get_parameter_quality */ mask_get_parameter_quality,
+        /* set_parameter_lossless */ mask_set_parameter_lossless,
+        /* get_parameter_lossless */ mask_get_parameter_lossless,
+        /* set_parameter_logging_level */ mask_set_parameter_logging_level,
+        /* get_parameter_logging_level */ mask_get_parameter_logging_level,
+        /* list_parameters */ mask_list_parameters,
+        /* set_parameter_integer */ mask_set_parameter_integer,
+        /* get_parameter_integer */ mask_get_parameter_integer,
+        /* set_parameter_boolean */ mask_set_parameter_boolean,
+        /* get_parameter_boolean */ mask_get_parameter_boolean,
+        /* set_parameter_string */ mask_set_parameter_string,
+        /* get_parameter_string */ mask_get_parameter_string,
+        /* query_input_colorspace */ mask_query_input_colorspace,
+        /* encode_image */ mask_encode_image,
+        /* get_compressed_data */ mask_get_compressed_data,
+        /* query_input_colorspace (v2) */ mask_query_input_colorspace2,
+        /* query_encoded_size (v3) */ nullptr
+    };
+
+const heif_encoder_plugin* get_encoder_plugin_mask()
+{
+  return &encoder_plugin_mask;
+}
+
+
+#if 0 // PLUGIN_mask_ENCODER
+heif_plugin_info plugin_info {
+  1,
+  heif_plugin_type_encoder,
+  &encoder_plugin_mask
+};
+#endif
diff --git a/libheif/plugins/encoder_mask.h b/libheif/plugins/encoder_mask.h
new file mode 100644
index 0000000000..0a55857acf
--- /dev/null
+++ b/libheif/plugins/encoder_mask.h
@@ -0,0 +1,36 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_ENCODER_MASK_H
+#define LIBHEIF_ENCODER_MASK_H
+
+#include "common_utils.h"
+
+// This is a dummy module. It does not actually do anything except parameter parsing.
+// The actual codec is included in the library.
+
+struct encoder_struct_mask
+{
+};
+
+
+const struct heif_encoder_plugin* get_encoder_plugin_mask();
+
+#endif //LIBHEIF_ENCODER_MASK_H
diff --git a/libheif/plugins/encoder_openjpeg.cc b/libheif/plugins/encoder_openjpeg.cc
new file mode 100644
index 0000000000..3bbbe0b2ef
--- /dev/null
+++ b/libheif/plugins/encoder_openjpeg.cc
@@ -0,0 +1,684 @@
+/*
+ * OpenJPEG codec.
+ * Copyright (c) 2023 Devon Sookhoo
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "libheif/heif.h"
+#include "libheif/heif_plugin.h"
+#include "encoder_openjpeg.h"
+
+#include <openjpeg.h>
+#include <string.h>
+
+#include <vector>
+#include <string>
+#include <cassert>
+
+using namespace std;
+
+
+static const int OPJ_PLUGIN_PRIORITY = 80;
+
+
+struct encoder_struct_opj
+{
+  int quality = 70;
+  heif_chroma chroma = heif_chroma_undefined;
+  opj_cparameters_t parameters;
+
+  // --- output
+
+  std::vector<uint8_t> codestream; //contains encoded pixel data
+  bool data_read = false;
+
+  // --- parameters
+
+  // std::vector<parameter> parameters;
+
+  // void add_param(const parameter&);
+
+  // void add_param(const std::string& name, int value);
+
+  // void add_param(const std::string& name, bool value);
+
+  // void add_param(const std::string& name, const std::string& value);
+
+  // parameter get_param(const std::string& name) const;
+
+  // std::string preset;
+  // std::string tune;
+
+  // int logLevel = X265_LOG_NONE;
+};
+
+static const char* kParam_chroma = "chroma";
+static const char* const kParam_chroma_valid_values[] = {
+    "420", "422", "444", nullptr
+};
+
+
+#define MAX_PLUGIN_NAME_LENGTH 80
+static char plugin_name[MAX_PLUGIN_NAME_LENGTH];
+
+const char* opj_plugin_name()
+{
+  snprintf(plugin_name, MAX_PLUGIN_NAME_LENGTH, "OpenJPEG %s", opj_version());
+  plugin_name[MAX_PLUGIN_NAME_LENGTH - 1] = 0;
+
+  return plugin_name;
+}
+
+
+#define MAX_NPARAMETERS 10
+
+static heif_encoder_parameter opj_encoder_params[MAX_NPARAMETERS];
+static const heif_encoder_parameter* opj_encoder_parameter_ptrs[MAX_NPARAMETERS + 1];
+
+static void opj_init_parameters()
+{
+  heif_encoder_parameter* p = opj_encoder_params;
+  const heif_encoder_parameter** d = opj_encoder_parameter_ptrs;
+  int i = 0;
+
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = kParam_chroma;
+  p->type = heif_encoder_parameter_type_string;
+  //p->string.default_value = "420";
+  p->has_default = false;
+  p->string.valid_values = kParam_chroma_valid_values;
+  d[i++] = p++;
+
+  d[i++] = nullptr;
+}
+
+void opj_init_plugin()
+{
+  opj_init_parameters();
+}
+
+void opj_cleanup_plugin()
+{
+}
+
+static void opj_set_default_parameters(void* encoder);
+
+heif_error opj_new_encoder(void** encoder_out)
+{
+  encoder_struct_opj* encoder = new encoder_struct_opj();
+  *encoder_out = encoder;
+
+  opj_set_default_parameters(encoder);
+  opj_set_default_encoder_parameters(&(encoder->parameters));
+
+  return heif_error_ok;
+}
+
+void opj_free_encoder(void* encoder_raw)
+{
+  encoder_struct_opj* encoder = (encoder_struct_opj*) encoder_raw;
+  delete encoder;
+}
+
+heif_error opj_set_parameter_quality(void* encoder_raw, int quality)
+{
+  auto* encoder = (encoder_struct_opj*) encoder_raw;
+
+  if (quality < 0 || quality > 100) {
+    return heif_error_invalid_parameter_value;
+  }
+
+  encoder->quality = quality;
+
+  return heif_error_ok;
+}
+
+heif_error opj_get_parameter_quality(void* encoder_raw, int* quality)
+{
+  auto* encoder = (encoder_struct_opj*) encoder_raw;
+
+  *quality = encoder->quality;
+
+  return heif_error_ok;
+}
+
+heif_error opj_set_parameter_lossless(void* encoder_raw, int lossless)
+{
+  auto* encoder = (encoder_struct_opj*) encoder_raw;
+  encoder->parameters.irreversible = lossless ? 0 : 1;
+  return heif_error_ok;
+}
+
+heif_error opj_get_parameter_lossless(void* encoder_raw, int* lossless)
+{
+  auto* encoder = (encoder_struct_opj*) encoder_raw;
+  *lossless = (encoder->parameters.irreversible == 0);
+  return heif_error_ok;
+}
+
+heif_error opj_set_parameter_logging_level(void* encoder, int logging)
+{
+  return heif_error_ok;
+}
+
+heif_error opj_get_parameter_logging_level(void* encoder, int* logging)
+{
+  return heif_error_ok;
+}
+
+const heif_encoder_parameter** opj_list_parameters(void* encoder)
+{
+  return opj_encoder_parameter_ptrs;
+}
+
+heif_error opj_set_parameter_integer(void* encoder_raw, const char* name, int value)
+{
+  encoder_struct_opj* encoder = (encoder_struct_opj*) encoder_raw;
+
+  if (strcmp(name, heif_encoder_parameter_name_quality) == 0) {
+    return opj_set_parameter_quality(encoder, value);
+  }
+
+  return heif_error_unsupported_parameter;
+}
+
+heif_error opj_get_parameter_integer(void* encoder_raw, const char* name, int* value)
+{
+  encoder_struct_opj* encoder = (encoder_struct_opj*) encoder_raw;
+
+  if (strcmp(name, heif_encoder_parameter_name_quality) == 0) {
+    return opj_get_parameter_quality(encoder, value);
+  }
+
+  return heif_error_ok;
+}
+
+heif_error opj_set_parameter_boolean(void* encoder, const char* name, int value)
+{
+  return heif_error_ok;
+}
+
+heif_error opj_get_parameter_boolean(void* encoder, const char* name, int* value)
+{
+  return heif_error_ok;
+}
+
+heif_error opj_set_parameter_string(void* encoder_raw, const char* name, const char* value)
+{
+  auto* encoder = (encoder_struct_opj*) encoder_raw;
+
+  if (strcmp(name, kParam_chroma) == 0) {
+    if (strcmp(value, "420") == 0) {
+      encoder->chroma = heif_chroma_420;
+      return heif_error_ok;
+    }
+    else if (strcmp(value, "422") == 0) {
+      encoder->chroma = heif_chroma_422;
+      return heif_error_ok;
+    }
+    else if (strcmp(value, "444") == 0) {
+      encoder->chroma = heif_chroma_444;
+      return heif_error_ok;
+    }
+    else {
+      return heif_error_invalid_parameter_value;
+    }
+  }
+
+  return heif_error_unsupported_parameter;
+}
+
+static void save_strcpy(char* dst, int dst_size, const char* src)
+{
+  strncpy(dst, src, dst_size - 1);
+  dst[dst_size - 1] = 0;
+}
+
+heif_error opj_get_parameter_string(void* encoder_raw, const char* name, char* value, int value_size)
+{
+  encoder_struct_opj* encoder = (encoder_struct_opj*) encoder_raw;
+
+  if (strcmp(name, kParam_chroma) == 0) {
+    switch (encoder->chroma) {
+      case heif_chroma_420:
+        save_strcpy(value, value_size, "420");
+        break;
+      case heif_chroma_422:
+        save_strcpy(value, value_size, "422");
+        break;
+      case heif_chroma_444:
+        save_strcpy(value, value_size, "444");
+        break;
+      case heif_chroma_undefined:
+        save_strcpy(value, value_size, "undefined");
+        break;
+      default:
+        assert(false);
+        return heif_error_invalid_parameter_value;
+      }
+      return heif_error_ok;
+  }
+
+  return heif_error_unsupported_parameter;
+}
+
+
+static void opj_set_default_parameters(void* encoder)
+{
+  for (const heif_encoder_parameter** p = opj_encoder_parameter_ptrs; *p; p++) {
+    const heif_encoder_parameter* param = *p;
+
+    if (param->has_default) {
+      switch (param->type) {
+        case heif_encoder_parameter_type_integer:
+          opj_set_parameter_integer(encoder, param->name, param->integer.default_value);
+          break;
+        case heif_encoder_parameter_type_boolean:
+          opj_set_parameter_boolean(encoder, param->name, param->boolean.default_value);
+          break;
+        case heif_encoder_parameter_type_string:
+          opj_set_parameter_string(encoder, param->name, param->string.default_value);
+          break;
+      }
+    }
+  }
+}
+
+
+void opj_query_input_colorspace(heif_colorspace* inout_colorspace, heif_chroma* inout_chroma)
+{
+  // Replace the input colorspace/chroma with the one that is supported by the encoder and that
+  // comes as close to the input colorspace/chroma as possible.
+
+  if (*inout_colorspace == heif_colorspace_monochrome) {
+    *inout_colorspace = heif_colorspace_monochrome;
+    *inout_chroma = heif_chroma_monochrome;
+  }
+  else {
+    *inout_colorspace = heif_colorspace_YCbCr;
+    *inout_chroma = heif_chroma_444;
+  }
+}
+
+void opj_query_input_colorspace2(void* encoder_raw, heif_colorspace* inout_colorspace, heif_chroma* inout_chroma)
+{
+  auto* encoder = (struct encoder_struct_opj*) encoder_raw;
+
+  if (*inout_colorspace == heif_colorspace_monochrome) {
+    *inout_colorspace = heif_colorspace_monochrome;
+    *inout_chroma = heif_chroma_monochrome;
+  }
+  else {
+    *inout_colorspace = heif_colorspace_YCbCr;
+
+    if (encoder->chroma != heif_chroma_undefined) {
+      *inout_chroma = encoder->chroma;
+    }
+    else {
+      *inout_chroma = heif_chroma_444;
+    }
+  }
+}
+
+
+// OpenJPEG will encode a portion of the image and then call this function
+// @param src_data_raw - Newly encoded bytes provided by OpenJPEG
+// @param nb_bytes - The number of bytes or size of src_data_raw
+// @param encoder_raw - Out the new
+// @return - The number of bytes successfully transferred
+static OPJ_SIZE_T opj_write_from_buffer(void* src_data_raw, OPJ_SIZE_T nb_bytes, void* encoder_raw)
+{
+  uint8_t* src_data = (uint8_t*) src_data_raw;
+  encoder_struct_opj* encoder = (encoder_struct_opj*) encoder_raw;
+
+  for (size_t i = 0; i < nb_bytes; i++) {
+    encoder->codestream.push_back(src_data[i]);
+  }
+
+  return nb_bytes;
+}
+
+static void opj_close_from_buffer(void* p_user_data)
+{
+}
+
+
+// The codestream is defined in ISO/IEC 15444-1. It contains the
+// compressed image pixel data and very basic metadata. 
+// @param data - Uncompressed image pixel data
+// @param encoder - The function will output codestream in encoder->codestream
+static heif_error generate_codestream(opj_image_t* image, encoder_struct_opj* encoder)
+{
+  heif_error error;
+  OPJ_BOOL success;
+
+  encoder->parameters.cp_disto_alloc = 1;
+  encoder->parameters.tcp_numlayers = 1;
+  encoder->parameters.tcp_rates[0] = (float)(1 + (100 - encoder->quality)/2);
+
+#if 0
+  //Insert a human readable comment into the codestream
+  if (parameters.cp_comment == NULL) {
+    char buf[80];
+#ifdef _WIN32
+    sprintf_s(buf, 80, "Created by OpenJPEG version %s", opj_version());
+#else
+    snprintf(buf, 80, "Created by OpenJPEG version %s", opj_version());
+#endif
+    parameters.cp_comment = strdup(buf);
+  }
+#endif
+
+  //OPJ_CODEC_J2K - Only generate the codestream
+  //OPJ_CODEC_JP2 - Generate the entire jp2 file (which contains a codestream)
+  OPJ_CODEC_FORMAT codec_format = OPJ_CODEC_J2K;
+  opj_codec_t* codec = opj_create_compress(codec_format);
+  success = opj_setup_encoder(codec, &(encoder->parameters), image);
+  if (!success) {
+    opj_destroy_codec(codec);
+    error = {heif_error_Encoding_error, heif_suberror_Unspecified, "Failed to setup OpenJPEG encoder"};
+    return error;
+  }
+
+
+  //Create Stream
+  size_t bufferSize = 64 * 1024; // 64k
+  opj_stream_t* stream = opj_stream_create(bufferSize, false /* read only mode */);
+  if (stream == NULL) {
+    opj_destroy_codec(codec);
+    error = {heif_error_Encoding_error, heif_suberror_Unspecified, "Failed to create opj_stream_t"};
+    return error;
+  }
+
+
+  // When OpenJPEG encodes the image, it will pass the 'encoder' into the write function
+  opj_stream_set_user_data(stream, encoder, opj_close_from_buffer);
+
+  // Tell OpenJPEG how and where to write the output data
+  opj_stream_set_write_function(stream, (opj_stream_write_fn) opj_write_from_buffer);
+
+  // TODO: should we use this function?
+  // opj_stream_set_user_data_length(stream, 0);
+
+
+
+  success = opj_start_compress(codec, image, stream);
+  if (!success) {
+    opj_stream_destroy(stream);
+    opj_destroy_codec(codec);
+    error = {heif_error_Encoding_error, heif_suberror_Unspecified, "Failed opj_start_compress()"};
+    return error;
+  }
+
+  success = opj_encode(codec, stream);
+  if (!success) {
+    opj_stream_destroy(stream);
+    opj_destroy_codec(codec);
+    error = {heif_error_Encoding_error, heif_suberror_Unspecified, "Failed opj_encode()"};
+    return error;
+  }
+
+  success = opj_end_compress(codec, stream);
+  if (!success) {
+    opj_stream_destroy(stream);
+    opj_destroy_codec(codec);
+    error = {heif_error_Encoding_error, heif_suberror_Unspecified, "Failed opj_end_compress()"};
+    return error;
+  }
+
+  opj_stream_destroy(stream);
+  opj_destroy_codec(codec);
+
+  return heif_error_ok;
+}
+
+
+heif_error opj_encode_image(void* encoder_raw, const heif_image* image, heif_image_input_class image_class)
+{
+  encoder_struct_opj* encoder = (encoder_struct_opj*) encoder_raw;
+  heif_error err;
+
+  heif_chroma chroma = heif_image_get_chroma_format(image);
+  heif_colorspace colorspace = heif_image_get_colorspace(image);
+
+  int width = heif_image_get_primary_width(image);
+  int height = heif_image_get_primary_height(image);
+
+  std::vector<heif_channel> channels;
+  OPJ_COLOR_SPACE opj_colorspace;
+
+  switch (colorspace) {
+    case heif_colorspace_YCbCr:
+      channels = {heif_channel_Y, heif_channel_Cb, heif_channel_Cr};
+      opj_colorspace = OPJ_CLRSPC_SYCC;
+      break;
+    case heif_colorspace_RGB:
+      channels = {heif_channel_R, heif_channel_G, heif_channel_B};
+      opj_colorspace = OPJ_CLRSPC_SRGB;
+      break;
+    case heif_colorspace_monochrome:
+      channels = {heif_channel_Y};
+      opj_colorspace = OPJ_CLRSPC_GRAY;
+      break;
+    default:
+      assert(false);
+      return {heif_error_Encoding_error, heif_suberror_Unspecified, "OpenJPEG encoder plugin received image with invalid colorspace."};
+  }
+
+  int band_count = (int) channels.size();
+
+  opj_image_cmptparm_t component_params[4];
+  memset(&component_params, 0, band_count * sizeof(opj_image_cmptparm_t));
+
+  for (int comp = 0; comp < band_count; comp++) {
+
+    int bpp = heif_image_get_bits_per_pixel_range(image, channels[comp]);
+
+    int sub_dx = 1, sub_dy = 1;
+    switch (chroma) {
+      case heif_chroma_420:
+        sub_dx = 2;
+        sub_dy = 2;
+        break;
+      case heif_chroma_422:
+        sub_dx = 2;
+        sub_dy = 1;
+        break;
+      default:
+        break;
+    }
+
+    component_params[comp].prec = bpp;
+    component_params[comp].sgnd = 0;
+    component_params[comp].dx = comp == 0 ? 1 : sub_dx;
+    component_params[comp].dy = comp == 0 ? 1 : sub_dy;
+    component_params[comp].w = comp == 0 ? width : (width + sub_dx / 2) / sub_dx;
+    component_params[comp].h = comp == 0 ? height : (height + sub_dy / 2) / sub_dy;
+  }
+
+  opj_image_t* opj_image = opj_image_create(band_count, &component_params[0], opj_colorspace);
+  if (image == nullptr) {
+    // Failed to create image
+    err = {heif_error_Encoding_error, heif_suberror_Unspecified, "Failed create OpenJPEG image"};
+    return err;
+  }
+
+  opj_image->x0 = 0;
+  opj_image->y0 = 0;
+  opj_image->x1 = width;
+  opj_image->y1 = height;
+
+  for (int comp = 0; comp < band_count; comp++) {
+    int stride;
+    const uint8_t* p = heif_image_get_plane_readonly(image, channels[comp], &stride);
+    int bpp = heif_image_get_bits_per_pixel(image, channels[comp]);
+
+    int cwidth = component_params[comp].w;
+    int cheight = component_params[comp].h;
+
+    // Note: obj_image data is 32bit integer
+
+    if (bpp <= 8) {
+      for (int y = 0; y < cheight; y++) {
+        for (int x = 0; x < cwidth; x++) {
+          opj_image->comps[comp].data[y * cwidth + x] = p[y * stride + x];
+        }
+      }
+    }
+    else {
+      const uint16_t* p16 = (const uint16_t*)p;
+
+      for (int y = 0; y < cheight; y++) {
+        for (int x = 0; x < cwidth; x++) {
+          opj_image->comps[comp].data[y * cwidth + x] = p16[y * stride/2 + x];
+        }
+      }
+    }
+  }
+
+  encoder->data_read = false;
+  encoder->codestream.clear(); //Fixes issue when encoding multiple images and old data persists.
+
+  //Encodes the image into a 'codestream' which is stored in the 'encoder' variable
+  err = generate_codestream(opj_image, encoder);
+
+  opj_image_destroy(opj_image);
+
+  return err;
+}
+
+heif_error opj_get_compressed_data(void* encoder_raw, uint8_t** data, int* size, enum heif_encoded_data_type* type)
+{
+  // Get a packet of decoded data. The data format depends on the codec.
+
+  encoder_struct_opj* encoder = (encoder_struct_opj*) encoder_raw;
+
+  if (encoder->data_read) {
+    *size = 0;
+    *data = nullptr;
+  }
+  else {
+    *size = (int) encoder->codestream.size();
+    *data = encoder->codestream.data();
+    encoder->data_read = true;
+  }
+
+  return heif_error_ok;
+}
+
+void opj_query_encoded_size(void* encoder, uint32_t input_width, uint32_t input_height, uint32_t* encoded_width, uint32_t* encoded_height)
+{
+  // --- version 3 ---
+
+  // The encoded image size may be different from the input frame size, e.g. because
+  // of required rounding, or a required minimum size. Use this function to return
+  // the encoded size for a given input image size.
+  // You may set this to NULL if no padding is required for any image size.
+
+  *encoded_width = input_width;
+  *encoded_height = input_height;
+}
+
+
+heif_error opj_start_sequence_encoding(void* encoder, const heif_image* image,
+                                       enum heif_image_input_class image_class,
+                                       uint32_t framerate_num, uint32_t framerate_denom,
+                                       const heif_sequence_encoding_options* options)
+{
+  return heif_error_ok;
+}
+
+heif_error opj_encode_sequence_frame(void* encoder, const heif_image* image, uintptr_t frame_nr)
+{
+  return opj_encode_image(encoder, image, heif_image_input_class_normal);
+}
+
+heif_error opj_end_sequence_encoding(void* encoder)
+{
+  return heif_error_ok;
+}
+
+heif_error opj_get_compressed_data2(void* encoder, uint8_t** data, int* size,
+                                    uintptr_t* frame_nr,
+                                    int* is_keyframe, int* more_frame_packets)
+{
+  heif_error err = opj_get_compressed_data(encoder, data, size, nullptr);
+
+  if (is_keyframe) {
+    *is_keyframe = true;
+  }
+
+  if (more_frame_packets) {
+    *more_frame_packets = true;
+  }
+
+  return err;
+}
+
+static const heif_encoder_plugin encoder_plugin_openjpeg{
+    /* plugin_api_version */ 4,
+    /* compression_format */ heif_compression_JPEG2000,
+    /* id_name */ "openjpeg",
+    /* priority */ OPJ_PLUGIN_PRIORITY,
+    /* supports_lossy_compression */ false,
+    /* supports_lossless_compression */ true,
+    /* get_plugin_name */ opj_plugin_name,
+    /* init_plugin */ opj_init_plugin,
+    /* cleanup_plugin */ opj_cleanup_plugin,
+    /* new_encoder */ opj_new_encoder,
+    /* free_encoder */ opj_free_encoder,
+    /* set_parameter_quality */ opj_set_parameter_quality,
+    /* get_parameter_quality */ opj_get_parameter_quality,
+    /* set_parameter_lossless */ opj_set_parameter_lossless,
+    /* get_parameter_lossless */ opj_get_parameter_lossless,
+    /* set_parameter_logging_level */ opj_set_parameter_logging_level,
+    /* get_parameter_logging_level */ opj_get_parameter_logging_level,
+    /* list_parameters */ opj_list_parameters,
+    /* set_parameter_integer */ opj_set_parameter_integer,
+    /* get_parameter_integer */ opj_get_parameter_integer,
+    /* set_parameter_boolean */ opj_set_parameter_boolean,
+    /* get_parameter_boolean */ opj_get_parameter_boolean,
+    /* set_parameter_string */ opj_set_parameter_string,
+    /* get_parameter_string */ opj_get_parameter_string,
+    /* query_input_colorspace */ opj_query_input_colorspace,
+    /* encode_image */ opj_encode_image,
+    /* get_compressed_data */ opj_get_compressed_data,
+    /* query_input_colorspace (v2) */ opj_query_input_colorspace2,
+    /* query_encoded_size (v3) */ opj_query_encoded_size,
+    /* minimum_required_libheif_version */ LIBHEIF_MAKE_VERSION(1,21,0),
+    /* start_sequence_encoding (v4) */ opj_start_sequence_encoding,
+    /* encode_sequence_frame (v4) */ opj_encode_sequence_frame,
+    /* end_sequence_encoding (v4) */ opj_end_sequence_encoding,
+    /* get_compressed_data2 (v4) */ opj_get_compressed_data2,
+    /* does_indicate_keyframes (v4) */ 1
+};
+
+const heif_encoder_plugin* get_encoder_plugin_openjpeg()
+{
+  return &encoder_plugin_openjpeg;
+}
+
+
+#if PLUGIN_OPENJPEG_ENCODER
+heif_plugin_info plugin_info {
+  1,
+  heif_plugin_type_encoder,
+  &encoder_plugin_openjpeg
+};
+#endif
diff --git a/libheif/plugins/encoder_openjpeg.h b/libheif/plugins/encoder_openjpeg.h
new file mode 100644
index 0000000000..1f2828ca8a
--- /dev/null
+++ b/libheif/plugins/encoder_openjpeg.h
@@ -0,0 +1,36 @@
+/*
+ * OpenJPEG codec.
+ * Copyright (c) 2023 Devon Sookhoo
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_ENCODER_OPENJPEG_H
+#define LIBHEIF_ENCODER_OPENJPEG_H
+
+#include "common_utils.h"
+
+
+const struct heif_encoder_plugin* get_encoder_plugin_openjpeg();
+
+#if PLUGIN_OPENJPEG_ENCODER
+extern "C" {
+MAYBE_UNUSED LIBHEIF_API extern heif_plugin_info plugin_info;
+}
+#endif
+
+#endif
diff --git a/libheif/plugins/encoder_openjph.cc b/libheif/plugins/encoder_openjph.cc
new file mode 100644
index 0000000000..58ac9c909f
--- /dev/null
+++ b/libheif/plugins/encoder_openjph.cc
@@ -0,0 +1,946 @@
+/*
+ * OpenJPH codec.
+ * Copyright (c) 2023 Devon Sookhoo
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ * Copyright (C) 2024 Brad Hards
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+// Portions of this code adapted from OpenJPH's ojph_compress.cpp
+// which is under the following license:
+//***************************************************************************/
+// This software is released under the 2-Clause BSD license, included
+// below.
+//
+// Copyright (c) 2019, Aous Naman 
+// Copyright (c) 2019, Kakadu Software Pty Ltd, Australia
+// Copyright (c) 2019, The University of New South Wales, Australia
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+// 
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// 
+// 2. 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
+// HOLDER 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.
+//***************************************************************************/
+
+
+#include "libheif/heif.h"
+#include "libheif/heif_plugin.h"
+#include "encoder_openjph.h"
+
+#include "openjph/ojph_mem.h"
+#include "openjph/ojph_defs.h"
+#include "openjph/ojph_file.h"
+#include "openjph/ojph_codestream.h"
+#include "openjph/ojph_params.h"
+#include "openjph/ojph_version.h"
+
+#include <string.h>
+
+#include <cassert>
+#include <limits>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include <iostream>
+
+static const int OJPH_PLUGIN_PRIORITY = 80;
+
+
+struct encoder_struct_ojph
+{
+  // We do this for API reasons. Has no effect at this stage.
+  int quality = 70;
+  heif_chroma chroma = heif_chroma_undefined;
+
+  // Context
+  ojph::codestream codestream;
+  std::string comment;
+
+  // --- output
+  bool data_read = false;
+  ojph::mem_outfile outfile;
+};
+
+
+#define MAX_NPARAMETERS 10
+static heif_encoder_parameter ojph_encoder_params[MAX_NPARAMETERS];
+const static heif_encoder_parameter* ojph_encoder_parameter_ptrs[MAX_NPARAMETERS + 1];
+
+static const char* kParam_chroma = "chroma";
+static const char* const kParam_chroma_valid_values[] = {
+    "420", "422", "444", nullptr
+};
+
+static const char* kParam_num_decompositions = "num_decompositions";
+static const int NUM_DECOMPOSITIONS_MIN = 0;
+static const int NUM_DECOMPOSITIONS_MAX = 32;
+
+static const char* kParam_progression_order = "progression_order";
+static const char* const kParam_progression_order_valid_values[] = {
+    "LRCP", "RLCP", "RPCL", "PCRL", "CPRL", nullptr
+};
+
+#if OPENJPH_MAJOR_VERSION > 1 || OPENJPH_MINOR_VERSION > 10
+static const char* kParam_tlm_marker = "tlm_marker";
+#endif
+
+static const char* kParam_codestream_comment = "codestream_comment";
+
+static const char* kParam_tile_size = "tile_size";
+
+#if OPENJPH_MAJOR_VERSION > 1 || OPENJPH_MINOR_VERSION > 11
+static const char* kParam_tilepart_division = "tilepart_division";
+static const char* const kParam_tilepart_division_valid_values[] = {
+    "none", "resolution", "component", "both", nullptr
+};
+#endif
+
+static const char* kParam_block_dimensions = "block_dimensions";
+
+static void ojph_init_encoder_parameters()
+{
+  heif_encoder_parameter* p = ojph_encoder_params;
+  const heif_encoder_parameter** d = ojph_encoder_parameter_ptrs;
+  int i = 0;
+
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = heif_encoder_parameter_name_lossless;
+  p->type = heif_encoder_parameter_type_boolean;
+  p->boolean.default_value = false;
+  p->has_default = true;
+  d[i++] = p++;
+
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = kParam_chroma;
+  p->type = heif_encoder_parameter_type_string;
+  p->string.default_value = "444";
+  p->has_default = true;
+  p->string.valid_values = kParam_chroma_valid_values;
+  d[i++] = p++;
+
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = kParam_num_decompositions;
+  p->type = heif_encoder_parameter_type_integer;
+  p->integer.default_value = 5;
+  p->integer.have_minimum_maximum = true;
+  p->integer.minimum = NUM_DECOMPOSITIONS_MIN;
+  p->integer.maximum = NUM_DECOMPOSITIONS_MAX;
+  p->integer.valid_values = NULL;
+  p->integer.num_valid_values = 0;
+  p->has_default = true;
+  d[i++] = p++;
+
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = kParam_progression_order;
+  p->type = heif_encoder_parameter_type_string;
+  p->string.default_value = "RPCL";
+  p->has_default = true;
+  p->string.valid_values = kParam_progression_order_valid_values;
+  d[i++] = p++;
+
+#if OPENJPH_MAJOR_VERSION > 1 || OPENJPH_MINOR_VERSION > 10
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = kParam_tlm_marker;
+  p->type = heif_encoder_parameter_type_boolean;
+  p->boolean.default_value = false;
+  p->has_default = true;
+  d[i++] = p++;
+#endif
+
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = kParam_codestream_comment;
+  p->type = heif_encoder_parameter_type_string;
+  p->string.default_value = nullptr;
+  p->has_default = false;
+  p->string.valid_values = nullptr;
+  d[i++] = p++;
+
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = kParam_tile_size;
+  p->type = heif_encoder_parameter_type_string;
+  p->string.default_value = "0,0";
+  p->has_default = true;
+  p->string.valid_values = nullptr;
+  d[i++] = p++;
+
+#if OPENJPH_MAJOR_VERSION > 1 || OPENJPH_MINOR_VERSION > 11
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = kParam_tilepart_division;
+  p->type = heif_encoder_parameter_type_string;
+  p->string.default_value = "none";
+  p->has_default = true;
+  p->string.valid_values = kParam_tilepart_division_valid_values;
+  d[i++] = p++;
+#endif
+
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = kParam_block_dimensions;
+  p->type = heif_encoder_parameter_type_string;
+  p->string.default_value = "64,64";
+  p->has_default = true;
+  p->string.valid_values = nullptr;
+  d[i++] = p++;
+
+  d[i++] = nullptr;
+}
+
+
+void ojph_init_plugin()
+{
+  ojph_init_encoder_parameters();
+}
+
+void ojph_cleanup_plugin()
+{
+}
+
+
+//////////// Integer parameter setters
+
+// Note quality is part of the plugin API.
+
+heif_error ojph_set_parameter_quality(void* encoder_raw, int quality)
+{
+  auto* encoder = (encoder_struct_ojph*) encoder_raw;
+
+  encoder->quality = quality;
+
+  return heif_error_ok;
+}
+
+static const heif_error &ojph_set_num_decompositions(int value, encoder_struct_ojph *encoder)
+{
+  if ((value < NUM_DECOMPOSITIONS_MIN) || (value > NUM_DECOMPOSITIONS_MAX)) {
+    return heif_error_invalid_parameter_value;
+  }
+  encoder->codestream.access_cod().set_num_decomposition(value);
+  return heif_error_ok;
+}
+
+heif_error ojph_set_parameter_integer(void *encoder_raw, const char *name, int value)
+{
+  encoder_struct_ojph* encoder = (encoder_struct_ojph*) encoder_raw;
+
+  if (strcmp(name, heif_encoder_parameter_name_quality) == 0) {
+    return  ojph_set_parameter_quality(encoder, value);
+  } else if (strcmp(name, kParam_num_decompositions) == 0) {
+    return ojph_set_num_decompositions(value, encoder);
+  } else {
+    return heif_error_unsupported_parameter;
+  }
+}
+
+
+//////////// Integer parameter getters
+
+// Note quality is part of the plugin API
+
+heif_error ojph_get_parameter_quality(void* encoder_raw, int* quality)
+{
+  auto* encoder = (encoder_struct_ojph*) encoder_raw;
+
+  *quality = encoder->quality;
+
+  return heif_error_ok;
+}
+
+const heif_error &ojph_get_parameter_num_decompositions(encoder_struct_ojph *encoder, int *value)
+{
+  *value = encoder->codestream.access_cod().get_num_decompositions();
+  return heif_error_ok;
+}
+
+heif_error ojph_get_parameter_integer(void *encoder_raw, const char *name, int *value)
+{
+  encoder_struct_ojph* encoder = (encoder_struct_ojph*) encoder_raw;
+
+  if (strcmp(name, heif_encoder_parameter_name_quality) == 0) {
+    return ojph_get_parameter_quality(encoder, value);
+  } else if (strcmp(name, kParam_num_decompositions) == 0) {
+    return ojph_get_parameter_num_decompositions(encoder, value);
+  } else {
+    return heif_error_unsupported_parameter;
+  }
+}
+
+
+//////////// Boolean parameter setters
+
+// Note lossless is part of the plugin API
+
+heif_error ojph_set_parameter_lossless(void* encoder_raw, int lossless)
+{
+  auto* encoder = (encoder_struct_ojph*) encoder_raw;
+  encoder->codestream.access_cod().set_reversible(lossless);
+  return heif_error_ok;
+}
+
+#if OPENJPH_MAJOR_VERSION > 1 || OPENJPH_MINOR_VERSION > 10
+const heif_error &ojph_set_tlm_marker_requested(encoder_struct_ojph *encoder, int value)
+{
+  encoder->codestream.request_tlm_marker(value);
+  return heif_error_ok;
+}
+#endif
+
+heif_error ojph_set_parameter_boolean(void *encoder_raw, const char *name, int value)
+{
+  auto* encoder = (encoder_struct_ojph*) encoder_raw;
+  if (strcmp(name, heif_encoder_parameter_name_lossless) == 0) {
+    return ojph_set_parameter_lossless(encoder, value);
+#if OPENJPH_MAJOR_VERSION > 1 || OPENJPH_MINOR_VERSION > 10
+  } else if (strcmp(name, kParam_tlm_marker) == 0) {
+    return ojph_set_tlm_marker_requested(encoder, value);
+#endif
+  }
+  return heif_error_unsupported_parameter;
+}
+
+//////////// Boolean parameter getters
+
+// Note lossless is part of the plugin API
+
+heif_error ojph_get_parameter_lossless(void* encoder_raw, int* lossless)
+{
+  auto* encoder = (encoder_struct_ojph*) encoder_raw;
+  *lossless = encoder->codestream.access_cod().is_reversible();
+  return heif_error_ok;
+}
+
+#if OPENJPH_MAJOR_VERSION > 1 || OPENJPH_MINOR_VERSION > 10
+const heif_error &ojph_get_parameter_tlm_marker(encoder_struct_ojph *encoder, int *value)
+{
+  *value = encoder->codestream.is_tlm_requested();
+  return heif_error_ok;
+}
+#endif
+
+heif_error ojph_get_parameter_boolean(void *encoder_raw, const char *name, int *value)
+{
+  auto* encoder = (encoder_struct_ojph*) encoder_raw;
+  if (strcmp(name, heif_encoder_parameter_name_lossless) == 0) {
+    return ojph_get_parameter_lossless(encoder, value);
+#if OPENJPH_MAJOR_VERSION > 1 || OPENJPH_MINOR_VERSION > 10
+  } else if (strcmp(name, kParam_tlm_marker) == 0) {
+    return ojph_get_parameter_tlm_marker(encoder, value);
+#endif
+  } else {
+    return heif_error_unsupported_parameter;
+  }
+}
+
+
+//////////// String parameter getters
+
+static void safe_strcpy(char* dst, int dst_size, const char* src)
+{
+  strncpy(dst, src, dst_size - 1);
+  dst[dst_size - 1] = 0;
+}
+
+const heif_error &ojph_get_parameter_chroma(encoder_struct_ojph *encoder, char *value, int value_size)
+{
+  switch (encoder->chroma) {
+    case heif_chroma_420:
+      safe_strcpy(value, value_size, "420");
+      break;
+    case heif_chroma_422:
+      safe_strcpy(value, value_size, "422");
+      break;
+    case heif_chroma_444:
+      safe_strcpy(value, value_size, "444");
+      break;
+    case heif_chroma_undefined:
+      safe_strcpy(value, value_size, "undefined");
+      break;
+    default:
+      assert(false);
+      return heif_error_invalid_parameter_value;
+  }
+  return heif_error_ok;
+}
+
+const heif_error &ojph_get_parameter_progression_order(encoder_struct_ojph *encoder, char *value, int value_size)
+{
+  safe_strcpy(value, value_size, encoder->codestream.access_cod().get_progression_order_as_string());
+  return heif_error_ok;
+}
+
+const heif_error &ojph_get_parameter_codestream_comment(encoder_struct_ojph *encoder, char *value, int value_size)
+{
+  safe_strcpy(value, value_size, encoder->comment.c_str());
+  return heif_error_ok;
+}
+
+const heif_error &ojph_get_parameter_tile_size(encoder_struct_ojph *encoder, char *value, int value_size)
+{
+  ojph::size tile_size = encoder->codestream.access_siz().get_tile_size();
+  std::stringstream stringStream;
+  stringStream << tile_size.w << "," << tile_size.h;
+  safe_strcpy(value, value_size, stringStream.str().c_str());
+  return heif_error_ok;
+}
+
+#if OPENJPH_MAJOR_VERSION > 1 || OPENJPH_MINOR_VERSION > 11
+const heif_error &ojph_get_parameter_tilepart_division(encoder_struct_ojph *encoder, char *value, int value_size)
+{
+  bool res = encoder->codestream.is_tilepart_division_at_resolutions();
+  bool comp = encoder->codestream.is_tilepart_division_at_components();
+  if (res && comp) {
+    safe_strcpy(value, value_size, "both");
+  } else if (res) {
+    safe_strcpy(value, value_size, "resolution");
+  } else if (comp) {
+    safe_strcpy(value, value_size, "component");
+  } else {
+    safe_strcpy(value, value_size, "none");
+  }
+  return heif_error_ok;
+}
+#endif
+
+const heif_error &ojph_get_parameter_block_dimensions(encoder_struct_ojph *encoder, char *value, int value_size)
+{
+  ojph::size block_dims = encoder->codestream.access_cod().get_block_dims();
+  std::stringstream stringStream;
+  stringStream << block_dims.w << "," << block_dims.h;
+  safe_strcpy(value, value_size, stringStream.str().c_str());
+  return heif_error_ok;
+}
+
+heif_error ojph_get_parameter_string(void *encoder_raw, const char *name, char *value, int value_size)
+{
+  encoder_struct_ojph* encoder = (encoder_struct_ojph*) encoder_raw;
+
+  if (strcmp(name, kParam_chroma) == 0) {
+    return ojph_get_parameter_chroma(encoder, value, value_size);
+  } else if (strcmp(name, kParam_progression_order) == 0) {
+    return ojph_get_parameter_progression_order(encoder, value, value_size);
+  } else if (strcmp(name, kParam_codestream_comment) == 0) {
+    return ojph_get_parameter_codestream_comment(encoder, value, value_size);
+  } else if (strcmp(name, kParam_tile_size) == 0) {
+    return ojph_get_parameter_tile_size(encoder, value, value_size);
+#if OPENJPH_MAJOR_VERSION > 1 || OPENJPH_MINOR_VERSION > 11
+  } else if (strcmp(name, kParam_tilepart_division) == 0) {
+    return ojph_get_parameter_tilepart_division(encoder, value, value_size);
+#endif
+  } else if (strcmp(name, kParam_block_dimensions) == 0) {
+    return ojph_get_parameter_block_dimensions(encoder, value, value_size);
+  } else {
+    return heif_error_unsupported_parameter;
+  }
+}
+
+//////////// String parameter setters
+
+static const heif_error &ojph_set_chroma(encoder_struct_ojph *encoder, const char *value)
+{
+  if (strcmp(value, "420") == 0) {
+    encoder->chroma = heif_chroma_420;
+    return heif_error_ok;
+  } else if (strcmp(value, "422") == 0) {
+    encoder->chroma = heif_chroma_422;
+    return heif_error_ok;
+  } else if (strcmp(value, "444") == 0) {
+    encoder->chroma = heif_chroma_444;
+    return heif_error_ok;
+  } else {
+    return heif_error_invalid_parameter_value;
+  }
+}
+
+static bool string_list_contains(const char* const* values_list, const char* value)
+{
+  for (int i = 0; values_list[i]; i++) {
+    if (strcmp(values_list[i], value) == 0) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+static const heif_error &ojph_set_progression_order(encoder_struct_ojph *encoder, const char *value)
+{
+  if (string_list_contains(kParam_progression_order_valid_values, value)) {
+    encoder->codestream.access_cod().set_progression_order(value);
+    return heif_error_ok;
+  } else {
+    return heif_error_invalid_parameter_value;
+  }
+}
+
+static const heif_error &ojph_set_codestream_comment(encoder_struct_ojph *encoder, const char *value)
+{
+  if (value != nullptr) {
+    encoder->comment = std::string(value);
+  }
+  return heif_error_ok;
+}
+
+static const heif_error &ojph_set_tile_size(encoder_struct_ojph *encoder, const char *value)
+{
+  std::string valueStr(value);
+  size_t commaOffset = valueStr.find(",");
+  if (commaOffset == std::string::npos) {
+    return heif_error_invalid_parameter_value;
+  }
+  std::string xTSizText = valueStr.substr(0, commaOffset);
+  unsigned long xTSiz = std::stoul(xTSizText);
+  std::string yTSizText = valueStr.substr(commaOffset + 1);
+  unsigned long yTSiz = std::stoul(yTSizText);
+  if ((xTSiz < 1)
+    || (xTSiz > std::numeric_limits<unsigned int>::max())
+    || (yTSiz < 1)
+    || (yTSiz > std::numeric_limits<unsigned int>::max())) {
+    return heif_error_invalid_parameter_value;
+  }
+  encoder->codestream.access_siz().set_tile_size(ojph::size((ojph::ui32)xTSiz, (ojph::ui32)yTSiz));
+  return heif_error_ok;
+}
+
+#if OPENJPH_MAJOR_VERSION > 1 || OPENJPH_MINOR_VERSION > 11
+static const heif_error &ojph_set_tilepart_division(encoder_struct_ojph *encoder, const char *value)
+{
+  if (strcmp(value, "none") == 0) {
+    encoder->codestream.set_tilepart_divisions(false, false);
+    return heif_error_ok;
+  } else if (strcmp(value, "resolution") == 0) {
+    encoder->codestream.set_tilepart_divisions(true, false);
+    return heif_error_ok;
+  } else if (strcmp(value, "component") == 0) {
+    encoder->codestream.set_tilepart_divisions(false, true);
+    return heif_error_ok;
+  } else if (strcmp(value, "both") == 0) {
+    encoder->codestream.set_tilepart_divisions(true, true);
+    return heif_error_ok;
+  } else {
+    return heif_error_invalid_parameter_value;
+  }
+}
+#endif
+
+// Get the base 2 logarithm for code block sizes. See ITU-T T.800 (11/2015) Table A.18
+// Values are encoded 0 to 8 (i.e. its -2)
+static const int log_base_2(unsigned long v)
+{
+  switch (v) {
+    case 4:
+      return 2 - 2;
+    case 8:
+      return 3 - 2;
+    case 16:
+      return 4 - 2;
+    case 32:
+      return 5 - 2;
+    case 64:
+      return 6 - 2;
+    case 128:
+      return 7 - 2;
+    case 256:
+      return 8 - 2;
+    case 512:
+      return 9 - 2;
+    case 1024:
+      return 10 - 2;
+    default:
+      // any other value is invalid
+      return -1;
+  }
+}
+
+static const heif_error &ojph_set_block_dimensions(encoder_struct_ojph *encoder, const char *value)
+{
+  std::string valueStr(value);
+  size_t commaOffset = valueStr.find(",");
+  if (commaOffset == std::string::npos) {
+    return heif_error_invalid_parameter_value;
+  }
+  std::string widthText = valueStr.substr(0, commaOffset);
+  unsigned long width = std::stoul(widthText);
+  std::string heightText = valueStr.substr(commaOffset + 1);
+  unsigned long height = std::stoul(heightText);
+  int xcb = log_base_2(width);
+  int ycb = log_base_2(height);
+  if ((xcb == -1) || (ycb == -1) || (xcb + ycb > 12)) {
+    return heif_error_invalid_parameter_value;
+  }
+  encoder->codestream.access_cod().set_block_dims((ojph::ui32)width, (ojph::ui32)height);
+  return heif_error_ok;
+}
+
+heif_error ojph_set_parameter_string(void *encoder_raw, const char *name, const char *value)
+{
+  auto* encoder = (encoder_struct_ojph*) encoder_raw;
+
+  if (strcmp(name, kParam_chroma) == 0) {
+    return ojph_set_chroma(encoder, value);
+  } else if (strcmp(name, kParam_progression_order) == 0) {
+    return ojph_set_progression_order(encoder, value);
+  } else if (strcmp(name, kParam_codestream_comment) == 0) {
+    return ojph_set_codestream_comment(encoder, value);
+  } else if (strcmp(name, kParam_tile_size) == 0) {
+    return ojph_set_tile_size(encoder, value);
+#if OPENJPH_MAJOR_VERSION > 1 || OPENJPH_MINOR_VERSION > 11
+  } else if (strcmp(name, kParam_tilepart_division) == 0) {
+    return ojph_set_tilepart_division(encoder, value);
+#endif
+  } else if (strcmp(name, kParam_block_dimensions) == 0) {
+    return ojph_set_block_dimensions(encoder, value);
+  } else {
+    return heif_error_unsupported_parameter;
+  }
+}
+
+static void ojph_set_default_parameters(void* encoder_raw)
+{
+  encoder_struct_ojph* encoder = (encoder_struct_ojph*) encoder_raw;
+  for (const heif_encoder_parameter** p = ojph_encoder_parameter_ptrs; *p; p++) {
+    const heif_encoder_parameter* param = *p;
+
+    if (param->has_default) {
+      switch (param->type) {
+        case heif_encoder_parameter_type_integer:
+          ojph_set_parameter_integer(encoder, param->name, param->integer.default_value);
+          break;
+        case heif_encoder_parameter_type_boolean:
+          ojph_set_parameter_boolean(encoder, param->name, param->boolean.default_value);
+          break;
+        case heif_encoder_parameter_type_string:
+          ojph_set_parameter_string(encoder, param->name, param->string.default_value);
+          break;
+      }
+    }
+  }
+}
+
+///// Actual encoding functionality
+
+heif_error ojph_new_encoder(void** encoder_out)
+{
+  encoder_struct_ojph* encoder = new encoder_struct_ojph();
+  encoder->outfile.open();
+  *encoder_out = encoder;
+
+  ojph_set_default_parameters(encoder);
+
+  return heif_error_ok;
+}
+
+void ojph_free_encoder(void* encoder_raw)
+{
+  encoder_struct_ojph* encoder = (encoder_struct_ojph*) encoder_raw;
+  encoder->codestream.close();
+  delete encoder;
+}
+
+heif_error ojph_set_parameter_logging_level(void* encoder, int logging)
+{
+  // No logging level options in OpenJPH
+  return heif_error_ok;
+}
+
+heif_error ojph_get_parameter_logging_level(void* encoder, int* logging)
+{
+  // No logging level options in OpenJPH
+  return heif_error_ok;
+}
+
+const heif_encoder_parameter** ojph_list_parameters(void* encoder_raw)
+{
+  return ojph_encoder_parameter_ptrs;
+}
+
+
+void ojph_query_input_colorspace(heif_colorspace* inout_colorspace, heif_chroma* inout_chroma)
+{
+  // Replace the input colorspace/chroma with the one that is supported by the encoder and that
+  // comes as close to the input colorspace/chroma as possible.
+
+  if (*inout_colorspace == heif_colorspace_monochrome) {
+    *inout_colorspace = heif_colorspace_monochrome;
+    *inout_chroma = heif_chroma_monochrome;
+  }
+  else {
+    *inout_colorspace = heif_colorspace_YCbCr;
+    *inout_chroma = heif_chroma_444;
+  }
+}
+
+void ojph_query_input_colorspace2(void* encoder_raw, heif_colorspace* inout_colorspace, heif_chroma* inout_chroma)
+{
+  auto* encoder = (encoder_struct_ojph*) encoder_raw;
+
+  if (*inout_colorspace == heif_colorspace_monochrome) {
+    *inout_colorspace = heif_colorspace_monochrome;
+    *inout_chroma = heif_chroma_monochrome;
+  }
+  else {
+    *inout_colorspace = heif_colorspace_YCbCr;
+
+    if (encoder->chroma != heif_chroma_undefined) {
+      *inout_chroma = encoder->chroma;
+    }
+    else {
+      *inout_chroma = heif_chroma_444;
+    }
+  }
+}
+
+std::vector<heif_channel> build_SIZ(encoder_struct_ojph *encoder, const heif_image *image)
+{
+  std::vector<heif_channel> sourceChannels;
+  ojph::param_siz siz = encoder->codestream.access_siz();
+  int width = heif_image_get_primary_width(image);
+  int height = heif_image_get_primary_height(image);
+  siz.set_image_extent(ojph::point(width, height));
+
+  heif_chroma chroma = heif_image_get_chroma_format(image);
+
+  encoder->codestream.set_planar(true);
+
+  if (chroma == heif_chroma_monochrome) {
+    sourceChannels = {heif_channel_Y};
+  } else {
+    sourceChannels = {heif_channel_Y, heif_channel_Cb, heif_channel_Cr};
+  }
+
+  siz.set_num_components((ojph::ui32)sourceChannels.size());
+  for (ojph::ui32 i = 0; i < siz.get_num_components(); i++) {
+    int bit_depth = heif_image_get_bits_per_pixel_range(image, sourceChannels[i]);
+    if (sourceChannels[i] == heif_channel_Y) {
+      siz.set_component(i, ojph::point(1, 1), bit_depth, false);
+    } else { // Cb or Cr
+      if (chroma == heif_chroma_444) {
+        siz.set_component(i, ojph::point(1, 1), bit_depth, false);
+      } else if (chroma == heif_chroma_422) {
+        siz.set_component(i, ojph::point(2, 1), bit_depth, false);
+      } else {
+        siz.set_component(i, ojph::point(2, 2), bit_depth, false);
+      }
+    }
+  }
+  siz.set_image_offset(ojph::point(0, 0));
+  siz.set_tile_offset(ojph::point(0, 0));
+  return sourceChannels;
+}
+
+void build_COD(encoder_struct_ojph *encoder)
+{
+  ojph::param_cod cod = encoder->codestream.access_cod();
+  cod.set_color_transform(false);
+}
+
+heif_error ojph_encode_image(void *encoder_raw, const heif_image *image, heif_image_input_class image_class)
+{
+  encoder_struct_ojph* encoder = (encoder_struct_ojph*) encoder_raw;
+
+  if (heif_image_get_colorspace(image) != heif_colorspace_YCbCr &&
+      heif_image_get_colorspace(image) != heif_colorspace_monochrome) {
+    return {
+      heif_error_Encoding_error,
+      heif_suberror_Unspecified,
+      "OpenJPH encoder plugin received image with invalid colorspace."
+    };
+  }
+
+  // reset output position to start
+  encoder->outfile.seek(0, ojph::outfile_base::seek::OJPH_SEEK_SET);
+  encoder->data_read = false;
+
+  std::vector<heif_channel> sourceChannels = build_SIZ(encoder, image);
+  build_COD(encoder);
+#if OPENJPH_MAJOR_VERSION > 1 || OPENJPH_MINOR_VERSION > 10
+  bool hasComment = (encoder->comment.length() > 0);
+  ojph::comment_exchange com_ex;
+  if (hasComment) {
+    com_ex.set_string(encoder->comment.c_str());
+  }
+  encoder->codestream.write_headers(&(encoder->outfile), &com_ex, hasComment ? 1 : 0);
+#else
+  encoder->codestream.write_headers(&(encoder->outfile));
+#endif
+  ojph::ui32 next_comp;
+  ojph::line_buf* cur_line = encoder->codestream.exchange(NULL, next_comp);
+
+  for (const auto& sourceChannel : sourceChannels) {
+    size_t stride;
+    const uint8_t *data = heif_image_get_plane_readonly2(image, sourceChannel, &stride);
+    uint32_t component_height = heif_image_get_height(image, sourceChannel);
+    for (uint32_t y = 0; y < component_height; y++) {
+      const uint8_t *sourceLine = data + y * stride;
+      size_t outputWidth = cur_line->size;
+      ojph::si32 *targetLine = cur_line->i32;
+      for (uint32_t x = 0; x < outputWidth; x++) {
+        targetLine[x] = sourceLine[x];
+      }
+      cur_line = encoder->codestream.exchange(cur_line, next_comp);
+    }
+  }
+  encoder->codestream.flush();
+
+  return heif_error_ok;
+}
+
+heif_error ojph_get_compressed_data(void* encoder_raw, uint8_t** data, int* size, heif_encoded_data_type* type)
+{
+  encoder_struct_ojph* encoder = (encoder_struct_ojph*) encoder_raw;
+
+  if (encoder->data_read) {
+    *size = 0;
+    *data = nullptr;
+  }
+  else {
+    *size = (int) encoder->outfile.tell();
+    *data = (uint8_t*) encoder->outfile.get_data();
+    encoder->data_read = true;
+  }
+  return heif_error_ok;
+}
+
+
+static const int MAX_PLUGIN_NAME_LENGTH = 80;
+static char plugin_name[MAX_PLUGIN_NAME_LENGTH];
+
+const char* ojph_plugin_name()
+{
+  snprintf(plugin_name, MAX_PLUGIN_NAME_LENGTH,
+      "OpenJPH %s.%s.%s",
+      OJPH_INT_TO_STRING(OPENJPH_VERSION_MAJOR),
+      OJPH_INT_TO_STRING(OPENJPH_VERSION_MINOR),
+      OJPH_INT_TO_STRING(OPENJPH_VERSION_PATCH)
+  );
+  plugin_name[MAX_PLUGIN_NAME_LENGTH - 1] = 0;
+
+  return plugin_name;
+}
+
+
+heif_error ojph_start_sequence_encoding(void* encoder, const heif_image* image,
+                                       enum heif_image_input_class image_class,
+                                       uint32_t framerate_num, uint32_t framerate_denom,
+                                       const heif_sequence_encoding_options* options)
+{
+  return heif_error_ok;
+}
+
+heif_error ojph_encode_sequence_frame(void* encoder, const heif_image* image, uintptr_t frame_nr)
+{
+  return ojph_encode_image(encoder, image, heif_image_input_class_normal);
+}
+
+heif_error ojph_end_sequence_encoding(void* encoder)
+{
+  return heif_error_ok;
+}
+
+heif_error ojph_get_compressed_data2(void* encoder, uint8_t** data, int* size,
+                                    uintptr_t* frame_nr,
+                                    int* is_keyframe, int* more_frame_packets)
+{
+  heif_error err = ojph_get_compressed_data(encoder, data, size, nullptr);
+
+  if (is_keyframe) {
+    *is_keyframe = true;
+  }
+
+  if (more_frame_packets) {
+    *more_frame_packets = true;
+  }
+
+  return err;
+}
+
+static const heif_encoder_plugin encoder_plugin_openjph {
+    /* plugin_api_version */ 4,
+    /* compression_format */ heif_compression_HTJ2K,
+    /* id_name */ "openjph",
+    /* priority */ OJPH_PLUGIN_PRIORITY,
+    /* supports_lossy_compression */ true,
+    /* supports_lossless_compression */ true,
+    /* get_plugin_name */ ojph_plugin_name,
+    /* init_plugin */ ojph_init_plugin,
+    /* cleanup_plugin */ ojph_cleanup_plugin,
+    /* new_encoder */ ojph_new_encoder,
+    /* free_encoder */ ojph_free_encoder,
+    /* set_parameter_quality */ ojph_set_parameter_quality,
+    /* get_parameter_quality */ ojph_get_parameter_quality,
+    /* set_parameter_lossless */ ojph_set_parameter_lossless,
+    /* get_parameter_lossless */ ojph_get_parameter_lossless,
+    /* set_parameter_logging_level */ ojph_set_parameter_logging_level,
+    /* get_parameter_logging_level */ ojph_get_parameter_logging_level,
+    /* list_parameters */ ojph_list_parameters,
+    /* set_parameter_integer */ ojph_set_parameter_integer,
+    /* get_parameter_integer */ ojph_get_parameter_integer,
+    /* set_parameter_boolean */ ojph_set_parameter_boolean,
+    /* get_parameter_boolean */ ojph_get_parameter_boolean,
+    /* set_parameter_string */ ojph_set_parameter_string,
+    /* get_parameter_string */ ojph_get_parameter_string,
+    /* query_input_colorspace */ ojph_query_input_colorspace,
+    /* encode_image */ ojph_encode_image,
+    /* get_compressed_data */ ojph_get_compressed_data,
+    /* query_input_colorspace (v2) */ ojph_query_input_colorspace2,
+    /* query_encoded_size (v3) */ nullptr,
+    /* minimum_required_libheif_version */ LIBHEIF_MAKE_VERSION(1,21,0),
+    /* start_sequence_encoding (v4) */ ojph_start_sequence_encoding,
+    /* encode_sequence_frame (v4) */ ojph_encode_sequence_frame,
+    /* end_sequence_encoding (v4) */ ojph_end_sequence_encoding,
+    /* get_compressed_data2 (v4) */ ojph_get_compressed_data2,
+    /* does_indicate_keyframes (v4) */ 1
+};
+
+const heif_encoder_plugin* get_encoder_plugin_openjph()
+{
+  return &encoder_plugin_openjph;
+}
+
+
+#if PLUGIN_OPENJPH_ENCODER
+heif_plugin_info plugin_info {
+  1,
+  heif_plugin_type_encoder,
+  &encoder_plugin_openjph
+};
+#endif
diff --git a/libheif/plugins/encoder_openjph.h b/libheif/plugins/encoder_openjph.h
new file mode 100644
index 0000000000..25e77e5719
--- /dev/null
+++ b/libheif/plugins/encoder_openjph.h
@@ -0,0 +1,37 @@
+/*
+ * OpenJPH codec.
+ * Copyright (c) 2023 Devon Sookhoo
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ * Copyright (C) 2024 Brad Hards
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_ENCODER_OPENJPH_H
+#define LIBHEIF_ENCODER_OPENJPH_H
+
+#include "common_utils.h"
+
+
+const struct heif_encoder_plugin* get_encoder_plugin_openjph();
+
+#if PLUGIN_OPENJPH_ENCODER
+extern "C" {
+MAYBE_UNUSED LIBHEIF_API extern heif_plugin_info plugin_info;
+}
+#endif
+
+#endif
diff --git a/libheif/heif_encoder_rav1e.cc b/libheif/plugins/encoder_rav1e.cc
similarity index 56%
rename from libheif/heif_encoder_rav1e.cc
rename to libheif/plugins/encoder_rav1e.cc
index ed7befd3f8..641618b75b 100644
--- a/libheif/heif_encoder_rav1e.cc
+++ b/libheif/plugins/encoder_rav1e.cc
@@ -1,6 +1,6 @@
 /*
  * HEIF codec.
- * Copyright (c) 2017 struktur AG, Dirk Farin <farin@struktur.de>
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
  *
  * This file is part of libheif.
  *
@@ -18,29 +18,32 @@
  * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "heif.h"
-#include "heif_plugin.h"
-#include "heif_avif.h"
-#include "heif_api_structs.h"
-
-#if defined(HAVE_CONFIG_H)
-#include "config.h"
-#endif
-
+#include "libheif/heif.h"
+#include "libheif/heif_plugin.h"
+#include "encoder_rav1e.h"
 #include <vector>
 #include <memory>
 #include <cstring>
 #include <cassert>
 #include <string>
 #include <algorithm>
+#include <deque>
 
 #include <iostream>  // TODO: remove me
 
 #include "rav1e.h"
+#include <utility>
 
 
 struct encoder_struct_rav1e
 {
+  ~encoder_struct_rav1e()
+  {
+    if (rav1eContextRaw) {
+      rav1e_context_unref(rav1eContextRaw);
+    }
+  }
+
   int speed; // 0-10
 
   int quality; // TODO: not sure yet how to map quality to min/max q
@@ -52,13 +55,28 @@ struct encoder_struct_rav1e
 
   heif_chroma chroma;
 
+  // --- encoder
+
+  RaContext* rav1eContextRaw = nullptr;
+  uint8_t yShift = 0;
+
   // --- output
 
-  std::vector<uint8_t> compressed_data;
-  bool data_read = false;
+  struct Packet
+  {
+    std::vector<uint8_t> compressedData;
+    uintptr_t frameNr = 0;
+    bool is_keyframe = false;
+  };
+
+  std::deque<Packet> output_packets;
+  std::vector<uint8_t> active_output_data;
 };
 
-static const char* kError_out_of_memory = "Out of memory";
+//static const char* kError_out_of_memory = "Out of memory";
+
+static heif_error get_encoder_packets(void* encoder_raw);
+
 
 static const char* kParam_min_q = "min-q";
 static const char* kParam_threads = "threads";
@@ -71,11 +89,13 @@ static const char* const kParam_chroma_valid_values[] = {
 
 static int valid_tile_num_values[] = {1, 2, 4, 8, 16, 32, 64};
 
-static struct heif_error heif_error_codec_library_error = {heif_error_Encoder_plugin_error,
-                                                           heif_suberror_Unspecified,
-                                                           "rav1e error"};
+static heif_error heif_error_codec_library_error = {
+  heif_error_Encoder_plugin_error,
+  heif_suberror_Unspecified,
+  "rav1e error"
+};
 
-static const int RAV1E_PLUGIN_PRIORITY = 50;
+static const int RAV1E_PLUGIN_PRIORITY = 20;
 
 #define MAX_PLUGIN_NAME_LENGTH 80
 
@@ -87,7 +107,7 @@ static void rav1e_set_default_parameters(void* encoder);
 
 static const char* rav1e_plugin_name()
 {
-  strcpy(plugin_name, "Rav1e encoder");
+  snprintf(plugin_name, MAX_PLUGIN_NAME_LENGTH, "Rav1e encoder v%s", rav1e_version_short());
 
   return plugin_name;
 }
@@ -95,13 +115,13 @@ static const char* rav1e_plugin_name()
 
 #define MAX_NPARAMETERS 10
 
-static struct heif_encoder_parameter rav1e_encoder_params[MAX_NPARAMETERS];
-static const struct heif_encoder_parameter* rav1e_encoder_parameter_ptrs[MAX_NPARAMETERS + 1];
+static heif_encoder_parameter rav1e_encoder_params[MAX_NPARAMETERS];
+static const heif_encoder_parameter* rav1e_encoder_parameter_ptrs[MAX_NPARAMETERS + 1];
 
 static void rav1e_init_parameters()
 {
-  struct heif_encoder_parameter* p = rav1e_encoder_params;
-  const struct heif_encoder_parameter** d = rav1e_encoder_parameter_ptrs;
+  heif_encoder_parameter* p = rav1e_encoder_params;
+  const heif_encoder_parameter** d = rav1e_encoder_parameter_ptrs;
   int i = 0;
 
   assert(i < MAX_NPARAMETERS);
@@ -204,7 +224,7 @@ static void rav1e_init_parameters()
 }
 
 
-const struct heif_encoder_parameter** rav1e_list_parameters(void* encoder)
+const heif_encoder_parameter** rav1e_list_parameters(void* encoder)
 {
   return rav1e_encoder_parameter_ptrs;
 }
@@ -219,10 +239,10 @@ static void rav1e_cleanup_plugin()
 {
 }
 
-struct heif_error rav1e_new_encoder(void** enc)
+heif_error rav1e_new_encoder(void** enc)
 {
   auto* encoder = new encoder_struct_rav1e();
-  struct heif_error err = heif_error_ok;
+  heif_error err = heif_error_ok;
 
   *enc = encoder;
 
@@ -235,15 +255,15 @@ struct heif_error rav1e_new_encoder(void** enc)
 
 void rav1e_free_encoder(void* encoder_raw)
 {
-  auto* encoder = (struct encoder_struct_rav1e*) encoder_raw;
+  auto* encoder = (encoder_struct_rav1e*) encoder_raw;
 
   delete encoder;
 }
 
 
-struct heif_error rav1e_set_parameter_quality(void* encoder_raw, int quality)
+heif_error rav1e_set_parameter_quality(void* encoder_raw, int quality)
 {
-  auto* encoder = (struct encoder_struct_rav1e*) encoder_raw;
+  auto* encoder = (encoder_struct_rav1e*) encoder_raw;
 
   if (quality < 0 || quality > 100) {
     return heif_error_invalid_parameter_value;
@@ -254,18 +274,18 @@ struct heif_error rav1e_set_parameter_quality(void* encoder_raw, int quality)
   return heif_error_ok;
 }
 
-struct heif_error rav1e_get_parameter_quality(void* encoder_raw, int* quality)
+heif_error rav1e_get_parameter_quality(void* encoder_raw, int* quality)
 {
-  auto* encoder = (struct encoder_struct_rav1e*) encoder_raw;
+  auto* encoder = (encoder_struct_rav1e*) encoder_raw;
 
   *quality = encoder->quality;
 
   return heif_error_ok;
 }
 
-struct heif_error rav1e_set_parameter_lossless(void* encoder_raw, int enable)
+heif_error rav1e_set_parameter_lossless(void* encoder_raw, int enable)
 {
-  struct encoder_struct_rav1e* encoder = (struct encoder_struct_rav1e*) encoder_raw;
+  encoder_struct_rav1e* encoder = (encoder_struct_rav1e*) encoder_raw;
 
   if (enable) {
     encoder->min_q = 0;
@@ -274,16 +294,16 @@ struct heif_error rav1e_set_parameter_lossless(void* encoder_raw, int enable)
   return heif_error_ok;
 }
 
-struct heif_error rav1e_get_parameter_lossless(void* encoder_raw, int* enable)
+heif_error rav1e_get_parameter_lossless(void* encoder_raw, int* enable)
 {
-  struct encoder_struct_rav1e* encoder = (struct encoder_struct_rav1e*) encoder_raw;
+  encoder_struct_rav1e* encoder = (encoder_struct_rav1e*) encoder_raw;
 
   *enable = (encoder->min_q == 0);
 
   return heif_error_ok;
 }
 
-struct heif_error rav1e_set_parameter_logging_level(void* encoder_raw, int logging)
+heif_error rav1e_set_parameter_logging_level(void* encoder_raw, int logging)
 {
 #if 0
   struct encoder_struct_x265* encoder = (struct encoder_struct_x265*)encoder_raw;
@@ -298,7 +318,7 @@ struct heif_error rav1e_set_parameter_logging_level(void* encoder_raw, int loggi
   return heif_error_ok;
 }
 
-struct heif_error rav1e_get_parameter_logging_level(void* encoder_raw, int* loglevel)
+heif_error rav1e_get_parameter_logging_level(void* encoder_raw, int* loglevel)
 {
 #if 0
   struct encoder_struct_x265* encoder = (struct encoder_struct_x265*)encoder_raw;
@@ -315,9 +335,9 @@ struct heif_error rav1e_get_parameter_logging_level(void* encoder_raw, int* logl
 #define get_value(paramname, paramvar) if (strcmp(name, paramname)==0) { *value = encoder->paramvar; return heif_error_ok; }
 
 
-struct heif_error rav1e_set_parameter_integer(void* encoder_raw, const char* name, int value)
+heif_error rav1e_set_parameter_integer(void* encoder_raw, const char* name, int value)
 {
-  struct encoder_struct_rav1e* encoder = (struct encoder_struct_rav1e*) encoder_raw;
+  encoder_struct_rav1e* encoder = (encoder_struct_rav1e*) encoder_raw;
 
   if (strcmp(name, heif_encoder_parameter_name_quality) == 0) {
     return rav1e_set_parameter_quality(encoder, value);
@@ -335,9 +355,9 @@ struct heif_error rav1e_set_parameter_integer(void* encoder_raw, const char* nam
   return heif_error_unsupported_parameter;
 }
 
-struct heif_error rav1e_get_parameter_integer(void* encoder_raw, const char* name, int* value)
+heif_error rav1e_get_parameter_integer(void* encoder_raw, const char* name, int* value)
 {
-  struct encoder_struct_rav1e* encoder = (struct encoder_struct_rav1e*) encoder_raw;
+  encoder_struct_rav1e* encoder = (encoder_struct_rav1e*) encoder_raw;
 
   if (strcmp(name, heif_encoder_parameter_name_quality) == 0) {
     return rav1e_get_parameter_quality(encoder, value);
@@ -356,9 +376,9 @@ struct heif_error rav1e_get_parameter_integer(void* encoder_raw, const char* nam
 }
 
 
-struct heif_error rav1e_set_parameter_boolean(void* encoder_raw, const char* name, int value)
+heif_error rav1e_set_parameter_boolean(void* encoder_raw, const char* name, int value)
 {
-  auto* encoder = (struct encoder_struct_rav1e*) encoder_raw;
+  auto* encoder = (encoder_struct_rav1e*) encoder_raw;
 
   if (strcmp(name, heif_encoder_parameter_name_lossless) == 0) {
     return rav1e_set_parameter_lossless(encoder, value);
@@ -369,9 +389,9 @@ struct heif_error rav1e_set_parameter_boolean(void* encoder_raw, const char* nam
   return heif_error_unsupported_parameter;
 }
 
-struct heif_error rav1e_get_parameter_boolean(void* encoder_raw, const char* name, int* value)
+heif_error rav1e_get_parameter_boolean(void* encoder_raw, const char* name, int* value)
 {
-  auto* encoder = (struct encoder_struct_rav1e*) encoder_raw;
+  auto* encoder = (encoder_struct_rav1e*) encoder_raw;
 
   if (strcmp(name, heif_encoder_parameter_name_lossless) == 0) {
     return rav1e_get_parameter_lossless(encoder, value);
@@ -383,9 +403,9 @@ struct heif_error rav1e_get_parameter_boolean(void* encoder_raw, const char* nam
 }
 
 
-struct heif_error rav1e_set_parameter_string(void* encoder_raw, const char* name, const char* value)
+heif_error rav1e_set_parameter_string(void* encoder_raw, const char* name, const char* value)
 {
-  auto* encoder = (struct encoder_struct_rav1e*) encoder_raw;
+  auto* encoder = (encoder_struct_rav1e*) encoder_raw;
 
   if (strcmp(name, kParam_chroma) == 0) {
     if (strcmp(value, "420") == 0) {
@@ -416,24 +436,27 @@ static void save_strcpy(char* dst, int dst_size, const char* src)
 }
 
 
-struct heif_error rav1e_get_parameter_string(void* encoder_raw, const char* name,
-                                             char* value, int value_size)
+heif_error rav1e_get_parameter_string(void* encoder_raw, const char* name,
+                                      char* value, int value_size)
 {
-  struct encoder_struct_rav1e* encoder = (struct encoder_struct_rav1e*) encoder_raw;
+  encoder_struct_rav1e* encoder = (encoder_struct_rav1e*) encoder_raw;
 
-  switch (encoder->chroma) {
-    case heif_chroma_420:
-      save_strcpy(value, value_size, "420");
-      break;
-    case heif_chroma_422:
-      save_strcpy(value, value_size, "422");
-      break;
-    case heif_chroma_444:
-      save_strcpy(value, value_size, "444");
-      break;
-    default:
-      assert(false);
-      return heif_error_invalid_parameter_value;
+  if (strcmp(name, kParam_chroma) == 0) {
+    switch (encoder->chroma) {
+      case heif_chroma_420:
+        save_strcpy(value, value_size, "420");
+        break;
+      case heif_chroma_422:
+        save_strcpy(value, value_size, "422");
+        break;
+      case heif_chroma_444:
+        save_strcpy(value, value_size, "444");
+        break;
+      default:
+        assert(false);
+        return heif_error_invalid_parameter_value;
+    }
+    return heif_error_ok;
   }
 
   return heif_error_unsupported_parameter;
@@ -442,8 +465,8 @@ struct heif_error rav1e_get_parameter_string(void* encoder_raw, const char* name
 
 static void rav1e_set_default_parameters(void* encoder)
 {
-  for (const struct heif_encoder_parameter** p = rav1e_encoder_parameter_ptrs; *p; p++) {
-    const struct heif_encoder_parameter* param = *p;
+  for (const heif_encoder_parameter** p = rav1e_encoder_parameter_ptrs; *p; p++) {
+    const heif_encoder_parameter* param = *p;
 
     if (param->has_default) {
       switch (param->type) {
@@ -478,42 +501,16 @@ void rav1e_query_input_colorspace2(void* encoder_raw, heif_colorspace* colorspac
 }
 
 
-void rav1e_query_encoded_size(void* encoder, uint32_t input_width, uint32_t input_height,
-                              uint32_t* encoded_width, uint32_t* encoded_height)
+heif_error rav1e_start_sequence_encoding_intern(void* encoder_raw, const heif_image* image,
+                                       enum heif_image_input_class input_class,
+                                       uint32_t framerate_num, uint32_t framerate_denom,
+                                       const heif_sequence_encoding_options* options,
+                                       bool image_sequence)
 {
-  *encoded_width = std::max(input_width, 16U);
-  *encoded_height = std::max(input_height, 16U);
-}
-
-
-struct heif_error rav1e_encode_image(void* encoder_raw, const struct heif_image* image,
-                                     heif_image_input_class input_class)
-{
-  auto* encoder = (struct encoder_struct_rav1e*) encoder_raw;
-
-  // --- round image size to minimum size
-
-  uint32_t rounded_width, rounded_height;
-  rav1e_query_encoded_size(encoder,
-                           image->image->get_width(),
-                           image->image->get_height(),
-                           &rounded_width,
-                           &rounded_height);
-
-  bool success = image->image->extend_padding_to_size(rounded_width, rounded_height);
-  if (!success) {
-    struct heif_error err = {
-        heif_error_Memory_allocation_error,
-        heif_suberror_Unspecified,
-        kError_out_of_memory
-    };
-    return err;
-  }
-
+  auto* encoder = (encoder_struct_rav1e*) encoder_raw;
 
   const heif_chroma chroma = heif_image_get_chroma_format(image);
 
-  uint8_t yShift = 0;
   RaChromaSampling chromaSampling;
   RaChromaSamplePosition chromaPosition;
   RaPixelRange rav1eRange;
@@ -521,6 +518,7 @@ struct heif_error rav1e_encode_image(void* encoder_raw, const struct heif_image*
   if (input_class == heif_image_input_class_alpha) {
     chromaSampling = RA_CHROMA_SAMPLING_CS420; // I can't seem to get RA_CHROMA_SAMPLING_CS400 to work right now, unfortunately
     chromaPosition = RA_CHROMA_SAMPLE_POSITION_UNKNOWN; // TODO: set to CENTER when AV1 and rav1e supports this
+    encoder->yShift = 1;
   }
   else {
     switch (chroma) {
@@ -535,21 +533,28 @@ struct heif_error rav1e_encode_image(void* encoder_raw, const struct heif_image*
       case heif_chroma_420:
         chromaSampling = RA_CHROMA_SAMPLING_CS420;
         chromaPosition = RA_CHROMA_SAMPLE_POSITION_UNKNOWN; // TODO: set to CENTER when AV1 and rav1e supports this
-        yShift = 1;
+        encoder->yShift = 1;
         break;
       default:
         return heif_error_codec_library_error;
     }
   }
 
+  heif_color_profile_nclx* nclx = nullptr;
+  heif_error err = heif_image_get_nclx_color_profile(image, &nclx);
+  if (err.code != heif_error_Ok) {
+    nclx = nullptr;
+  }
+
+  // make sure NCLX profile is deleted at end of function
+  auto nclx_deleter = std::unique_ptr<heif_color_profile_nclx, void (*)(heif_color_profile_nclx*)>(nclx, heif_nclx_color_profile_free);
+
   rav1eRange = RA_PIXEL_RANGE_FULL;
-  auto nclx = image->image->get_color_profile_nclx();
   if (nclx) {
-    rav1eRange = nclx->get_full_range_flag() ? RA_PIXEL_RANGE_FULL : RA_PIXEL_RANGE_LIMITED;
+    rav1eRange = nclx->full_range_flag ? RA_PIXEL_RANGE_FULL : RA_PIXEL_RANGE_LIMITED;
   }
 
-  int bitDepth = image->image->get_bits_per_pixel(heif_channel_Y);
-
+  int bitDepth = heif_image_get_bits_per_pixel(image, heif_channel_Y);
 
   auto rav1eConfigRaw = rav1e_config_default();
   auto rav1eConfig = std::shared_ptr<RaConfig>(rav1eConfigRaw, [](RaConfig* c) { rav1e_config_unref(c); });
@@ -558,13 +563,39 @@ struct heif_error rav1e_encode_image(void* encoder_raw, const struct heif_image*
     return heif_error_codec_library_error;
   }
 
-  if (rav1e_config_parse(rav1eConfig.get(), "still_picture", "true") == -1) {
-    return heif_error_codec_library_error;
+  rav1e_config_set_time_base(rav1eConfig.get(), RaRational{framerate_num, framerate_denom});
+
+  if (!image_sequence) {
+    if (rav1e_config_parse(rav1eConfig.get(), "still_picture", "true") == -1) {
+      return heif_error_codec_library_error;
+    }
   }
-  if (rav1e_config_parse_int(rav1eConfig.get(), "width", image->image->get_width()) == -1) {
+
+  if (image_sequence) {
+    if (options->gop_structure == heif_sequence_gop_structure_intra_only) {
+      if (rav1e_config_parse(rav1eConfig.get(), "key_frame_interval", "1") == -1) {
+        return heif_error_codec_library_error;
+      }
+    }
+    else if (options->keyframe_distance_max) {
+      if (rav1e_config_parse(rav1eConfig.get(), "key_frame_interval",
+                             std::to_string(options->keyframe_distance_max).c_str()) == -1) {
+        return heif_error_codec_library_error;
+      }
+    }
+
+    if (options->keyframe_distance_min) {
+      if (rav1e_config_parse(rav1eConfig.get(), "min_key_frame_interval",
+                             std::to_string(options->keyframe_distance_min).c_str()) == -1) {
+        return heif_error_codec_library_error;
+      }
+    }
+  }
+
+  if (rav1e_config_parse_int(rav1eConfig.get(), "width", heif_image_get_width(image, heif_channel_Y)) == -1) {
     return heif_error_codec_library_error;
   }
-  if (rav1e_config_parse_int(rav1eConfig.get(), "height", image->image->get_height()) == -1) {
+  if (rav1e_config_parse_int(rav1eConfig.get(), "height", heif_image_get_height(image, heif_channel_Y)) == -1) {
     return heif_error_codec_library_error;
   }
   if (rav1e_config_parse_int(rav1eConfig.get(), "threads", encoder->threads) == -1) {
@@ -575,9 +606,9 @@ struct heif_error rav1e_encode_image(void* encoder_raw, const struct heif_image*
       (input_class == heif_image_input_class_normal ||
        input_class == heif_image_input_class_thumbnail)) {
     if (rav1e_config_set_color_description(rav1eConfig.get(),
-                                           (RaMatrixCoefficients) nclx->get_matrix_coefficients(),
-                                           (RaColorPrimaries) nclx->get_colour_primaries(),
-                                           (RaTransferCharacteristics) nclx->get_transfer_characteristics()) == -1) {
+                                           (RaMatrixCoefficients) nclx->matrix_coefficients,
+                                           (RaColorPrimaries) nclx->color_primaries,
+                                           (RaTransferCharacteristics) nclx->transfer_characteristics) == -1) {
       return heif_error_codec_library_error;
     }
   }
@@ -608,38 +639,60 @@ struct heif_error rav1e_encode_image(void* encoder_raw, const struct heif_image*
     }
   }
 
-  auto colorProfile = image->image->get_color_profile_nclx();
-  if (auto nclxProfile = std::dynamic_pointer_cast<const heif_color_profile_nclx>(colorProfile)) {
+  if (nclx) {
     rav1e_config_set_color_description(rav1eConfig.get(),
-                                       (RaMatrixCoefficients) nclxProfile->matrix_coefficients,
-                                       (RaColorPrimaries) nclxProfile->color_primaries,
-                                       (RaTransferCharacteristics) nclxProfile->transfer_characteristics);
+                                       (RaMatrixCoefficients) nclx->matrix_coefficients,
+                                       (RaColorPrimaries) nclx->color_primaries,
+                                       (RaTransferCharacteristics) nclx->transfer_characteristics);
   }
 
-  RaContext* rav1eContextRaw = rav1e_context_new(rav1eConfig.get());
-  if (!rav1eContextRaw) {
+  encoder->rav1eContextRaw = rav1e_context_new(rav1eConfig.get());
+  if (!encoder->rav1eContextRaw) {
     return heif_error_codec_library_error;
   }
-  auto rav1eContext = std::shared_ptr<RaContext>(rav1eContextRaw, [](RaContext* ctx) { rav1e_context_unref(ctx); });
+
+  return {};
+}
+
+
+heif_error rav1e_start_sequence_encoding(void* encoder_raw, const heif_image* image,
+                                       enum heif_image_input_class input_class,
+                                       uint32_t framerate_num, uint32_t framerate_denom,
+                                       const heif_sequence_encoding_options* options)
+{
+  return rav1e_start_sequence_encoding_intern(encoder_raw, image, input_class,
+                                              framerate_num, framerate_denom, options, true);
+}
+
+
+heif_error rav1e_encode_sequence_frame(void* encoder_raw, const heif_image* image, uintptr_t frame_nr)
+{
+  auto* encoder = (encoder_struct_rav1e*) encoder_raw;
+  auto& rav1eContext = encoder->rav1eContextRaw;
+
+  int bitDepth = heif_image_get_bits_per_pixel(image, heif_channel_Y);
+
+  int yShift = encoder->yShift;
 
 
   // --- copy libheif image to rav1e image
 
-  auto rav1eFrameRaw = rav1e_frame_new(rav1eContext.get());
+  auto rav1eFrameRaw = rav1e_frame_new(rav1eContext);
   auto rav1eFrame = std::shared_ptr<RaFrame>(rav1eFrameRaw, [](RaFrame* frm) { rav1e_frame_unref(frm); });
 
   int byteWidth = (bitDepth > 8) ? 2 : 1;
   // if (input_class == heif_image_input_class_alpha) {
   //} else
   {
-    int strideY;
-    const uint8_t* Y = image->image->get_plane(heif_channel_Y, &strideY);
-    int strideCb;
-    const uint8_t* Cb = image->image->get_plane(heif_channel_Cb, &strideCb);
-    int strideCr;
-    const uint8_t* Cr = image->image->get_plane(heif_channel_Cr, &strideCr);
+    size_t strideY;
+    const uint8_t* Y = heif_image_get_plane_readonly2(image, heif_channel_Y, &strideY);
+    size_t strideCb;
+    const uint8_t* Cb = heif_image_get_plane_readonly2(image, heif_channel_Cb, &strideCb);
+    size_t strideCr;
+    const uint8_t* Cr = heif_image_get_plane_readonly2(image, heif_channel_Cr, &strideCr);
+
 
-    uint32_t height = image->image->get_height();
+    uint32_t height = heif_image_get_height(image, heif_channel_Y);
 
     uint32_t uvHeight = (height + yShift) >> yShift;
     rav1e_frame_fill_plane(rav1eFrame.get(), 0, Y, strideY * height, strideY, byteWidth);
@@ -647,58 +700,138 @@ struct heif_error rav1e_encode_image(void* encoder_raw, const struct heif_image*
     rav1e_frame_fill_plane(rav1eFrame.get(), 2, Cr, strideCr * uvHeight, strideCr, byteWidth);
   }
 
-  RaEncoderStatus encoderStatus = rav1e_send_frame(rav1eContext.get(), rav1eFrame.get());
+  RaEncoderStatus encoderStatus = rav1e_send_frame(rav1eContext, rav1eFrame.get());
   if (encoderStatus != 0) {
     return heif_error_codec_library_error;
   }
 
+  return get_encoder_packets(encoder_raw);
+}
+
+
+heif_error rav1e_end_sequence_encoding(void* encoder_raw)
+{
+  auto* encoder = (encoder_struct_rav1e*) encoder_raw;
+  auto& rav1eContext = encoder->rav1eContextRaw;
+
   // flush encoder
-  encoderStatus = rav1e_send_frame(rav1eContext.get(), nullptr);
+  RaEncoderStatus encoderStatus = rav1e_send_frame(rav1eContext, nullptr);
   if (encoderStatus != 0) {
     return heif_error_codec_library_error;
   }
 
-  RaPacket* pkt = nullptr;
-  encoderStatus = rav1e_receive_packet(rav1eContext.get(), &pkt);
-  if (encoderStatus != 0) {
-    return heif_error_codec_library_error;
+  return get_encoder_packets(encoder_raw);
+}
+
+
+static heif_error get_encoder_packets(void* encoder_raw)
+{
+  auto* encoder = (encoder_struct_rav1e*) encoder_raw;
+  auto& rav1eContext = encoder->rav1eContextRaw;
+
+  for (;;) {
+    RaPacket* pkt = nullptr;
+    RaEncoderStatus encoderStatus = rav1e_receive_packet(rav1eContext, &pkt);
+
+    if (encoderStatus == RA_ENCODER_STATUS_NEED_MORE_DATA) {
+      return {};
+    }
+
+    if (encoderStatus == RA_ENCODER_STATUS_ENCODED) {
+      continue;
+    }
+
+    if (encoderStatus != 0) {
+      return heif_error_codec_library_error;
+    }
+
+    if (pkt && pkt->data && (pkt->len > 0)) {
+      encoder_struct_rav1e::Packet output_packet;
+      output_packet.frameNr = pkt->input_frameno;
+      output_packet.is_keyframe = (pkt->frame_type == RaFrameType::RA_FRAME_TYPE_KEY);
+
+      encoder->output_packets.emplace_back(output_packet);
+      encoder->output_packets.back().compressedData.resize(pkt->len);
+
+      memcpy(encoder->output_packets.back().compressedData.data(),
+             pkt->data,
+             pkt->len);
+    }
+
+    if (pkt) {
+      rav1e_packet_unref(pkt);
+    }
+    else {
+      break;
+    }
   }
 
-  if (pkt && pkt->data && (pkt->len > 0)) {
-    encoder->compressed_data.resize(pkt->len);
-    memcpy(encoder->compressed_data.data(), pkt->data, pkt->len);
-    encoder->data_read = false;
+  return {};
+}
+
+
+heif_error rav1e_get_compressed_data2(void* encoder_raw, uint8_t** data, int* size,
+                                    uintptr_t* out_framenr, int* out_is_keyframe,
+                                    int* more_frame_packets)
+{
+  auto* encoder = (encoder_struct_rav1e*) encoder_raw;
+
+  encoder->active_output_data.clear();
+
+  if (encoder->output_packets.empty()) {
+    *size = 0;
+    *data = nullptr;
   }
+  else {
+    encoder->active_output_data = std::move(encoder->output_packets.front().compressedData);
+    if (out_framenr) {
+      *out_framenr = encoder->output_packets.front().frameNr;
+    }
+
+    if (out_is_keyframe) {
+      *out_is_keyframe = encoder->output_packets.front().is_keyframe;
+    }
 
-  if (pkt) {
-    rav1e_packet_unref(pkt);
+    encoder->output_packets.pop_front();
+
+    *size = (int) encoder->active_output_data.size();
+    *data = encoder->active_output_data.data();
   }
 
   return heif_error_ok;
 }
 
-struct heif_error rav1e_get_compressed_data(void* encoder_raw, uint8_t** data, int* size,
-                                            enum heif_encoded_data_type* type)
+heif_error rav1e_get_compressed_data(void* encoder_raw, uint8_t** data, int* size,
+                                     heif_encoded_data_type* type)
 {
-  auto* encoder = (struct encoder_struct_rav1e*) encoder_raw;
+  return rav1e_get_compressed_data2(encoder_raw, data, size, nullptr, nullptr, nullptr);
+}
 
-  if (encoder->data_read) {
-    *data = nullptr;
-    *size = 0;
+
+heif_error rav1e_encode_image(void* encoder_raw, const heif_image* image,
+                              heif_image_input_class input_class)
+{
+  heif_error err;
+  err = rav1e_start_sequence_encoding_intern(encoder_raw, image, input_class, 1,25, nullptr, false);
+  if (err.code) {
+    return err;
   }
-  else {
-    *data = encoder->compressed_data.data();
-    *size = (int) encoder->compressed_data.size();
-    encoder->data_read = true;
+
+  err = rav1e_encode_sequence_frame(encoder_raw, image, 0);
+  if (err.code) {
+    return err;
   }
 
+  rav1e_end_sequence_encoding(encoder_raw);
+
   return heif_error_ok;
 }
 
 
-static const struct heif_encoder_plugin encoder_plugin_rav1e
+
+static const heif_encoder_plugin encoder_plugin_rav1e
     {
-        /* plugin_api_version */ 3,
+        /* plugin_api_version */ 4,
         /* compression_format */ heif_compression_AV1,
         /* id_name */ "rav1e",
         /* priority */ RAV1E_PLUGIN_PRIORITY,
@@ -726,10 +859,25 @@ static const struct heif_encoder_plugin encoder_plugin_rav1e
         /* encode_image */ rav1e_encode_image,
         /* get_compressed_data */ rav1e_get_compressed_data,
         /* query_input_colorspace (v2) */ rav1e_query_input_colorspace2,
-        /* query_encoded_size (v3) */ rav1e_query_encoded_size
+        /* query_encoded_size (v3) */ nullptr,
+        /* minimum_required_libheif_version */ LIBHEIF_MAKE_VERSION(1,21,0),
+        /* start_sequence_encoding (v4) */ rav1e_start_sequence_encoding,
+        /* encode_sequence_frame (v4) */ rav1e_encode_sequence_frame,
+        /* end_sequence_encoding (v4) */ rav1e_end_sequence_encoding,
+        /* get_compressed_data2 (v4) */ rav1e_get_compressed_data2,
+        /* does_indicate_keyframes (v4) */ 1
     };
 
-const struct heif_encoder_plugin* get_encoder_plugin_rav1e()
+const heif_encoder_plugin* get_encoder_plugin_rav1e()
 {
   return &encoder_plugin_rav1e;
 }
+
+
+#if PLUGIN_RAV1E
+heif_plugin_info plugin_info{
+    1,
+    heif_plugin_type_encoder,
+    &encoder_plugin_rav1e
+};
+#endif
diff --git a/libheif/heif_encoder_rav1e.h b/libheif/plugins/encoder_rav1e.h
similarity index 76%
rename from libheif/heif_encoder_rav1e.h
rename to libheif/plugins/encoder_rav1e.h
index 2853ebeb55..bb0eb9c915 100644
--- a/libheif/heif_encoder_rav1e.h
+++ b/libheif/plugins/encoder_rav1e.h
@@ -1,6 +1,6 @@
 /*
  * HEIF codec.
- * Copyright (c) 2017 struktur AG, Dirk Farin <farin@struktur.de>
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
  *
  * This file is part of libheif.
  *
@@ -18,10 +18,17 @@
  * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef LIBHEIF_HEIF_ENCODER_RAV1E_H
-#define LIBHEIF_HEIF_ENCODER_RAV1E_H
+#ifndef LIBHEIF_ENCODER_RAV1E_H
+#define LIBHEIF_ENCODER_RAV1E_H
 
+#include "common_utils.h"
 
 const struct heif_encoder_plugin* get_encoder_plugin_rav1e();
 
+#if PLUGIN_RAV1E
+extern "C" {
+MAYBE_UNUSED LIBHEIF_API extern heif_plugin_info plugin_info;
+}
+#endif
+
 #endif
diff --git a/libheif/plugins/encoder_svt.cc b/libheif/plugins/encoder_svt.cc
new file mode 100644
index 0000000000..03d87ca1ae
--- /dev/null
+++ b/libheif/plugins/encoder_svt.cc
@@ -0,0 +1,1258 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2022 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "libheif/heif.h"
+#include "libheif/heif_plugin.h"
+#include "encoder_svt.h"
+#include <vector>
+#include <cstring>
+#include <cassert>
+#include <algorithm>
+#include <deque>
+#include <memory>
+#include <limits>
+
+#include "svt-av1/EbSvtAv1.h"
+#include "svt-av1/EbSvtAv1Enc.h"
+#include <utility>
+
+// TODO: for some reason, the SVT encoder outputs only keyframes for me.
+//       It appears to work in libavif, but I didn't find the difference yet.
+
+struct encoder_struct_svt
+{
+  ~encoder_struct_svt()
+  {
+    if (svt_encoder) {
+      svt_av1_enc_deinit(svt_encoder);
+      svt_av1_enc_deinit_handle(svt_encoder);
+    }
+  }
+
+  int speed = 12; // 0-13
+
+  int quality;
+
+  int min_q = 0;
+  int max_q = 63;
+  int qp = -1;
+  bool qp_set = false;
+#if SVT_AV1_CHECK_VERSION(3, 0, 0)
+  bool lossless = false;
+#endif
+
+  int threads = 4;
+
+  int tile_rows = 1; // 1,2,4,8,16,32,64
+  int tile_cols = 1; // 1,2,4,8,16,32,64
+
+#if SVT_AV1_CHECK_VERSION(0, 9, 1)
+  enum Tune
+  {
+    Tune_VQ = 0,
+    Tune_PSNR = 1,
+    Tune_SSIM = 2
+  };
+
+  uint8_t tune = Tune_PSNR;
+#endif
+
+  heif_chroma chroma = heif_chroma_420; // SVT-AV1 only supports 4:2:0 as of v3.0.0
+  heif_image_input_class input_class = heif_image_input_class_normal;
+
+  // int keyframe_interval = 0; TODO: this does not seem to work (see all [1])
+
+  // --- Encoder
+
+  EbComponentType* svt_encoder = nullptr;
+  EbSvtAv1EncConfiguration svt_config;
+  EbBufferHeaderType input_buffer;
+
+  bool still_image_mode = false;
+
+  // --- output
+
+  struct Packet
+  {
+    std::vector<uint8_t> compressedData;
+    uintptr_t frameNr = 0;
+    bool is_keyframe = false;
+  };
+
+  std::deque<Packet> output_packets;
+  std::vector<uint8_t> active_output_data;
+
+  //std::vector<uint8_t> compressed_data;
+  //bool data_read = false;
+};
+
+//static const char* kError_out_of_memory = "Out of memory";
+
+static const char* kParam_min_q = "min-q";
+static const char* kParam_max_q = "max-q";
+static const char* kParam_qp = "qp";
+static const char* kParam_threads = "threads";
+static const char* kParam_speed = "speed";
+
+#if SVT_AV1_CHECK_VERSION(0, 9, 1)
+static const char* kParam_tune = "tune";
+static const char* const kParam_tune_valid_values[] = {"vq", "psnr", "ssim", nullptr};
+#endif
+
+/*
+static const char* kParam_chroma = "chroma";
+static const char* const kParam_chroma_valid_values[] = {
+    "420", "422", "444", nullptr
+};
+*/
+
+static int valid_tile_num_values[] = {1, 2, 4, 8, 16, 32, 64};
+
+static heif_error heif_error_codec_library_error = {
+  heif_error_Encoder_plugin_error,
+  heif_suberror_Unspecified,
+  "SVT-AV1 error"
+};
+
+static const int SVT_PLUGIN_PRIORITY = 40;
+
+#define MAX_PLUGIN_NAME_LENGTH 80
+
+static char plugin_name[MAX_PLUGIN_NAME_LENGTH];
+
+
+static void svt_set_default_parameters(void* encoder);
+
+
+static const char* svt_plugin_name()
+{
+  plugin_name[MAX_PLUGIN_NAME_LENGTH - 1] = 0;
+  snprintf(plugin_name, MAX_PLUGIN_NAME_LENGTH, "SVT-AV1 encoder %s", svt_av1_get_version());
+
+  return plugin_name;
+}
+
+int int_log2(int pow2_value)
+{
+  int input_value = pow2_value;
+  (void) input_value;
+
+  int v = 0;
+  while (pow2_value > 1) {
+    pow2_value >>= 1;
+    v++;
+  }
+
+  // check that computation is correct
+  assert(input_value == (1 << v));
+
+  return v;
+}
+
+#define MAX_NPARAMETERS 11
+
+static heif_encoder_parameter svt_encoder_params[MAX_NPARAMETERS];
+static const heif_encoder_parameter* svt_encoder_parameter_ptrs[MAX_NPARAMETERS + 1];
+
+static void svt_init_parameters()
+{
+  heif_encoder_parameter* p = svt_encoder_params;
+  const heif_encoder_parameter** d = svt_encoder_parameter_ptrs;
+  int i = 0;
+
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = kParam_speed;
+  p->type = heif_encoder_parameter_type_integer;
+  p->integer.default_value = 12;
+  p->has_default = true;
+  p->integer.have_minimum_maximum = true;
+  p->integer.minimum = 0;
+  p->integer.maximum = 13;
+  p->integer.valid_values = nullptr;
+  p->integer.num_valid_values = 0;
+  d[i++] = p++;
+
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = kParam_threads;
+  p->type = heif_encoder_parameter_type_integer;
+  p->integer.default_value = 4;
+  p->has_default = true;
+  p->integer.have_minimum_maximum = true;
+  p->integer.minimum = 1;
+  p->integer.maximum = 16;
+  p->integer.valid_values = nullptr;
+  p->integer.num_valid_values = 0;
+  d[i++] = p++;
+
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = "tile-rows";
+  p->type = heif_encoder_parameter_type_integer;
+  p->integer.default_value = 4;
+  p->has_default = true;
+  p->integer.have_minimum_maximum = false;
+  p->integer.valid_values = valid_tile_num_values;
+  p->integer.num_valid_values = 7;
+  d[i++] = p++;
+
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = "tile-cols";
+  p->type = heif_encoder_parameter_type_integer;
+  p->integer.default_value = 4;
+  p->has_default = true;
+  p->integer.have_minimum_maximum = false;
+  p->integer.valid_values = valid_tile_num_values;
+  p->integer.num_valid_values = 7;
+  d[i++] = p++;
+
+
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = heif_encoder_parameter_name_quality;
+  p->type = heif_encoder_parameter_type_integer;
+  p->integer.default_value = 50;
+  p->has_default = true;
+  p->integer.have_minimum_maximum = true;
+  p->integer.minimum = 0;
+  p->integer.maximum = 100;
+  p->integer.valid_values = NULL;
+  p->integer.num_valid_values = 0;
+  d[i++] = p++;
+
+#if SVT_AV1_CHECK_VERSION(3, 0, 0)
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = heif_encoder_parameter_name_lossless;
+  p->type = heif_encoder_parameter_type_boolean;
+  p->boolean.default_value = false;
+  p->has_default = true;
+  d[i++] = p++;
+#endif
+
+#if 0
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = kParam_chroma;
+  p->type = heif_encoder_parameter_type_string;
+  p->string.default_value = "420";
+  p->has_default = true;
+  p->string.valid_values = kParam_chroma_valid_values;
+  d[i++] = p++;
+#endif
+
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = kParam_qp;
+  p->type = heif_encoder_parameter_type_integer;
+  p->integer.default_value = 50;
+  p->has_default = false;
+  p->integer.have_minimum_maximum = true;
+  p->integer.minimum = 0;
+  p->integer.maximum = 63;
+  p->integer.valid_values = nullptr;
+  p->integer.num_valid_values = 0;
+  d[i++] = p++;
+
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = kParam_min_q;
+  p->type = heif_encoder_parameter_type_integer;
+  p->integer.default_value = 0;
+  p->has_default = true;
+  p->integer.have_minimum_maximum = true;
+  p->integer.minimum = 0;
+  p->integer.maximum = 63;
+  p->integer.valid_values = nullptr;
+  p->integer.num_valid_values = 0;
+  d[i++] = p++;
+
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = kParam_max_q;
+  p->type = heif_encoder_parameter_type_integer;
+  p->integer.default_value = 63;
+  p->has_default = true;
+  p->integer.have_minimum_maximum = true;
+  p->integer.minimum = 0;
+  p->integer.maximum = 63;
+  p->integer.valid_values = nullptr;
+  p->integer.num_valid_values = 0;
+  d[i++] = p++;
+
+#if SVT_AV1_CHECK_VERSION(0, 9, 1)
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = kParam_tune;
+  p->type = heif_encoder_parameter_type_string;
+  p->string.default_value = "psnr";
+  p->has_default = true;
+  p->string.valid_values = kParam_tune_valid_values;
+  d[i++] = p++;
+#endif
+
+  d[i++] = nullptr;
+}
+
+
+const heif_encoder_parameter** svt_list_parameters(void* encoder)
+{
+  return svt_encoder_parameter_ptrs;
+}
+
+static void svt_init_plugin()
+{
+  svt_init_parameters();
+}
+
+
+static void svt_cleanup_plugin()
+{
+}
+
+heif_error svt_new_encoder(void** enc)
+{
+  auto* encoder = new encoder_struct_svt();
+  struct heif_error err = heif_error_ok;
+
+  *enc = encoder;
+
+  // set default parameters
+
+  svt_set_default_parameters(encoder);
+
+  return err;
+}
+
+void svt_free_encoder(void* encoder_raw)
+{
+  auto* encoder = (struct encoder_struct_svt*) encoder_raw;
+
+  delete encoder;
+}
+
+
+heif_error svt_set_parameter_quality(void* encoder_raw, int quality)
+{
+  auto* encoder = (encoder_struct_svt*) encoder_raw;
+
+  if (quality < 0 || quality > 100) {
+    return heif_error_invalid_parameter_value;
+  }
+
+  encoder->quality = quality;
+
+  return heif_error_ok;
+}
+
+heif_error svt_get_parameter_quality(void* encoder_raw, int* quality)
+{
+  auto* encoder = (encoder_struct_svt*) encoder_raw;
+
+  *quality = encoder->quality;
+
+  return heif_error_ok;
+}
+
+heif_error svt_set_parameter_lossless(void* encoder_raw, int enable)
+{
+  auto* encoder = (encoder_struct_svt*) encoder_raw;
+
+#if SVT_AV1_CHECK_VERSION(3, 0, 0)
+  encoder->lossless = enable;
+#else
+  if (enable) {
+    encoder->min_q = 0;
+    encoder->max_q = 0;
+    encoder->qp = 0;
+    encoder->qp_set = true;
+    encoder->quality = 100; // not really required, but to be consistent
+  }
+#endif
+
+  return heif_error_ok;
+}
+
+heif_error svt_get_parameter_lossless(void* encoder_raw, int* enable)
+{
+  auto* encoder = (encoder_struct_svt*) encoder_raw;
+
+#if SVT_AV1_CHECK_VERSION(3, 0, 0)
+  *enable = encoder->lossless;
+#else
+  *enable = (encoder->min_q == 0 && encoder->max_q == 0 &&
+             ((encoder->qp_set && encoder->qp == 0) || encoder->quality == 100));
+#endif
+
+  return heif_error_ok;
+}
+
+heif_error svt_set_parameter_logging_level(void* encoder_raw, int logging)
+{
+#if 0
+  struct encoder_struct_x265* encoder = (struct encoder_struct_x265*)encoder_raw;
+
+  if (logging<0 || logging>4) {
+    return heif_error_invalid_parameter_value;
+  }
+
+  encoder->logLevel = logging;
+#endif
+
+  return heif_error_ok;
+}
+
+heif_error svt_get_parameter_logging_level(void* encoder_raw, int* loglevel)
+{
+#if 0
+  struct encoder_struct_x265* encoder = (struct encoder_struct_x265*)encoder_raw;
+
+  *loglevel = encoder->logLevel;
+#else
+  *loglevel = 0;
+#endif
+
+  return heif_error_ok;
+}
+
+#define set_value(paramname, paramvar) if (strcmp(name, paramname)==0) { encoder->paramvar = value; return heif_error_ok; }
+#define get_value(paramname, paramvar) if (strcmp(name, paramname)==0) { *value = encoder->paramvar; return heif_error_ok; }
+
+
+heif_error svt_set_parameter_integer(void* encoder_raw, const char* name, int value)
+{
+  encoder_struct_svt* encoder = (encoder_struct_svt*) encoder_raw;
+
+  if (strcmp(name, heif_encoder_parameter_name_quality) == 0) {
+    return svt_set_parameter_quality(encoder, value);
+  }
+  else if (strcmp(name, heif_encoder_parameter_name_lossless) == 0) {
+    return svt_set_parameter_lossless(encoder, value);
+  }
+  else if (strcmp(name, kParam_qp) == 0) {
+    encoder->qp = value;
+    encoder->qp_set = true;
+    return heif_error_ok;
+  }
+
+  set_value(kParam_min_q, min_q);
+  set_value(kParam_max_q, max_q);
+  set_value(kParam_threads, threads);
+  set_value(kParam_speed, speed);
+  set_value("tile-rows", tile_rows);
+  set_value("tile-cols", tile_cols);
+
+  return heif_error_unsupported_parameter;
+}
+
+heif_error svt_get_parameter_integer(void* encoder_raw, const char* name, int* value)
+{
+  auto* encoder = (encoder_struct_svt*) encoder_raw;
+
+  if (strcmp(name, heif_encoder_parameter_name_quality) == 0) {
+    return svt_get_parameter_quality(encoder, value);
+  }
+  else if (strcmp(name, heif_encoder_parameter_name_lossless) == 0) {
+    return svt_get_parameter_lossless(encoder, value);
+  }
+
+  get_value(kParam_min_q, min_q);
+  get_value(kParam_max_q, max_q);
+  get_value(kParam_qp, qp); // TODO: what if qp was not set ?
+  get_value(kParam_threads, threads);
+  get_value(kParam_speed, speed);
+  get_value("tile-rows", tile_rows);
+  get_value("tile-cols", tile_cols);
+
+  return heif_error_unsupported_parameter;
+}
+
+
+heif_error svt_set_parameter_boolean(void* encoder_raw, const char* name, int value)
+{
+  auto* encoder = (encoder_struct_svt*) encoder_raw;
+
+  if (strcmp(name, heif_encoder_parameter_name_lossless) == 0) {
+    return svt_set_parameter_lossless(encoder, value);
+  }
+
+  //set_value(kParam_realtime, realtime_mode);
+
+  return heif_error_unsupported_parameter;
+}
+
+heif_error svt_get_parameter_boolean(void* encoder_raw, const char* name, int* value)
+{
+  auto* encoder = (encoder_struct_svt*) encoder_raw;
+
+  if (strcmp(name, heif_encoder_parameter_name_lossless) == 0) {
+    return svt_get_parameter_lossless(encoder, value);
+  }
+
+  //get_value(kParam_realtime, realtime_mode);
+
+  return heif_error_unsupported_parameter;
+}
+
+
+heif_error svt_set_parameter_string(void* encoder_raw, const char* name, const char* value)
+{
+  auto* encoder = (encoder_struct_svt*) encoder_raw;
+  (void) encoder;
+
+#if 0
+  if (strcmp(name, kParam_chroma) == 0) {
+    if (strcmp(value, "420") == 0) {
+      encoder->chroma = heif_chroma_420;
+      return heif_error_ok;
+    }
+    else if (strcmp(value, "422") == 0) {
+      encoder->chroma = heif_chroma_422;
+      return heif_error_ok;
+    }
+    else if (strcmp(value, "444") == 0) {
+      encoder->chroma = heif_chroma_444;
+      return heif_error_ok;
+    }
+    else {
+      return heif_error_invalid_parameter_value;
+    }
+  }
+#endif
+
+#if SVT_AV1_CHECK_VERSION(0, 9, 1)
+  if (strcmp(name, kParam_tune) == 0) {
+    if (strcmp(value, "vq") == 0) {
+      encoder->tune = encoder_struct_svt::Tune_VQ;
+      return heif_error_ok;
+    }
+    else if (strcmp(value, "psnr") == 0) {
+      encoder->tune = encoder_struct_svt::Tune_PSNR;
+      return heif_error_ok;
+    }
+    else if (strcmp(value, "ssim") == 0) {
+      encoder->tune = encoder_struct_svt::Tune_SSIM;
+      return heif_error_ok;
+    }
+  }
+#endif
+
+  return heif_error_unsupported_parameter;
+}
+
+
+#if SVT_AV1_CHECK_VERSION(0, 9, 1)
+static void save_strcpy(char* dst, int dst_size, const char* src)
+{
+  strncpy(dst, src, dst_size - 1);
+  dst[dst_size - 1] = 0;
+}
+#endif
+
+
+heif_error svt_get_parameter_string(void* encoder_raw, const char* name,
+                                    char* value, int value_size)
+{
+  auto* encoder = (encoder_struct_svt*) encoder_raw;
+  (void) encoder;
+
+#if 0
+  if (strcmp(name, kParam_chroma) == 0) {
+    switch (encoder->chroma) {
+      case heif_chroma_420:
+        save_strcpy(value, value_size, "420");
+        break;
+      case heif_chroma_422:
+        save_strcpy(value, value_size, "422");
+        break;
+      case heif_chroma_444:
+        save_strcpy(value, value_size, "444");
+        break;
+      default:
+        assert(false);
+        return heif_error_invalid_parameter_value;
+    }
+    return heif_error_ok;
+  }
+#endif
+
+#if SVT_AV1_CHECK_VERSION(0, 9, 1)
+  if (strcmp(name, kParam_tune) == 0) {
+    switch (encoder->tune) {
+      case encoder_struct_svt::Tune_VQ:
+        save_strcpy(value, value_size, "vq");
+        break;
+      case encoder_struct_svt::Tune_PSNR:
+        save_strcpy(value, value_size, "psnr");
+        break;
+      case encoder_struct_svt::Tune_SSIM:
+        save_strcpy(value, value_size, "ssim");
+        break;
+      default:
+        assert(false);
+
+        return heif_error_invalid_parameter_value;
+    }
+    return heif_error_ok;
+  }
+#endif
+
+  return heif_error_unsupported_parameter;
+}
+
+
+static void svt_set_default_parameters(void* encoder)
+{
+  for (const heif_encoder_parameter** p = svt_encoder_parameter_ptrs; *p; p++) {
+    const heif_encoder_parameter* param = *p;
+
+    if (param->has_default) {
+      switch (param->type) {
+        case heif_encoder_parameter_type_integer:
+          svt_set_parameter_integer(encoder, param->name, param->integer.default_value);
+          break;
+        case heif_encoder_parameter_type_boolean:
+          svt_set_parameter_boolean(encoder, param->name, param->boolean.default_value);
+          break;
+        case heif_encoder_parameter_type_string:
+          // NOLINTNEXTLINE(build/include_what_you_use)
+          svt_set_parameter_string(encoder, param->name, param->string.default_value);
+          break;
+      }
+    }
+  }
+}
+
+
+void svt_query_input_colorspace(heif_colorspace* colorspace, heif_chroma* chroma)
+{
+  *colorspace = heif_colorspace_YCbCr;
+  *chroma = heif_chroma_420;
+}
+
+
+void svt_query_input_colorspace2(void* encoder_raw, heif_colorspace* colorspace, heif_chroma* chroma)
+{
+  //auto* encoder = (struct encoder_struct_svt*) encoder_raw;
+
+  *colorspace = heif_colorspace_YCbCr;
+  *chroma = heif_chroma_420;
+}
+
+
+void svt_query_encoded_size(void* encoder_raw, uint32_t input_width, uint32_t input_height,
+                            uint32_t* encoded_width, uint32_t* encoded_height)
+{
+  auto* encoder = (encoder_struct_svt*) encoder_raw;
+
+  // SVT-AV1 (as of version 1.2.1) can only create image sizes matching the chroma format. Add padding if necessary.
+
+  if (input_width < 64) {
+    *encoded_width = 64;
+  }
+  else if (encoder->chroma == heif_chroma_420 && (input_width & 1) == 1) {
+    *encoded_width = input_width + 1;
+  }
+  else {
+    *encoded_width = input_width;
+  }
+
+  if (input_height < 64) {
+    *encoded_height = 64;
+  }
+  else if (encoder->chroma != heif_chroma_444 && (input_height & 1) == 1) {
+    *encoded_height = input_height + 1;
+  }
+  else {
+    *encoded_height = input_height;
+  }
+}
+
+
+static heif_error svt_start_sequence_encoding_intern(void* encoder_raw, const heif_image* image,
+                                                     enum heif_image_input_class input_class,
+                                                     uint32_t framerate_num, uint32_t framerate_denom,
+                                                     const heif_sequence_encoding_options* options,
+                                                     bool image_sequence)
+{
+  auto* encoder = (encoder_struct_svt*) encoder_raw;
+  encoder->input_class = input_class;
+  EbErrorType res = EB_ErrorNone;
+  heif_error err;
+
+  // encoder->compressed_data.clear();
+
+  int w = heif_image_get_width(image, heif_channel_Y);
+  int h = heif_image_get_height(image, heif_channel_Y);
+
+  uint32_t encoded_width, encoded_height;
+  svt_query_encoded_size(encoder_raw, w, h, &encoded_width, &encoded_height);
+
+  const heif_chroma chroma = heif_image_get_chroma_format(image);
+  int bitdepth_y = heif_image_get_bits_per_pixel_range(image, heif_channel_Y);
+
+  EbColorFormat color_format = EB_YUV420;
+
+  if (input_class == heif_image_input_class_alpha) {
+    color_format = EB_YUV420;
+    //chromaPosition = RA_CHROMA_SAMPLE_POSITION_UNKNOWN;
+  }
+  else {
+    switch (chroma) {
+      case heif_chroma_444:
+        color_format = EB_YUV444;
+        //chromaPosition = RA_CHROMA_SAMPLE_POSITION_COLOCATED;
+        break;
+      case heif_chroma_422:
+        color_format = EB_YUV422;
+        //chromaPosition = RA_CHROMA_SAMPLE_POSITION_COLOCATED;
+        break;
+      case heif_chroma_420:
+        color_format = EB_YUV420;
+        //chromaPosition = RA_CHROMA_SAMPLE_POSITION_UNKNOWN; // TODO: set to CENTER when AV1 and svt supports this
+        break;
+      default:
+        return heif_error_codec_library_error;
+    }
+  }
+
+
+  // --- initialize the encoder
+
+  EbComponentType*& svt_encoder = encoder->svt_encoder;
+  EbSvtAv1EncConfiguration& svt_config = encoder->svt_config;
+  memset(&svt_config, 0, sizeof(EbSvtAv1EncConfiguration));
+
+#if SVT_AV1_CHECK_VERSION(3, 0, 0)
+  res = svt_av1_enc_init_handle(&svt_encoder, &svt_config);
+#else
+  res = svt_av1_enc_init_handle(&svt_encoder, nullptr, &svt_config);
+#endif
+  if (res != EB_ErrorNone) {
+    //goto cleanup;
+    return heif_error_codec_library_error;
+  }
+
+  svt_config.encoder_color_format = color_format;
+  svt_config.encoder_bit_depth = (uint8_t) bitdepth_y;
+  //svt_config.is_16bit_pipeline = bitdepth_y > 8;
+
+#if SVT_AV1_CHECK_VERSION(3, 0, 0)
+  svt_config.lossless = encoder->lossless;
+#endif
+
+  heif_color_profile_nclx* nclx = nullptr;
+  err = heif_image_get_nclx_color_profile(image, &nclx);
+  if (err.code != heif_error_Ok) {
+    nclx = nullptr;
+  }
+
+  // make sure NCLX profile is deleted at end of function
+  auto nclx_deleter = std::unique_ptr<heif_color_profile_nclx, void (*)(heif_color_profile_nclx*)>(nclx, heif_nclx_color_profile_free);
+
+  if (nclx) {
+#if !SVT_AV1_CHECK_VERSION(3, 0, 0)
+    svt_config.color_description_present_flag = true;
+#endif
+#if SVT_AV1_VERSION_MAJOR >= 1
+    svt_config.color_primaries = static_cast<EbColorPrimaries>(nclx->color_primaries);
+    svt_config.transfer_characteristics = static_cast<EbTransferCharacteristics>(nclx->transfer_characteristics);
+    svt_config.matrix_coefficients = static_cast<EbMatrixCoefficients>(nclx->matrix_coefficients);
+    svt_config.color_range = nclx->full_range_flag ? EB_CR_FULL_RANGE : EB_CR_STUDIO_RANGE;
+#else
+    svt_config.color_primaries = static_cast<uint8_t>(nclx->color_primaries);
+    svt_config.transfer_characteristics = static_cast<uint8_t>(nclx->transfer_characteristics);
+    svt_config.matrix_coefficients = static_cast<uint8_t>(nclx->matrix_coefficients);
+    svt_config.color_range = nclx->full_range_flag ? 1 : 0;
+#endif
+
+
+#if !SVT_AV1_CHECK_VERSION(3, 0, 0)
+    // Follow comment in svt header: set if input is HDR10 BT2020 using SMPTE ST2084.
+    svt_config.high_dynamic_range_input = (bitdepth_y == 10 && // TODO: should this be >8 ?
+                                           nclx->color_primaries == heif_color_primaries_ITU_R_BT_2020_2_and_2100_0 &&
+                                           nclx->transfer_characteristics == heif_transfer_characteristic_ITU_R_BT_2100_0_PQ &&
+                                           nclx->matrix_coefficients == heif_matrix_coefficients_ITU_R_BT_2020_2_non_constant_luminance);
+#endif
+  }
+  else {
+#if !SVT_AV1_CHECK_VERSION(3, 0, 0)
+    svt_config.color_description_present_flag = false;
+#endif
+  }
+
+
+  svt_config.source_width = encoded_width;
+  svt_config.source_height = encoded_height;
+#if SVT_AV1_CHECK_VERSION(3, 0, 0)
+  svt_config.level_of_parallelism = encoder->threads;
+#else
+  svt_config.logical_processors = encoder->threads;
+#endif
+
+  // disable 2-pass
+  svt_config.rc_stats_buffer = SvtAv1FixedBuf{nullptr, 0};
+
+  svt_config.rate_control_mode = 0; // constant rate factor
+  //svt_config.enable_adaptive_quantization = 0;   // 2 is CRF (the default), 0 would be CQP
+  int qp;
+  if (encoder->qp_set) {
+    qp = encoder->qp;
+  }
+  else {
+    qp = ((100 - encoder->quality) * 63 + 50) / 100;
+  }
+  svt_config.qp = qp;
+  svt_config.min_qp_allowed = encoder->min_q;
+  svt_config.max_qp_allowed = encoder->max_q;
+
+  svt_config.tile_rows = int_log2(encoder->tile_rows);
+  svt_config.tile_columns = int_log2(encoder->tile_cols);
+
+#if SVT_AV1_CHECK_VERSION(0, 9, 1)
+  svt_config.tune = encoder->tune;
+#endif
+
+  svt_config.enc_mode = (int8_t) encoder->speed;
+
+  if (image_sequence) {
+    // svt_config.force_key_frames = true; TODO: this does not seem to work (see all [1])
+
+#if 1
+    // TODO: setting pref_structure to SVT_AV1_PRED_LOW_DELAY_B hangs the encoder
+
+    switch (options->gop_structure) {
+      case heif_sequence_gop_structure_intra_only:
+        //svt_config.pred_structure = SvtAv1PredStructure::SVT_AV1_PRED_LOW_DELAY_B;
+        break;
+      case heif_sequence_gop_structure_lowdelay:
+        //svt_config.pred_structure = SvtAv1PredStructure::SVT_AV1_PRED_LOW_DELAY_B;
+        break;
+      case heif_sequence_gop_structure_unrestricted:
+        svt_config.pred_structure = SvtAv1PredStructure::SVT_AV1_PRED_RANDOM_ACCESS;
+        break;
+    }
+
+    if (options->keyframe_distance_max) {
+      svt_config.intra_period_length = options->keyframe_distance_max; // TODO -1 ?
+    }
+#endif
+  }
+  else {
+    // TODO: enable when https://gitlab.com/AOMediaCodec/SVT-AV1/-/issues/2245 is resolved
+    // svt_config.avif = true;
+    // encoder->still_image_mode = true;
+  }
+
+  if (color_format == EB_YUV422 || bitdepth_y > 10) {
+    svt_config.profile = PROFESSIONAL_PROFILE;
+  }
+  else if (color_format == EB_YUV444) {
+    svt_config.profile = HIGH_PROFILE;
+  }
+
+  svt_config.frame_rate_numerator = framerate_num;
+  svt_config.frame_rate_denominator = framerate_denom;
+
+  res = svt_av1_enc_set_parameter(svt_encoder, &svt_config);
+  if (res == EB_ErrorBadParameter) {
+    return heif_error_codec_library_error;
+  }
+
+  res = svt_av1_enc_init(svt_encoder);
+  if (res != EB_ErrorNone) {
+    return heif_error_codec_library_error;
+  }
+
+  return {};
+}
+
+
+static heif_error read_encoder_output_packets(void* encoder_raw, bool done_sending_pics)
+{
+  auto* encoder = (encoder_struct_svt*) encoder_raw;
+  EbComponentType*& svt_encoder = encoder->svt_encoder;
+  EbErrorType res = EB_ErrorNone;
+
+
+  // --- read compressed picture
+
+  int encode_at_eos = 0;
+
+  do {
+    EbBufferHeaderType* output_buf = nullptr;
+
+    res = svt_av1_enc_get_packet(svt_encoder, &output_buf, (uint8_t) done_sending_pics);
+    if (output_buf != nullptr) {
+      encode_at_eos = ((output_buf->flags & EB_BUFFERFLAG_EOS) == EB_BUFFERFLAG_EOS);
+      if (output_buf->p_buffer && (output_buf->n_filled_len > 0)) {
+        uint8_t* data = output_buf->p_buffer;
+        uint32_t n = output_buf->n_filled_len;
+
+        encoder_struct_svt::Packet output_packet;
+        output_packet.frameNr = output_buf->pts;
+        output_packet.is_keyframe = (output_buf->pic_type == EbAv1PictureType::EB_AV1_KEY_PICTURE);
+
+        encoder->output_packets.emplace_back(output_packet);
+        encoder->output_packets.back().compressedData.resize(n);
+
+        memcpy(encoder->output_packets.back().compressedData.data(),
+               data, n);
+
+        /* TODO: this is a hack
+         * When using
+         *           svt_config.pred_structure = SvtAv1PredStructure::SVT_AV1_PRED_LOW_DELAY_B;
+         * svt_av1_enc_get_packet() hangs on the second call. As a workaround, we can leave the
+         * loop when we got the image:
+         */
+        if (output_packet.is_keyframe)
+          break;
+      }
+      svt_av1_enc_release_out_buffer(&output_buf);
+    }
+  } while (res == EB_ErrorNone && !encode_at_eos);
+
+
+  // delete input_buffer.p_buffer;
+
+  if (!done_sending_pics && ((res == EB_ErrorNone) || (res == EB_NoErrorEmptyQueue))) {
+    return heif_error_ok;
+  }
+  else {
+    return (res == EB_ErrorNone ? heif_error_ok : heif_error_codec_library_error);
+  }
+}
+
+
+static heif_error svt_encode_sequence_frame(void* encoder_raw, const heif_image* image, uintptr_t frame_nr)
+{
+  auto* encoder = (encoder_struct_svt*) encoder_raw;
+  EbComponentType*& svt_encoder = encoder->svt_encoder;
+  EbErrorType res = EB_ErrorNone;
+
+  int w = heif_image_get_width(image, heif_channel_Y);
+  int h = heif_image_get_height(image, heif_channel_Y);
+  const heif_chroma chroma = heif_image_get_chroma_format(image);
+  int bitdepth_y = heif_image_get_bits_per_pixel_range(image, heif_channel_Y);
+
+  uint32_t encoded_width, encoded_height;
+  svt_query_encoded_size(encoder_raw, w, h, &encoded_width, &encoded_height);
+
+  // Note: it is ok to cast away the const, as the image content is not changed.
+  // However, we have to guarantee that there are no plane pointers or stride values kept over calling the svt_encode_image() function.
+  heif_error err = heif_image_extend_padding_to_size(const_cast<struct heif_image*>(image),
+                                                     (int) encoded_width,
+                                                     (int) encoded_height);
+  if (err.code) {
+    return err;
+  }
+
+
+  uint8_t yShift = 0;
+
+  if (encoder->input_class == heif_image_input_class_alpha) {
+    yShift = 1;
+  }
+  else if (chroma == heif_chroma_420) {
+    yShift = 1;
+  }
+
+
+  // --- copy libheif image to svt image
+
+  EbBufferHeaderType& input_buffer = encoder->input_buffer;
+
+  auto svt_io_format = std::make_unique<EbSvtIOFormat>();
+  input_buffer.p_buffer = (uint8_t*) svt_io_format.get();
+  memset(input_buffer.p_buffer, 0, sizeof(EbSvtIOFormat));
+
+  input_buffer.size = sizeof(EbBufferHeaderType);
+  input_buffer.p_app_private = nullptr;
+  input_buffer.pic_type = EB_AV1_INVALID_PICTURE;
+  input_buffer.metadata = nullptr;
+  input_buffer.pts = frame_nr;
+
+  /* TODO: this does not seem to work (see all [1])
+  if (encoder->keyframe_interval) {
+    if (frame_nr % encoder->keyframe_interval == 0) {
+      input_buffer.pic_type = EB_AV1_KEY_PICTURE;
+    }
+  }
+  */
+
+  auto* input_picture_buffer = (EbSvtIOFormat*) input_buffer.p_buffer;
+
+  int bytesPerPixel = bitdepth_y > 8 ? 2 : 1;
+  std::vector<uint8_t> dummy_color_plane;
+  if (encoder->input_class == heif_image_input_class_alpha) {
+    size_t stride64;
+    input_picture_buffer->luma = (uint8_t*) heif_image_get_plane_readonly2(image, heif_channel_Y, &stride64);
+
+    uint32_t stride32;
+    if (stride64 > std::numeric_limits<uint32_t>::max()) {
+      return {
+        heif_error_Encoder_plugin_error,
+        heif_suberror_Unspecified,
+        "Image too wide for encoder"
+      };
+    }
+    else {
+      stride32 = static_cast<uint32_t>(stride64);
+    }
+
+    input_picture_buffer->y_stride = stride32 / bytesPerPixel;
+    input_buffer.n_filled_len = stride32 * encoded_height;
+
+    uint32_t uvWidth = get_subsampled_size_h(encoded_width, heif_channel_Cb, heif_chroma_420, scaling_mode::round_up);
+    uint32_t uvHeight = get_subsampled_size_v(encoded_height, heif_channel_Cb, heif_chroma_420, scaling_mode::round_up);
+    dummy_color_plane.resize(uvWidth * uvHeight);
+
+    if (bitdepth_y <= 8) {
+      uint8_t val = static_cast<uint8_t>(1 << (bitdepth_y - 1));
+      memset(dummy_color_plane.data(), val, uvWidth * uvHeight * bytesPerPixel);
+    }
+    else {
+      assert(bitdepth_y > 8 && bitdepth_y <= 16);
+      uint16_t val = static_cast<uint16_t>(1 << (bitdepth_y - 1));
+      uint8_t high = static_cast<uint8_t>((val >> 8) & 0xFF);
+      uint8_t low = static_cast<uint8_t>(val & 0xFF);
+
+      for (uint32_t i = 0; i < uvWidth * uvHeight; i++) {
+        dummy_color_plane[2 * i] = low;
+        dummy_color_plane[2 * i + 1] = high;
+      }
+    }
+
+    input_buffer.n_filled_len += 2 * uvWidth * uvHeight;
+    input_picture_buffer->cb_stride = uvWidth;
+    input_picture_buffer->cr_stride = uvWidth;
+
+    input_picture_buffer->cb = dummy_color_plane.data();
+    input_picture_buffer->cr = dummy_color_plane.data();
+  }
+  else {
+    size_t stride64;
+    input_picture_buffer->luma = (uint8_t*) heif_image_get_plane_readonly2(image, heif_channel_Y, &stride64);
+
+    uint32_t stride32;
+    if (stride64 > std::numeric_limits<uint32_t>::max()) {
+      return {
+        heif_error_Encoder_plugin_error,
+        heif_suberror_Unspecified,
+        "Image too wide for encoder"
+      };
+    }
+    else {
+      stride32 = static_cast<uint32_t>(stride64);
+    }
+
+    input_picture_buffer->y_stride = stride32 / bytesPerPixel;
+    input_buffer.n_filled_len = stride32 * encoded_height;
+
+    uint32_t uvHeight = (encoded_height + yShift) >> yShift;
+    input_picture_buffer->cb = (uint8_t*) heif_image_get_plane_readonly2(image, heif_channel_Cb, &stride64);
+    stride32 = static_cast<uint32_t>(stride64); // chroma stride should always be smaller than luma stride
+    input_buffer.n_filled_len += stride32 * uvHeight;
+    input_picture_buffer->cb_stride = stride32 / bytesPerPixel;
+
+    input_picture_buffer->cr = (uint8_t*) heif_image_get_plane_readonly2(image, heif_channel_Cr, &stride64);
+    stride32 = static_cast<uint32_t>(stride64); // chroma stride should always be smaller than luma stride
+    input_buffer.n_filled_len += stride32 * uvHeight;
+    input_picture_buffer->cr_stride = stride32 / bytesPerPixel;
+  }
+
+  input_buffer.flags = 0;
+  // input_buffer.pts = 0;
+
+  EbAv1PictureType frame_type = EB_AV1_KEY_PICTURE;
+
+  input_buffer.pic_type = frame_type;
+
+  res = svt_av1_enc_send_picture(svt_encoder, &input_buffer);
+  if (res != EB_ErrorNone) {
+    delete input_buffer.p_buffer;
+    return heif_error_codec_library_error;
+  }
+
+  return read_encoder_output_packets(encoder_raw, false);
+}
+
+
+static heif_error svt_end_sequence_encoding(void* encoder_raw)
+{
+  auto* encoder = (encoder_struct_svt*) encoder_raw;
+
+  EbComponentType*& svt_encoder = encoder->svt_encoder;
+  //EbBufferHeaderType& input_buffer = encoder->input_buffer;
+
+  // --- flush encoder
+
+  EbErrorType ret = EB_ErrorNone;
+
+  EbBufferHeaderType flush_input_buffer;
+  flush_input_buffer.n_alloc_len = 0;
+  flush_input_buffer.n_filled_len = 0;
+  flush_input_buffer.n_tick_count = 0;
+  flush_input_buffer.p_app_private = nullptr;
+  flush_input_buffer.flags = EB_BUFFERFLAG_EOS;
+  flush_input_buffer.p_buffer = nullptr;
+  flush_input_buffer.metadata = nullptr;
+
+  ret = svt_av1_enc_send_picture(svt_encoder, &flush_input_buffer);
+
+  if (ret != EB_ErrorNone) {
+    // delete input_buffer.p_buffer;
+    return heif_error_codec_library_error;
+  }
+
+  return read_encoder_output_packets(encoder_raw, true);
+}
+
+
+heif_error svt_get_compressed_data2(void* encoder_raw, uint8_t** data, int* size,
+                                    uintptr_t* out_framenr, int* out_is_keyframe,
+                                    int* more_frame_packets)
+{
+  auto* encoder = (encoder_struct_svt*) encoder_raw;
+
+  encoder->active_output_data.clear();
+
+  if (encoder->output_packets.empty()) {
+    *size = 0;
+    *data = nullptr;
+  }
+  else {
+    encoder->active_output_data = std::move(encoder->output_packets.front().compressedData);
+    if (out_framenr) {
+      *out_framenr = encoder->output_packets.front().frameNr;
+    }
+
+    if (out_is_keyframe) {
+      *out_is_keyframe = encoder->output_packets.front().is_keyframe;
+    }
+
+    encoder->output_packets.pop_front();
+
+    *size = (int) encoder->active_output_data.size();
+    *data = encoder->active_output_data.data();
+  }
+
+  return heif_error_ok;
+}
+
+
+heif_error svt_get_compressed_data(void* encoder_raw, uint8_t** data, int* size,
+                                   heif_encoded_data_type* type)
+{
+  return svt_get_compressed_data2(encoder_raw, data, size, nullptr, nullptr, nullptr);
+}
+
+
+static heif_error svt_start_sequence_encoding(void* encoder_raw, const heif_image* image,
+                                              enum heif_image_input_class input_class,
+                                              uint32_t framerate_num, uint32_t framerate_denom,
+                                              const heif_sequence_encoding_options* options)
+{
+  return svt_start_sequence_encoding_intern(encoder_raw, image, input_class,
+                                            framerate_num, framerate_denom, options, true);
+}
+
+
+heif_error svt_encode_image(void* encoder_raw, const heif_image* image,
+                            heif_image_input_class input_class)
+{
+  heif_error err;
+  err = svt_start_sequence_encoding_intern(encoder_raw, image, input_class, 1,25, nullptr, false);
+  if (err.code) {
+    return err;
+  }
+
+  err = svt_encode_sequence_frame(encoder_raw, image, 0);
+  if (err.code) {
+    return err;
+  }
+
+  err = svt_end_sequence_encoding(encoder_raw);
+  if (err.code) {
+    return err;
+  }
+
+  return {};
+}
+
+
+static const heif_encoder_plugin encoder_plugin_svt
+{
+  /* plugin_api_version */ 4,
+                           /* compression_format */ heif_compression_AV1,
+                           /* id_name */ "svt",
+                           /* priority */ SVT_PLUGIN_PRIORITY,
+                           /* supports_lossy_compression */ true,
+#if SVT_AV1_CHECK_VERSION(3, 0, 0)
+                           /* supports_lossless_compression */ true,
+#else
+        /* supports_lossless_compression */ false,
+#endif
+                           /* get_plugin_name */ svt_plugin_name,
+                           /* init_plugin */ svt_init_plugin,
+                           /* cleanup_plugin */ svt_cleanup_plugin,
+                           /* new_encoder */ svt_new_encoder,
+                           /* free_encoder */ svt_free_encoder,
+                           /* set_parameter_quality */ svt_set_parameter_quality,
+                           /* get_parameter_quality */ svt_get_parameter_quality,
+                           /* set_parameter_lossless */ svt_set_parameter_lossless,
+                           /* get_parameter_lossless */ svt_get_parameter_lossless,
+                           /* set_parameter_logging_level */ svt_set_parameter_logging_level,
+                           /* get_parameter_logging_level */ svt_get_parameter_logging_level,
+                           /* list_parameters */ svt_list_parameters,
+                           /* set_parameter_integer */ svt_set_parameter_integer,
+                           /* get_parameter_integer */ svt_get_parameter_integer,
+                           /* set_parameter_boolean */ svt_set_parameter_boolean,
+                           /* get_parameter_boolean */ svt_get_parameter_boolean,
+                           /* set_parameter_string */ svt_set_parameter_string,
+                           /* get_parameter_string */ svt_get_parameter_string,
+                           /* query_input_colorspace */ svt_query_input_colorspace,
+                           /* encode_image */ svt_encode_image,
+                           /* get_compressed_data */ svt_get_compressed_data,
+                           /* query_input_colorspace (v2) */ svt_query_input_colorspace2,
+                           /* query_encoded_size (v3) */ svt_query_encoded_size,
+                           /* minimum_required_libheif_version */ LIBHEIF_MAKE_VERSION(1,21,0),
+                           /* start_sequence_encoding (v4) */ svt_start_sequence_encoding,
+                           /* encode_sequence_frame (v4) */ svt_encode_sequence_frame,
+                           /* end_sequence_encoding (v4) */ svt_end_sequence_encoding,
+                           /* get_compressed_data2 (v4) */ svt_get_compressed_data2,
+                           /* does_indicate_keyframes (v4) */ 1
+};
+
+const heif_encoder_plugin* get_encoder_plugin_svt()
+{
+  return &encoder_plugin_svt;
+}
+
+
+#if PLUGIN_SvtEnc
+heif_plugin_info plugin_info{
+    1,
+    heif_plugin_type_encoder,
+    &encoder_plugin_svt
+};
+#endif
diff --git a/libheif/plugins/encoder_svt.h b/libheif/plugins/encoder_svt.h
new file mode 100644
index 0000000000..461b575bf0
--- /dev/null
+++ b/libheif/plugins/encoder_svt.h
@@ -0,0 +1,34 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2022 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_ENCODER_SVT_H
+#define LIBHEIF_ENCODER_SVT_H
+
+#include "common_utils.h"
+
+const struct heif_encoder_plugin* get_encoder_plugin_svt();
+
+#if PLUGIN_SvtEnc
+extern "C" {
+MAYBE_UNUSED LIBHEIF_API extern heif_plugin_info plugin_info;
+}
+#endif
+
+#endif
diff --git a/libheif/plugins/encoder_uncompressed.cc b/libheif/plugins/encoder_uncompressed.cc
new file mode 100644
index 0000000000..05ab23912a
--- /dev/null
+++ b/libheif/plugins/encoder_uncompressed.cc
@@ -0,0 +1,370 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "encoder_uncompressed.h"
+#include "libheif/heif.h"
+#include "libheif/heif_plugin.h"
+#include <algorithm>
+#include <cstring>
+#include <cassert>
+#include <vector>
+#include <string>
+#include <memory>
+
+#include <mutex>
+
+
+static const char* kParam_interleave = "interleave";
+
+static const int PLUGIN_PRIORITY = 60;
+
+static const char* plugin_name = "builtin";
+
+
+static void uncompressed_set_default_parameters(void* encoder);
+
+
+static const char* uncompressed_plugin_name()
+{
+  return plugin_name;
+}
+
+
+#define MAX_NPARAMETERS 14
+
+static heif_encoder_parameter uncompressed_encoder_params[MAX_NPARAMETERS];
+static const heif_encoder_parameter* uncompressed_encoder_parameter_ptrs[MAX_NPARAMETERS + 1];
+
+static void uncompressed_init_parameters()
+{
+  heif_encoder_parameter* p = uncompressed_encoder_params;
+  const heif_encoder_parameter** d = uncompressed_encoder_parameter_ptrs;
+  int i = 0;
+
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = kParam_interleave;
+  p->type = heif_encoder_parameter_type_string;
+  p->string.default_value = "planar";
+  p->has_default = true;
+  d[i++] = p++;
+
+  assert(i < MAX_NPARAMETERS + 1);
+  d[i++] = nullptr;
+}
+
+
+const heif_encoder_parameter** uncompressed_list_parameters(void* encoder)
+{
+  return uncompressed_encoder_parameter_ptrs;
+}
+
+static void uncompressed_init_plugin()
+{
+  uncompressed_init_parameters();
+}
+
+
+static void uncompressed_cleanup_plugin()
+{
+}
+
+heif_error uncompressed_new_encoder(void** enc)
+{
+  encoder_struct_uncompressed* encoder = new encoder_struct_uncompressed();
+  heif_error err = heif_error_ok;
+
+  *enc = encoder;
+
+  // set default parameters
+
+  uncompressed_set_default_parameters(encoder);
+
+  return err;
+}
+
+void uncompressed_free_encoder(void* encoder_raw)
+{
+  encoder_struct_uncompressed* encoder = (encoder_struct_uncompressed*) encoder_raw;
+
+  delete encoder;
+}
+
+
+heif_error uncompressed_set_parameter_quality(void* encoder_raw, int quality)
+{
+  //struct encoder_struct_uncompressed* encoder = (struct encoder_struct_uncompressed*) encoder_raw;
+
+  return heif_error_ok;
+}
+
+heif_error uncompressed_get_parameter_quality(void* encoder_raw, int* quality)
+{
+  *quality = 100;
+
+  return heif_error_ok;
+}
+
+heif_error uncompressed_set_parameter_lossless(void* encoder_raw, int enable)
+{
+  return heif_error_ok;
+}
+
+heif_error uncompressed_get_parameter_lossless(void* encoder_raw, int* enable)
+{
+  //struct encoder_struct_uncompressed* encoder = (struct encoder_struct_uncompressed*) encoder_raw;
+
+  *enable = true;
+
+  return heif_error_ok;
+}
+
+heif_error uncompressed_set_parameter_logging_level(void* encoder_raw, int logging)
+{
+#if 0
+  struct encoder_struct_x265* encoder = (struct encoder_struct_x265*)encoder_raw;
+
+  if (logging<0 || logging>4) {
+    return heif_error_invalid_parameter_value;
+  }
+
+  encoder->logLevel = logging;
+#endif
+
+  return heif_error_ok;
+}
+
+heif_error uncompressed_get_parameter_logging_level(void* encoder_raw, int* loglevel)
+{
+#if 0
+  struct encoder_struct_x265* encoder = (struct encoder_struct_x265*)encoder_raw;
+
+  *loglevel = encoder->logLevel;
+#else
+  *loglevel = 0;
+#endif
+
+  return heif_error_ok;
+}
+
+#define set_value(paramname, paramvar) if (strcmp(name, paramname)==0) { encoder->paramvar = value; return heif_error_ok; }
+#define get_value(paramname, paramvar) if (strcmp(name, paramname)==0) { *value = encoder->paramvar; return heif_error_ok; }
+
+
+heif_error uncompressed_set_parameter_integer(void* encoder_raw, const char* name, int value)
+{
+  //struct encoder_struct_uncompressed* encoder = (struct encoder_struct_uncompressed*) encoder_raw;
+
+  return heif_error_unsupported_parameter;
+}
+
+heif_error uncompressed_get_parameter_integer(void* encoder_raw, const char* name, int* value)
+{
+  //struct encoder_struct_uncompressed* encoder = (struct encoder_struct_uncompressed*) encoder_raw;
+
+  return heif_error_unsupported_parameter;
+}
+
+
+heif_error uncompressed_set_parameter_boolean(void* encoder_raw, const char* name, int value)
+{
+  //struct encoder_struct_uncompressed* encoder = (struct encoder_struct_uncompressed*) encoder_raw;
+
+  return heif_error_unsupported_parameter;
+}
+
+heif_error uncompressed_get_parameter_boolean(void* encoder_raw, const char* name, int* value)
+{
+  //struct encoder_struct_uncompressed* encoder = (struct encoder_struct_uncompressed*) encoder_raw;
+
+  return heif_error_unsupported_parameter;
+}
+
+
+heif_error uncompressed_set_parameter_string(void* encoder_raw, const char* name, const char* value)
+{
+  //struct encoder_struct_uncompressed* encoder = (struct encoder_struct_uncompressed*) encoder_raw;
+
+  return heif_error_unsupported_parameter;
+}
+
+
+heif_error uncompressed_get_parameter_string(void* encoder_raw, const char* name,
+                                             char* value, int value_size)
+{
+  //struct encoder_struct_uncompressed* encoder = (struct encoder_struct_uncompressed*) encoder_raw;
+
+  return heif_error_unsupported_parameter;
+}
+
+
+static void uncompressed_set_default_parameters(void* encoder)
+{
+  for (const heif_encoder_parameter** p = uncompressed_encoder_parameter_ptrs; *p; p++) {
+    const heif_encoder_parameter* param = *p;
+
+    if (param->has_default) {
+      switch (param->type) {
+        case heif_encoder_parameter_type_integer:
+          uncompressed_set_parameter_integer(encoder, param->name, param->integer.default_value);
+          break;
+        case heif_encoder_parameter_type_boolean:
+          uncompressed_set_parameter_boolean(encoder, param->name, param->boolean.default_value);
+          break;
+        case heif_encoder_parameter_type_string:
+          uncompressed_set_parameter_string(encoder, param->name, param->string.default_value);
+          break;
+      }
+    }
+  }
+}
+
+
+void uncompressed_query_input_colorspace(heif_colorspace* colorspace, heif_chroma* chroma)
+{
+  //*colorspace = heif_colorspace_YCbCr;
+  //*chroma = heif_chroma_420;
+}
+
+
+void uncompressed_query_input_colorspace2(void* encoder_raw, heif_colorspace* colorspace, heif_chroma* chroma)
+{
+  //struct encoder_struct_uncompressed* encoder = (struct encoder_struct_uncompressed*) encoder_raw;
+
+  if (*colorspace == heif_colorspace_monochrome) {
+    // keep the monochrome colorspace
+  }
+  else {
+    //*colorspace = heif_colorspace_YCbCr;
+    //*chroma = encoder->chroma;
+  }
+}
+
+
+heif_error uncompressed_encode_image(void* encoder_raw, const heif_image* image,
+                                     heif_image_input_class input_class)
+{
+  //struct encoder_struct_uncompressed* encoder = (struct encoder_struct_uncompressed*) encoder_raw;
+
+  // Note: this is not used. It is a dummy plugin.
+
+  return heif_error_ok;
+}
+
+
+heif_error uncompressed_get_compressed_data(void* encoder_raw, uint8_t** data, int* size,
+                                            heif_encoded_data_type* type)
+{
+#if 0
+  struct encoder_struct_uncompressed* encoder = (struct encoder_struct_uncompressed*) encoder_raw;
+
+  if (encoder->data_read) {
+    *size = 0;
+    *data = nullptr;
+  }
+  else {
+    *size = (int) encoder->compressedData.size();
+    *data = encoder->compressedData.data();
+    encoder->data_read = true;
+  }
+#endif
+
+  return heif_error_ok;
+}
+
+
+heif_error uncompressed_start_sequence_encoding(void* encoder, const heif_image* image,
+                                                enum heif_image_input_class image_class,
+                                                uint32_t framerate_num, uint32_t framerate_denom,
+                                                const heif_sequence_encoding_options* options)
+{
+  return heif_error_ok;
+}
+
+heif_error uncompressed_encode_sequence_frame(void* encoder, const heif_image* image, uintptr_t frame_nr)
+{
+  return heif_error_ok;
+}
+
+heif_error uncompressed_end_sequence_encoding(void* encoder)
+{
+  return heif_error_ok;
+}
+
+heif_error uncompressed_get_compressed_data2(void* encoder, uint8_t** data, int* size,
+                                             uintptr_t* frame_nr,
+                                             int* is_keyframe, int* more_frame_packets)
+{
+  return heif_error_ok;
+}
+
+
+static const heif_encoder_plugin encoder_plugin_uncompressed
+    {
+        /* plugin_api_version */ 4,
+        /* compression_format */ heif_compression_uncompressed,
+        /* id_name */ "uncompressed",
+        /* priority */ PLUGIN_PRIORITY,
+        /* supports_lossy_compression */ true,
+        /* supports_lossless_compression */ true,
+        /* get_plugin_name */ uncompressed_plugin_name,
+        /* init_plugin */ uncompressed_init_plugin,
+        /* cleanup_plugin */ uncompressed_cleanup_plugin,
+        /* new_encoder */ uncompressed_new_encoder,
+        /* free_encoder */ uncompressed_free_encoder,
+        /* set_parameter_quality */ uncompressed_set_parameter_quality,
+        /* get_parameter_quality */ uncompressed_get_parameter_quality,
+        /* set_parameter_lossless */ uncompressed_set_parameter_lossless,
+        /* get_parameter_lossless */ uncompressed_get_parameter_lossless,
+        /* set_parameter_logging_level */ uncompressed_set_parameter_logging_level,
+        /* get_parameter_logging_level */ uncompressed_get_parameter_logging_level,
+        /* list_parameters */ uncompressed_list_parameters,
+        /* set_parameter_integer */ uncompressed_set_parameter_integer,
+        /* get_parameter_integer */ uncompressed_get_parameter_integer,
+        /* set_parameter_boolean */ uncompressed_set_parameter_boolean,
+        /* get_parameter_boolean */ uncompressed_get_parameter_boolean,
+        /* set_parameter_string */ uncompressed_set_parameter_string,
+        /* get_parameter_string */ uncompressed_get_parameter_string,
+        /* query_input_colorspace */ uncompressed_query_input_colorspace,
+        /* encode_image */ uncompressed_encode_image,
+        /* get_compressed_data */ uncompressed_get_compressed_data,
+        /* query_input_colorspace (v2) */ uncompressed_query_input_colorspace2,
+        /* query_encoded_size (v3) */ nullptr,
+        /* minimum_required_libheif_version */ LIBHEIF_MAKE_VERSION(1,21,0),
+        /* start_sequence_encoding (v4) */ uncompressed_start_sequence_encoding,
+        /* encode_sequence_frame (v4) */ uncompressed_encode_sequence_frame,
+        /* end_sequence_encoding (v4) */ uncompressed_end_sequence_encoding,
+        /* get_compressed_data2 (v4) */ uncompressed_get_compressed_data2,
+        /* does_indicate_keyframes (v4) */ 1
+    };
+
+const heif_encoder_plugin* get_encoder_plugin_uncompressed()
+{
+  return &encoder_plugin_uncompressed;
+}
+
+
+#if 0 // PLUGIN_uncompressed_ENCODER
+heif_plugin_info plugin_info {
+  1,
+  heif_plugin_type_encoder,
+  &encoder_plugin_uncompressed
+};
+#endif
diff --git a/libheif/plugins/encoder_uncompressed.h b/libheif/plugins/encoder_uncompressed.h
new file mode 100644
index 0000000000..4cfc59986f
--- /dev/null
+++ b/libheif/plugins/encoder_uncompressed.h
@@ -0,0 +1,55 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_ENCODER_UNCOMPRESSED_H
+#define LIBHEIF_ENCODER_UNCOMPRESSED_H
+
+#include "common_utils.h"
+
+// This is a dummy module. It does not actually do anything except parameter parsing.
+// The actual codec is included in the library.
+
+struct encoder_struct_uncompressed
+{
+  // --- parameters
+
+  enum class InterleaveFormat
+  {
+    Planar, Row, Pixel
+  };
+
+  InterleaveFormat interleaveFormat = InterleaveFormat::Planar;
+
+  // --- output
+
+  //bool data_read = false;
+  //std::vector<uint8_t> compressedData;
+};
+
+
+const struct heif_encoder_plugin* get_encoder_plugin_uncompressed();
+
+#if 0 // PLUGIN_UNCOMPRESSED
+extern "C" {
+MAYBE_UNUSED LIBHEIF_API extern heif_plugin_info plugin_info;
+}
+#endif
+
+#endif //LIBHEIF_ENCODER_UNCOMPRESSED_H
diff --git a/libheif/plugins/encoder_uvg266.cc b/libheif/plugins/encoder_uvg266.cc
new file mode 100644
index 0000000000..90ff2d2eb1
--- /dev/null
+++ b/libheif/plugins/encoder_uvg266.cc
@@ -0,0 +1,939 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "libheif/heif.h"
+#include "libheif/heif_plugin.h"
+#include "encoder_uvg266.h"
+#include <memory>
+#include <string>   // apparently, this is a false positive of cpplint
+#include <cstring>
+#include <cassert>
+#include <vector>
+#include <algorithm>
+#include <deque>
+#include <iostream>
+
+#include "logging.h"
+#include "nalu_utils.h"
+#include <utility>
+
+extern "C" {
+#include <uvg266.h>
+}
+
+
+static const char* kError_unspecified_error = "Unspecified encoder error";
+static const char* kError_unsupported_bit_depth = "Bit depth not supported by uvg266";
+static const char* kError_unsupported_chroma = "Unsupported chroma type";
+//static const char* kError_unsupported_image_size = "Images smaller than 16 pixels are not supported";
+
+
+struct encoder_struct_uvg266
+{
+  int quality = 75;
+  bool lossless = false;
+
+  // --- encoder
+
+  const uvg_api* api = nullptr;
+  uvg_config* config = nullptr;
+  uvg_encoder* kvzencoder = nullptr;
+
+  uvg_chroma_format kvzChroma;
+  int chroma_stride_shift = 0;
+  int chroma_height_shift = 0;
+  int input_chroma_width = 0;
+  int input_chroma_height = 0;
+
+  // --- output data
+
+  //std::vector<uint8_t> output_data;
+  //size_t output_idx = 0;
+
+  struct Packet
+  {
+    std::vector<uint8_t> data;
+    uintptr_t frameNr = 0;
+    bool more_nals = false;
+  };
+
+  std::deque<Packet> output_data;
+
+  std::vector<uint8_t> active_data; // holds the data that we just returned
+
+  void append_chunk_data(uvg_data_chunk* data, int framenr);
+
+  ~encoder_struct_uvg266()
+  {
+    if (kvzencoder) {
+      api->encoder_close(kvzencoder);
+    }
+
+    if (config) {
+      api->config_destroy(config);
+    }
+  }
+};
+
+static const int uvg266_PLUGIN_PRIORITY = 50;
+
+#define MAX_PLUGIN_NAME_LENGTH 80
+
+static char plugin_name[MAX_PLUGIN_NAME_LENGTH];
+
+
+static void uvg266_set_default_parameters(void* encoder);
+
+
+static const char* uvg266_plugin_name()
+{
+  strcpy(plugin_name, "uvg266 VVC encoder");
+  return plugin_name;
+}
+
+
+#define MAX_NPARAMETERS 10
+
+static heif_encoder_parameter uvg266_encoder_params[MAX_NPARAMETERS];
+static const heif_encoder_parameter* uvg266_encoder_parameter_ptrs[MAX_NPARAMETERS + 1];
+
+static void uvg266_init_parameters()
+{
+  heif_encoder_parameter* p = uvg266_encoder_params;
+  const heif_encoder_parameter** d = uvg266_encoder_parameter_ptrs;
+  int i = 0;
+
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = heif_encoder_parameter_name_quality;
+  p->type = heif_encoder_parameter_type_integer;
+  p->integer.default_value = 50;
+  p->has_default = true;
+  p->integer.have_minimum_maximum = true;
+  p->integer.minimum = 0;
+  p->integer.maximum = 100;
+  p->integer.valid_values = NULL;
+  p->integer.num_valid_values = 0;
+  d[i++] = p++;
+
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = heif_encoder_parameter_name_lossless;
+  p->type = heif_encoder_parameter_type_boolean;
+  p->boolean.default_value = false;
+  p->has_default = true;
+  d[i++] = p++;
+
+  d[i++] = nullptr;
+}
+
+
+const heif_encoder_parameter** uvg266_list_parameters(void* encoder)
+{
+  return uvg266_encoder_parameter_ptrs;
+}
+
+
+static void uvg266_init_plugin()
+{
+  uvg266_init_parameters();
+}
+
+
+static void uvg266_cleanup_plugin()
+{
+}
+
+
+static heif_error uvg266_new_encoder(void** enc)
+{
+  encoder_struct_uvg266* encoder = new encoder_struct_uvg266();
+  heif_error err = heif_error_ok;
+
+  *enc = encoder;
+
+  // set default parameters
+
+  uvg266_set_default_parameters(encoder);
+
+  return err;
+}
+
+static void uvg266_free_encoder(void* encoder_raw)
+{
+  struct encoder_struct_uvg266* encoder = (encoder_struct_uvg266*) encoder_raw;
+
+  delete encoder;
+}
+
+static heif_error uvg266_set_parameter_quality(void* encoder_raw, int quality)
+{
+  encoder_struct_uvg266* encoder = (encoder_struct_uvg266*) encoder_raw;
+
+  if (quality < 0 || quality > 100) {
+    return heif_error_invalid_parameter_value;
+  }
+
+  encoder->quality = quality;
+
+  return heif_error_ok;
+}
+
+static heif_error uvg266_get_parameter_quality(void* encoder_raw, int* quality)
+{
+  encoder_struct_uvg266* encoder = (encoder_struct_uvg266*) encoder_raw;
+
+  *quality = encoder->quality;
+
+  return heif_error_ok;
+}
+
+static heif_error uvg266_set_parameter_lossless(void* encoder_raw, int enable)
+{
+  encoder_struct_uvg266* encoder = (encoder_struct_uvg266*) encoder_raw;
+
+  encoder->lossless = enable ? 1 : 0;
+
+  return heif_error_ok;
+}
+
+static heif_error uvg266_get_parameter_lossless(void* encoder_raw, int* enable)
+{
+  encoder_struct_uvg266* encoder = (encoder_struct_uvg266*) encoder_raw;
+
+  *enable = encoder->lossless;
+
+  return heif_error_ok;
+}
+
+static heif_error uvg266_set_parameter_logging_level(void* encoder_raw, int logging)
+{
+//  struct encoder_struct_uvg266* encoder = (struct encoder_struct_uvg266*) encoder_raw;
+
+// return heif_error_invalid_parameter_value;
+
+  return heif_error_ok;
+}
+
+static heif_error uvg266_get_parameter_logging_level(void* encoder_raw, int* loglevel)
+{
+//  struct encoder_struct_uvg266* encoder = (struct encoder_struct_uvg266*) encoder_raw;
+
+  *loglevel = 0;
+
+  return heif_error_ok;
+}
+
+
+static heif_error uvg266_set_parameter_integer(void* encoder_raw, const char* name, int value)
+{
+  encoder_struct_uvg266* encoder = (encoder_struct_uvg266*) encoder_raw;
+
+  if (strcmp(name, heif_encoder_parameter_name_quality) == 0) {
+    return uvg266_set_parameter_quality(encoder, value);
+  }
+  else if (strcmp(name, heif_encoder_parameter_name_lossless) == 0) {
+    return uvg266_set_parameter_lossless(encoder, value);
+  }
+
+  return heif_error_unsupported_parameter;
+}
+
+static heif_error uvg266_get_parameter_integer(void* encoder_raw, const char* name, int* value)
+{
+  encoder_struct_uvg266* encoder = (encoder_struct_uvg266*) encoder_raw;
+
+  if (strcmp(name, heif_encoder_parameter_name_quality) == 0) {
+    return uvg266_get_parameter_quality(encoder, value);
+  }
+  else if (strcmp(name, heif_encoder_parameter_name_lossless) == 0) {
+    return uvg266_get_parameter_lossless(encoder, value);
+  }
+
+  return heif_error_unsupported_parameter;
+}
+
+
+static heif_error uvg266_set_parameter_boolean(void* encoder, const char* name, int value)
+{
+  if (strcmp(name, heif_encoder_parameter_name_lossless) == 0) {
+    return uvg266_set_parameter_lossless(encoder, value);
+  }
+
+  return heif_error_unsupported_parameter;
+}
+
+// Unused, will use "uvg266_get_parameter_integer" instead.
+/*
+static struct heif_error uvg266_get_parameter_boolean(void* encoder, const char* name, int* value)
+{
+  if (strcmp(name, heif_encoder_parameter_name_lossless)==0) {
+    return uvg266_get_parameter_lossless(encoder,value);
+  }
+
+  return heif_error_unsupported_parameter;
+}
+*/
+
+
+static heif_error uvg266_set_parameter_string(void* encoder_raw, const char* name, const char* value)
+{
+  return heif_error_unsupported_parameter;
+}
+
+static heif_error uvg266_get_parameter_string(void* encoder_raw, const char* name,
+                                              char* value, int value_size)
+{
+  return heif_error_unsupported_parameter;
+}
+
+
+static void uvg266_set_default_parameters(void* encoder)
+{
+  for (const heif_encoder_parameter** p = uvg266_encoder_parameter_ptrs; *p; p++) {
+    const heif_encoder_parameter* param = *p;
+
+    if (param->has_default) {
+      switch (param->type) {
+        case heif_encoder_parameter_type_integer:
+          uvg266_set_parameter_integer(encoder, param->name, param->integer.default_value);
+          break;
+        case heif_encoder_parameter_type_boolean:
+          uvg266_set_parameter_boolean(encoder, param->name, param->boolean.default_value);
+          break;
+        case heif_encoder_parameter_type_string:
+          uvg266_set_parameter_string(encoder, param->name, param->string.default_value);
+          break;
+      }
+    }
+  }
+}
+
+
+static void uvg266_query_input_colorspace(heif_colorspace* colorspace, heif_chroma* chroma)
+{
+  if (*colorspace == heif_colorspace_monochrome) {
+    *colorspace = heif_colorspace_monochrome;
+    *chroma = heif_chroma_monochrome;
+  }
+  else {
+    *colorspace = heif_colorspace_YCbCr;
+    *chroma = heif_chroma_420;
+  }
+}
+
+
+static void uvg266_query_input_colorspace2(void* encoder_raw, heif_colorspace* colorspace, heif_chroma* chroma)
+{
+  if (*colorspace == heif_colorspace_monochrome) {
+    *colorspace = heif_colorspace_monochrome;
+    *chroma = heif_chroma_monochrome;
+  }
+  else {
+    *colorspace = heif_colorspace_YCbCr;
+    if (*chroma != heif_chroma_420 &&
+        *chroma != heif_chroma_422 &&
+        *chroma != heif_chroma_444) {
+      *chroma = heif_chroma_420;
+    }
+  }
+}
+
+void uvg266_query_encoded_size(void* encoder_raw, uint32_t input_width, uint32_t input_height,
+                               uint32_t* encoded_width, uint32_t* encoded_height)
+{
+  *encoded_width = (input_width + 7) & ~0x7;
+  *encoded_height = (input_height + 7) & ~0x7;
+}
+
+
+#if 0
+static int rounded_size(int s)
+{
+  s = (s + 1) & ~1;
+
+  if (s < 64) {
+    s = 64;
+  }
+
+  return s;
+}
+#endif
+
+void encoder_struct_uvg266::append_chunk_data(uvg_data_chunk* data, int framenr)
+{
+  if (!data || data->len == 0) {
+    return;
+  }
+
+  std::vector<uint8_t> input_data;
+  while (data) {
+    input_data.insert(input_data.end(), data->data, data->data + data->len);
+    data = data->next;
+  }
+
+#if 0
+  std::cout << "DATA\n";
+  std::cout << write_raw_data_as_hex(input_data.data(), input_data.size(), {}, {});
+  std::cout << "---\n";
+#endif
+
+  //std::vector<uint8_t>& pktdata = encoder->output_data.front().data;
+  size_t start_idx = 0;
+
+  for (;;)
+  {
+    while (start_idx < input_data.size() - 3 &&
+           (input_data[start_idx] != 0 ||
+            input_data[start_idx + 1] != 0 ||
+            input_data[start_idx + 2] != 1)) {
+      start_idx++;
+            }
+
+    size_t end_idx = start_idx + 1;
+
+    while (end_idx < input_data.size() - 3 &&
+           (input_data[end_idx] != 0 ||
+            input_data[end_idx + 1] != 0 ||
+            input_data[end_idx + 2] != 1)) {
+      end_idx++;
+            }
+
+    if (end_idx == input_data.size() - 3) {
+      end_idx = input_data.size();
+    }
+
+    encoder_struct_uvg266::Packet pkt;
+    pkt.data.resize(end_idx - start_idx - 3);
+    memcpy(pkt.data.data(), input_data.data() + start_idx + 3, pkt.data.size());
+    pkt.frameNr = framenr;
+    pkt.more_nals = true; // will be set to 'false' for last NAL below
+
+    // uint8_t nal_type = (pkt.data[1] >> 3);
+    // std::cout << "append frameNr=" << framenr << " NAL:" << ((int)nal_type) << " size:" << pkt.data.size() << "\n";
+
+    output_data.emplace_back(std::move(pkt));
+
+    if (end_idx == input_data.size()) {
+      break;
+    }
+
+    start_idx = end_idx;
+  }
+
+  if (!output_data.empty()) {
+    output_data.back().more_nals = false;
+  }
+}
+
+
+static void copy_plane(uvg_pixel* out_p, size_t out_stride, const uint8_t* in_p, size_t in_stride, int w, int h, int padded_width, int padded_height)
+{
+  for (int y = 0; y < padded_height; y++) {
+    int sy = std::min(y, h - 1); // source y
+    memcpy(out_p + y * out_stride, in_p + sy * in_stride, w);
+
+    if (padded_width > w) {
+      memset(out_p + y * out_stride + w, *(in_p + sy * in_stride + w - 1), padded_width - w);
+    }
+  }
+}
+
+
+static heif_error uvg266_start_sequence_encoding_intern(void* encoder_raw, const heif_image* image,
+                                                        heif_image_input_class input_class,
+                                                        uint32_t framerate_num, uint32_t framerate_denom,
+                                                        const heif_sequence_encoding_options* options,
+                                                        bool image_sequence)
+{
+  encoder_struct_uvg266* encoder = (encoder_struct_uvg266*) encoder_raw;
+
+  int bit_depth = heif_image_get_bits_per_pixel_range(image, heif_channel_Y);
+
+  const uvg_api* api = uvg_api_get(bit_depth);
+  if (api == nullptr) {
+    return {
+      heif_error_Encoder_plugin_error,
+      heif_suberror_Unsupported_bit_depth,
+      kError_unsupported_bit_depth
+    };
+  }
+
+  encoder->api = api;
+
+  uvg_config* config = api->config_alloc();
+  api->config_init(config); // param, encoder->preset.c_str(), encoder->tune.c_str());
+
+  encoder->config = config;
+
+#if HAVE_UVG266_ENABLE_LOGGING
+  config->enable_logging_output = 0;
+#endif
+
+#if !ENABLE_MULTITHREADING_SUPPORT
+  // 0: Process everything with main thread
+  // -1 (default): Select automatically.
+  config->threads = 0;
+#endif
+
+  bool isGreyscale = (heif_image_get_colorspace(image) == heif_colorspace_monochrome);
+  heif_chroma chroma = heif_image_get_chroma_format(image);
+
+  int input_width = heif_image_get_width(image, heif_channel_Y);
+  int input_height = heif_image_get_height(image, heif_channel_Y);
+
+  if (isGreyscale) {
+    config->input_format = UVG_FORMAT_P400;
+    encoder->kvzChroma = UVG_CSP_400;
+  }
+  else if (chroma == heif_chroma_420) {
+    config->input_format = UVG_FORMAT_P420;
+    encoder->kvzChroma = UVG_CSP_420;
+    encoder->chroma_stride_shift = 1;
+    encoder->chroma_height_shift = 1;
+    encoder->input_chroma_width = (input_width + 1) / 2;
+    encoder->input_chroma_height = (input_height + 1) / 2;
+  }
+  else if (chroma == heif_chroma_422) {
+    config->input_format = UVG_FORMAT_P422;
+    encoder->kvzChroma = UVG_CSP_422;
+    encoder->chroma_stride_shift = 1;
+    encoder->chroma_height_shift = 0;
+    encoder->input_chroma_width = (input_width + 1) / 2;
+    encoder->input_chroma_height = input_height;
+  }
+  else if (chroma == heif_chroma_444) {
+    config->input_format = UVG_FORMAT_P444;
+    encoder->kvzChroma = UVG_CSP_444;
+    encoder->chroma_stride_shift = 0;
+    encoder->chroma_height_shift = 0;
+    encoder->input_chroma_width = input_width;
+    encoder->input_chroma_height = input_height;
+  }
+  else {
+    return heif_error{
+      heif_error_Encoder_plugin_error,
+      heif_suberror_Unsupported_image_type,
+      kError_unsupported_chroma
+    };
+  }
+
+  if (chroma != heif_chroma_monochrome) {
+    int w = heif_image_get_width(image, heif_channel_Y);
+    int h = heif_image_get_height(image, heif_channel_Y);
+    if (chroma != heif_chroma_444) { w = (w + 1) / 2; }
+    if (chroma == heif_chroma_420) { h = (h + 1) / 2; }
+
+    assert(heif_image_get_width(image, heif_channel_Cb) == w);
+    assert(heif_image_get_width(image, heif_channel_Cr) == w);
+    assert(heif_image_get_height(image, heif_channel_Cb) == h);
+    assert(heif_image_get_height(image, heif_channel_Cr) == h);
+    (void) w;
+    (void) h;
+  }
+
+  heif_color_profile_nclx* nclx = nullptr;
+  heif_error err = heif_image_get_nclx_color_profile(image, &nclx);
+  if (err.code != heif_error_Ok) {
+    nclx = nullptr;
+  }
+
+  // make sure NCLX profile is deleted at end of function
+  auto nclx_deleter = std::unique_ptr<heif_color_profile_nclx, void (*)(heif_color_profile_nclx*)>(nclx, heif_nclx_color_profile_free);
+
+  if (nclx) {
+    config->vui.fullrange = nclx->full_range_flag;
+  }
+  else {
+    config->vui.fullrange = 1;
+  }
+
+  if (nclx &&
+      (input_class == heif_image_input_class_normal ||
+       input_class == heif_image_input_class_thumbnail)) {
+    config->vui.colorprim = nclx->color_primaries;
+    config->vui.transfer = nclx->transfer_characteristics;
+    config->vui.colormatrix = nclx->matrix_coefficients;
+  }
+
+  config->qp = ((100 - encoder->quality) * 51 + 50) / 100;
+  config->lossless = encoder->lossless ? 1 : 0;
+
+  if (image_sequence) {
+    if (options->keyframe_distance_max) {
+      config->intra_period = options->keyframe_distance_max;
+    }
+
+    switch (options->gop_structure) {
+      case heif_sequence_gop_structure_intra_only:
+        config->intra_period = 1;
+        break;
+      case heif_sequence_gop_structure_lowdelay:
+        config->gop_lowdelay = 1;
+        break;
+      case heif_sequence_gop_structure_unrestricted:
+        break;
+    }
+  }
+
+  config->framerate_num = framerate_num;
+  config->framerate_denom = framerate_denom;
+
+  uint32_t encoded_width, encoded_height;
+  uvg266_query_encoded_size(encoder_raw, input_width, input_height, &encoded_width, &encoded_height);
+
+  config->width = encoded_width;
+  config->height = encoded_height;
+
+  uvg_encoder* kvzencoder = api->encoder_open(config);
+  if (!kvzencoder) {
+    return heif_error{
+      heif_error_Encoder_plugin_error,
+      heif_suberror_Encoder_encoding,
+      kError_unspecified_error
+    };
+  }
+
+  encoder->kvzencoder = kvzencoder;
+
+  return heif_error_ok;
+}
+
+
+static heif_error uvg266_encode_sequence_frame(void* encoder_raw, const heif_image* image,
+                                               uintptr_t framenr)
+{
+  encoder_struct_uvg266* encoder = (encoder_struct_uvg266*) encoder_raw;
+
+  bool isGreyscale = (heif_image_get_colorspace(image) == heif_colorspace_monochrome);
+
+  int input_width = heif_image_get_width(image, heif_channel_Y);
+  int input_height = heif_image_get_height(image, heif_channel_Y);
+
+  uint32_t encoded_width, encoded_height;
+  uvg266_query_encoded_size(encoder_raw, input_width, input_height, &encoded_width, &encoded_height);
+
+  // Note: it is ok to cast away the const, as the image content is not changed.
+  // However, we have to guarantee that there are no plane pointers or stride values kept over calling the svt_encode_image() function.
+  /*
+  err = heif_image_extend_padding_to_size(const_cast<struct heif_image*>(image),
+                                          param->sourceWidth,
+                                          param->sourceHeight);
+  if (err.code) {
+    return err;
+  }
+*/
+
+  uvg_picture* pic = encoder->api->picture_alloc_csp(encoder->kvzChroma, encoded_width, encoded_height);
+  if (!pic) {
+    return heif_error{
+        heif_error_Encoder_plugin_error,
+        heif_suberror_Encoder_encoding,
+        kError_unspecified_error
+    };
+  }
+
+  if (isGreyscale) {
+    size_t stride;
+    const uint8_t* data = heif_image_get_plane_readonly2(image, heif_channel_Y, &stride);
+
+    copy_plane(pic->y, pic->stride, data, stride, input_width, input_height, encoded_width, encoded_height);
+  }
+  else {
+    size_t stride;
+    const uint8_t* data;
+
+    data = heif_image_get_plane_readonly2(image, heif_channel_Y, &stride);
+    copy_plane(pic->y, pic->stride, data, stride, input_width, input_height, encoded_width, encoded_height);
+
+    data = heif_image_get_plane_readonly2(image, heif_channel_Cb, &stride);
+    copy_plane(pic->u, pic->stride >> encoder->chroma_stride_shift, data, stride,
+               encoder->input_chroma_width, encoder->input_chroma_height,
+               encoded_width >> encoder->chroma_stride_shift,
+               encoded_height >> encoder->chroma_height_shift);
+
+    data = heif_image_get_plane_readonly2(image, heif_channel_Cr, &stride);
+    copy_plane(pic->v, pic->stride >> encoder->chroma_stride_shift, data, stride,
+               encoder->input_chroma_width, encoder->input_chroma_height,
+               encoded_width >> encoder->chroma_stride_shift, encoded_height >> encoder->chroma_height_shift);
+  }
+
+
+  uvg_data_chunk* data = nullptr;
+  uint32_t data_len;
+  int success;
+#if 0
+  success = encoder->api->encoder_headers(encoder->kvzencoder, &data, &data_len);
+  if (!success) {
+    encoder->api->picture_free(pic);
+
+    return heif_error{
+        heif_error_Encoder_plugin_error,
+        heif_suberror_Encoder_encoding,
+        kError_unspecified_error
+    };
+  }
+#endif
+
+  pic->pts = framenr;
+
+  // If we write this, the data is twice in the output
+  //append_chunk_data(data, encoder->output_data);
+
+  uvg_picture* src_out = nullptr;
+
+  success = encoder->api->encoder_encode(encoder->kvzencoder,
+                                pic,
+                                &data, &data_len,
+                                nullptr, &src_out, nullptr);
+  if (!success) {
+    encoder->api->chunk_free(data);
+    encoder->api->picture_free(pic);
+    encoder->api->picture_free(src_out);
+
+    return heif_error{
+        heif_error_Encoder_plugin_error,
+        heif_suberror_Encoder_encoding,
+        kError_unspecified_error
+    };
+  }
+
+  if (src_out) {
+    encoder->append_chunk_data(data, (int)src_out->pts);
+
+    encoder->api->picture_free(src_out);
+    src_out = nullptr;
+  }
+
+  encoder->api->picture_free(pic);
+
+
+  encoder->api->chunk_free(data);
+
+  return heif_error_ok;
+}
+
+
+static heif_error uvg266_get_compressed_data_intern(void* encoder_raw, uint8_t** data, int* size,
+                                                    uintptr_t* frame_nr, int* is_keyframe, int* more_frame_packets)
+{
+  encoder_struct_uvg266* encoder = (encoder_struct_uvg266*) encoder_raw;
+
+  if (encoder->output_data.empty()) {
+    *data = nullptr;
+    *size = 0;
+
+    return heif_error_ok;
+  }
+
+  auto& pkg = encoder->output_data.front();
+
+  if (frame_nr) {
+    *frame_nr = pkg.frameNr;
+  }
+
+  if (more_frame_packets) {
+    *more_frame_packets = pkg.more_nals;
+  }
+
+  encoder->active_data = std::move(pkg.data);
+  encoder->output_data.pop_front();
+
+  *data = encoder->active_data.data();
+  *size = (int)encoder->active_data.size();
+
+#if 0
+  size_t start_idx = encoder->output_idx;
+
+  while (start_idx < encoder->output_data.size() - 3 &&
+         (encoder->output_data[start_idx] != 0 ||
+          encoder->output_data[start_idx + 1] != 0 ||
+          encoder->output_data[start_idx + 2] != 1)) {
+    start_idx++;
+  }
+
+  size_t end_idx = start_idx + 1;
+
+  while (end_idx < encoder->output_data.size() - 3 &&
+         (encoder->output_data[end_idx] != 0 ||
+          encoder->output_data[end_idx + 1] != 0 ||
+          encoder->output_data[end_idx + 2] != 1)) {
+    end_idx++;
+  }
+
+  if (end_idx == encoder->output_data.size() - 3) {
+    end_idx = encoder->output_data.size();
+  }
+
+  *data = encoder->output_data.data() + start_idx + 3;
+  *size = (int) (end_idx - start_idx - 3);
+
+  encoder->output_idx = end_idx;
+#endif
+
+  return heif_error_ok;
+}
+
+static heif_error uvg266_start_sequence_encoding(void* encoder_raw, const heif_image* image,
+                                                 heif_image_input_class input_class,
+                                                 uint32_t framerate_num, uint32_t framerate_denom,
+                                                 const heif_sequence_encoding_options* options)
+{
+  return uvg266_start_sequence_encoding_intern(encoder_raw, image, input_class,
+                                               framerate_num, framerate_denom, options, true);
+}
+
+static heif_error uvg266_end_sequence_encoding(void* encoder_raw)
+{
+  encoder_struct_uvg266* encoder = (encoder_struct_uvg266*) encoder_raw;
+
+  // --- flush
+
+  uvg_data_chunk* data = nullptr;
+  uint32_t data_len;
+
+  // uvg_picture* src_out = nullptr;
+
+  int success;
+  uvg_picture* src_out = nullptr;
+
+  for (;;) {
+    success = encoder->api->encoder_encode(encoder->kvzencoder,
+                                  nullptr,
+                                  &data, &data_len,
+                                  nullptr, &src_out, nullptr);
+    if (!success) {
+      encoder->api->chunk_free(data);
+      encoder->api->picture_free(src_out);
+
+      return heif_error{
+        heif_error_Encoder_plugin_error,
+        heif_suberror_Encoder_encoding,
+        kError_unspecified_error
+    };
+    }
+
+    if (data == nullptr || data->len == 0) {
+      break;
+    }
+
+    encoder->append_chunk_data(data, (int)src_out->pts);
+
+    encoder->api->picture_free(src_out);
+    src_out = nullptr;
+  }
+
+  (void) success;
+
+  if (src_out) {
+    encoder->append_chunk_data(data, (int)src_out->pts);
+
+    encoder->api->picture_free(src_out);
+    src_out = nullptr;
+  }
+
+
+  return heif_error_ok;
+}
+
+static heif_error uvg266_encode_image(void* encoder_raw, const heif_image* image,
+                                      heif_image_input_class input_class)
+{
+  heif_error err;
+  err = uvg266_start_sequence_encoding_intern(encoder_raw, image, input_class, 1,25, nullptr, false);
+  if (err.code) {
+    return err;
+  }
+
+  err = uvg266_encode_sequence_frame(encoder_raw, image, 0);
+  if (err.code) {
+    return err;
+  }
+
+  uvg266_end_sequence_encoding(encoder_raw);
+
+  return heif_error_ok;
+}
+
+
+static heif_error uvg266_get_compressed_data(void* encoder_raw, uint8_t** data, int* size,
+                                             heif_encoded_data_type* type)
+{
+  return uvg266_get_compressed_data_intern(encoder_raw, data, size, nullptr, nullptr, nullptr);
+}
+
+static heif_error uvg266_get_compressed_data2(void* encoder_raw, uint8_t** data, int* size,
+                                            uintptr_t* frame_nr, int* is_keyframe, int* more_frame_packets)
+{
+  return uvg266_get_compressed_data_intern(encoder_raw, data, size, frame_nr, is_keyframe, more_frame_packets);
+}
+
+
+static const heif_encoder_plugin encoder_plugin_uvg266
+    {
+        /* plugin_api_version */ 4,
+        /* compression_format */ heif_compression_VVC,
+        /* id_name */ "uvg266",
+        /* priority */ uvg266_PLUGIN_PRIORITY,
+        /* supports_lossy_compression */ true,
+        /* supports_lossless_compression */ true,
+        /* get_plugin_name */ uvg266_plugin_name,
+        /* init_plugin */ uvg266_init_plugin,
+        /* cleanup_plugin */ uvg266_cleanup_plugin,
+        /* new_encoder */ uvg266_new_encoder,
+        /* free_encoder */ uvg266_free_encoder,
+        /* set_parameter_quality */ uvg266_set_parameter_quality,
+        /* get_parameter_quality */ uvg266_get_parameter_quality,
+        /* set_parameter_lossless */ uvg266_set_parameter_lossless,
+        /* get_parameter_lossless */ uvg266_get_parameter_lossless,
+        /* set_parameter_logging_level */ uvg266_set_parameter_logging_level,
+        /* get_parameter_logging_level */ uvg266_get_parameter_logging_level,
+        /* list_parameters */ uvg266_list_parameters,
+        /* set_parameter_integer */ uvg266_set_parameter_integer,
+        /* get_parameter_integer */ uvg266_get_parameter_integer,
+        /* set_parameter_boolean */ uvg266_set_parameter_integer, // boolean also maps to integer function
+        /* get_parameter_boolean */ uvg266_get_parameter_integer, // boolean also maps to integer function
+        /* set_parameter_string */ uvg266_set_parameter_string,
+        /* get_parameter_string */ uvg266_get_parameter_string,
+        /* query_input_colorspace */ uvg266_query_input_colorspace,
+        /* encode_image */ uvg266_encode_image,
+        /* get_compressed_data */ uvg266_get_compressed_data,
+        /* query_input_colorspace (v2) */ uvg266_query_input_colorspace2,
+        /* query_encoded_size (v3) */ uvg266_query_encoded_size,
+        /* minimum_required_libheif_version */ LIBHEIF_MAKE_VERSION(1,21,0),
+        /* start_sequence_encoding (v4) */ uvg266_start_sequence_encoding,
+        /* encode_sequence_frame (v4) */ uvg266_encode_sequence_frame,
+        /* end_sequence_encoding (v4) */ uvg266_end_sequence_encoding,
+        /* get_compressed_data2 (v4) */ uvg266_get_compressed_data2,
+        /* does_indicate_keyframes (v4) */ 0
+    };
+
+const struct heif_encoder_plugin* get_encoder_plugin_uvg266() {
+  return &encoder_plugin_uvg266;
+}
+
+
+#if PLUGIN_UVG266
+heif_plugin_info plugin_info {
+  1,
+  heif_plugin_type_encoder,
+  &encoder_plugin_uvg266
+};
+#endif
diff --git a/libheif/plugins/encoder_uvg266.h b/libheif/plugins/encoder_uvg266.h
new file mode 100644
index 0000000000..61204c8e5c
--- /dev/null
+++ b/libheif/plugins/encoder_uvg266.h
@@ -0,0 +1,47 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_ENCODER_UVG266_H
+#define LIBHEIF_ENCODER_UVG266_H
+
+#include "common_utils.h"
+
+/* TODO: check whether this is also the case with uvg266.
+ *
+ * Image sizes in HEVC: since HEVC does not allow for odd image dimensions when
+   using chroma 4:2:0, our strategy is as follows.
+
+   - Images with odd dimensions are extended with an extra row/column which
+     contains a copy of the border.
+   - The HEVC image size generated by uvg266 is rounded up to the CTU size (?)
+     and the conformance window has to be respected.
+   - We add an additional crop transform to remove the extra row/column.
+ */
+
+
+const struct heif_encoder_plugin* get_encoder_plugin_uvg266();
+
+#if PLUGIN_UVG266
+extern "C" {
+MAYBE_UNUSED LIBHEIF_API extern heif_plugin_info plugin_info;
+}
+#endif
+
+#endif
diff --git a/libheif/plugins/encoder_vvenc.cc b/libheif/plugins/encoder_vvenc.cc
new file mode 100644
index 0000000000..5f10940402
--- /dev/null
+++ b/libheif/plugins/encoder_vvenc.cc
@@ -0,0 +1,886 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "libheif/heif.h"
+#include "libheif/heif_plugin.h"
+#include "encoder_vvenc.h"
+#include <memory>
+#include <string>   // apparently, this is a false positive of cpplint
+#include <cstring>
+#include <cassert>
+#include <vector>
+#include <algorithm>
+#include <deque>
+#include <utility>
+
+extern "C" {
+#include <vvenc/vvenc.h>
+}
+
+
+// TODO: it seems that the encoder does not support monochrome input. This affects also images with alpha channels.
+
+static const char* kError_unspecified_error = "Unspecified encoder error";
+static const char* kError_unsupported_bit_depth = "Bit depth not supported by vvenc";
+static const char* kError_unsupported_chroma = "Unsupported chroma type";
+//static const char* kError_unsupported_image_size = "Images smaller than 16 pixels are not supported";
+
+
+struct encoder_struct_vvenc
+{
+  int quality = 32;
+  bool lossless = false;
+
+  // --- encoder
+
+  vvencEncoder* vvencoder = nullptr;
+  vvencChromaFormat vvencChroma;
+  uint32_t encoded_width=0, encoded_height=0;
+
+  // --- output
+
+  struct Packet
+  {
+    std::vector<uint8_t> data;
+    uintptr_t frameNr = 0;
+    bool more_nals = false;
+  };
+
+  std::deque<Packet> output_data;
+
+  std::vector<uint8_t> active_data; // holds the data that we just returned
+
+  ~encoder_struct_vvenc()
+  {
+    if (vvencoder) {
+      vvenc_encoder_close(vvencoder);
+    }
+  }
+};
+
+static const int vvenc_PLUGIN_PRIORITY = 100;
+
+#define MAX_PLUGIN_NAME_LENGTH 80
+
+static char plugin_name[MAX_PLUGIN_NAME_LENGTH];
+
+
+static void vvenc_set_default_parameters(void* encoder);
+
+
+static const char* vvenc_plugin_name()
+{
+  strcpy(plugin_name, "vvenc VVC encoder");
+  return plugin_name;
+}
+
+
+#define MAX_NPARAMETERS 10
+
+static heif_encoder_parameter vvenc_encoder_params[MAX_NPARAMETERS];
+static const heif_encoder_parameter* vvenc_encoder_parameter_ptrs[MAX_NPARAMETERS + 1];
+
+static void vvenc_init_parameters()
+{
+  heif_encoder_parameter* p = vvenc_encoder_params;
+  const heif_encoder_parameter** d = vvenc_encoder_parameter_ptrs;
+  int i = 0;
+
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = heif_encoder_parameter_name_quality;
+  p->type = heif_encoder_parameter_type_integer;
+  p->integer.default_value = 50;
+  p->has_default = true;
+  p->integer.have_minimum_maximum = true;
+  p->integer.minimum = 0;
+  p->integer.maximum = 100;
+  p->integer.valid_values = NULL;
+  p->integer.num_valid_values = 0;
+  d[i++] = p++;
+
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = heif_encoder_parameter_name_lossless;
+  p->type = heif_encoder_parameter_type_boolean;
+  p->boolean.default_value = false;
+  p->has_default = true;
+  d[i++] = p++;
+
+  d[i++] = nullptr;
+}
+
+
+const heif_encoder_parameter** vvenc_list_parameters(void* encoder)
+{
+  return vvenc_encoder_parameter_ptrs;
+}
+
+
+static void vvenc_init_plugin()
+{
+  vvenc_init_parameters();
+}
+
+
+static void vvenc_cleanup_plugin()
+{
+}
+
+
+static heif_error vvenc_new_encoder(void** enc)
+{
+  encoder_struct_vvenc* encoder = new encoder_struct_vvenc();
+  heif_error err = heif_error_ok;
+
+  *enc = encoder;
+
+  // set default parameters
+
+  vvenc_set_default_parameters(encoder);
+
+  return err;
+}
+
+static void vvenc_free_encoder(void* encoder_raw)
+{
+  encoder_struct_vvenc* encoder = (encoder_struct_vvenc*) encoder_raw;
+
+  delete encoder;
+}
+
+static heif_error vvenc_set_parameter_quality(void* encoder_raw, int quality)
+{
+  encoder_struct_vvenc* encoder = (encoder_struct_vvenc*) encoder_raw;
+
+  if (quality < 0 || quality > 100) {
+    return heif_error_invalid_parameter_value;
+  }
+
+  encoder->quality = quality;
+
+  return heif_error_ok;
+}
+
+static heif_error vvenc_get_parameter_quality(void* encoder_raw, int* quality)
+{
+  encoder_struct_vvenc* encoder = (encoder_struct_vvenc*) encoder_raw;
+
+  *quality = encoder->quality;
+
+  return heif_error_ok;
+}
+
+static heif_error vvenc_set_parameter_lossless(void* encoder_raw, int enable)
+{
+  encoder_struct_vvenc* encoder = (encoder_struct_vvenc*) encoder_raw;
+
+  encoder->lossless = enable ? 1 : 0;
+
+  return heif_error_ok;
+}
+
+static heif_error vvenc_get_parameter_lossless(void* encoder_raw, int* enable)
+{
+  encoder_struct_vvenc* encoder = (encoder_struct_vvenc*) encoder_raw;
+
+  *enable = encoder->lossless;
+
+  return heif_error_ok;
+}
+
+static heif_error vvenc_set_parameter_logging_level(void* encoder_raw, int logging)
+{
+//  struct encoder_struct_vvenc* encoder = (struct encoder_struct_vvenc*) encoder_raw;
+
+// return heif_error_invalid_parameter_value;
+
+  return heif_error_ok;
+}
+
+static heif_error vvenc_get_parameter_logging_level(void* encoder_raw, int* loglevel)
+{
+//  struct encoder_struct_vvenc* encoder = (struct encoder_struct_vvenc*) encoder_raw;
+
+  *loglevel = 0;
+
+  return heif_error_ok;
+}
+
+
+static heif_error vvenc_set_parameter_integer(void* encoder_raw, const char* name, int value)
+{
+  encoder_struct_vvenc* encoder = (encoder_struct_vvenc*) encoder_raw;
+
+  if (strcmp(name, heif_encoder_parameter_name_quality) == 0) {
+    return vvenc_set_parameter_quality(encoder, value);
+  }
+  else if (strcmp(name, heif_encoder_parameter_name_lossless) == 0) {
+    return vvenc_set_parameter_lossless(encoder, value);
+  }
+
+  return heif_error_unsupported_parameter;
+}
+
+static heif_error vvenc_get_parameter_integer(void* encoder_raw, const char* name, int* value)
+{
+  encoder_struct_vvenc* encoder = (encoder_struct_vvenc*) encoder_raw;
+
+  if (strcmp(name, heif_encoder_parameter_name_quality) == 0) {
+    return vvenc_get_parameter_quality(encoder, value);
+  }
+  else if (strcmp(name, heif_encoder_parameter_name_lossless) == 0) {
+    return vvenc_get_parameter_lossless(encoder, value);
+  }
+
+  return heif_error_unsupported_parameter;
+}
+
+
+static heif_error vvenc_set_parameter_boolean(void* encoder, const char* name, int value)
+{
+  if (strcmp(name, heif_encoder_parameter_name_lossless) == 0) {
+    return vvenc_set_parameter_lossless(encoder, value);
+  }
+
+  return heif_error_unsupported_parameter;
+}
+
+// Unused, will use "vvenc_get_parameter_integer" instead.
+/*
+static struct heif_error vvenc_get_parameter_boolean(void* encoder, const char* name, int* value)
+{
+  if (strcmp(name, heif_encoder_parameter_name_lossless)==0) {
+    return vvenc_get_parameter_lossless(encoder,value);
+  }
+
+  return heif_error_unsupported_parameter;
+}
+*/
+
+
+static heif_error vvenc_set_parameter_string(void* encoder_raw, const char* name, const char* value)
+{
+  return heif_error_unsupported_parameter;
+}
+
+static heif_error vvenc_get_parameter_string(void* encoder_raw, const char* name,
+                                             char* value, int value_size)
+{
+  return heif_error_unsupported_parameter;
+}
+
+
+static void vvenc_set_default_parameters(void* encoder)
+{
+  for (const heif_encoder_parameter** p = vvenc_encoder_parameter_ptrs; *p; p++) {
+    const heif_encoder_parameter* param = *p;
+
+    if (param->has_default) {
+      switch (param->type) {
+        case heif_encoder_parameter_type_integer:
+          vvenc_set_parameter_integer(encoder, param->name, param->integer.default_value);
+          break;
+        case heif_encoder_parameter_type_boolean:
+          vvenc_set_parameter_boolean(encoder, param->name, param->boolean.default_value);
+          break;
+        case heif_encoder_parameter_type_string:
+          vvenc_set_parameter_string(encoder, param->name, param->string.default_value);
+          break;
+      }
+    }
+  }
+}
+
+
+static void vvenc_query_input_colorspace(heif_colorspace* colorspace, heif_chroma* chroma)
+{
+  if (*colorspace == heif_colorspace_monochrome) {
+    *colorspace = heif_colorspace_monochrome;
+    *chroma = heif_chroma_monochrome;
+  }
+  else {
+    *colorspace = heif_colorspace_YCbCr;
+    *chroma = heif_chroma_420;
+  }
+}
+
+
+static void vvenc_query_input_colorspace2(void* encoder_raw, heif_colorspace* colorspace, heif_chroma* chroma)
+{
+  if (*colorspace == heif_colorspace_monochrome) {
+    *colorspace = heif_colorspace_monochrome;
+    *chroma = heif_chroma_monochrome;
+  }
+  else {
+    *colorspace = heif_colorspace_YCbCr;
+    if (*chroma != heif_chroma_420 &&
+        *chroma != heif_chroma_422 &&
+        *chroma != heif_chroma_444) {
+      *chroma = heif_chroma_420;
+    }
+  }
+}
+
+void vvenc_query_encoded_size(void* encoder_raw, uint32_t input_width, uint32_t input_height,
+                              uint32_t* encoded_width, uint32_t* encoded_height)
+{
+  *encoded_width = (input_width + 7) & ~0x7;
+  *encoded_height = (input_height + 7) & ~0x7;
+}
+
+
+#include <iostream>
+#include <logging.h>
+
+static void append_chunk_data(struct encoder_struct_vvenc* encoder, vvencAccessUnit* au,
+                              uintptr_t pts)
+{
+#if 0
+  std::cout << "DATA pts=" << pts << "\n";
+  std::cout << write_raw_data_as_hex(au->payload, au->payloadUsedSize, {}, {});
+  std::cout << "---\n";
+#endif
+
+  std::vector<uint8_t> dat;
+  dat.resize(au->payloadUsedSize);
+  memcpy(dat.data(), au->payload, au->payloadUsedSize);
+
+  int start_idx = 0;
+
+  for (;;)
+  {
+    while (start_idx < au->payloadUsedSize - 3 &&
+           (au->payload[start_idx] != 0 ||
+            au->payload[start_idx + 1] != 0 ||
+            au->payload[start_idx + 2] != 1)) {
+      start_idx++;
+            }
+
+    int end_idx = start_idx + 1;
+
+    while (end_idx < au->payloadUsedSize - 3 &&
+           (au->payload[end_idx] != 0 ||
+            au->payload[end_idx + 1] != 0 ||
+            au->payload[end_idx + 2] != 1)) {
+      end_idx++;
+            }
+
+    if (end_idx == au->payloadUsedSize - 3) {
+      end_idx = au->payloadUsedSize;
+    }
+
+    encoder_struct_vvenc::Packet pkt;
+    pkt.data.resize(end_idx - start_idx - 3);
+    memcpy(pkt.data.data(), au->payload + start_idx + 3, pkt.data.size());
+    pkt.frameNr = pts;
+    pkt.more_nals = true; // will be set to 'false' for last NAL below.
+
+    //std::cout << "append frameNr=" << pts << " NAL:" << ((int)pkt.data[1]>>3) << " size:" << pkt.data.size() << "\n";
+
+    encoder->output_data.emplace_back(std::move(pkt));
+
+    if (end_idx == au->payloadUsedSize) {
+      break;
+    }
+
+    start_idx = end_idx;
+  }
+
+  if (!encoder->output_data.empty()) {
+    encoder->output_data.back().more_nals = false;
+  }
+}
+
+
+static void copy_plane(int16_t* dst_p, size_t dst_stride, const uint8_t* in_p, size_t in_stride, int w, int h, int padded_width, int padded_height)
+{
+  for (int y = 0; y < padded_height; y++) {
+    int sy = std::min(y, h - 1); // source y
+
+    for (int x = 0; x < w; x++) {
+      dst_p[y * dst_stride + x] = in_p[sy * in_stride + x];
+    }
+
+    for (int x = w; x < padded_width; x++) {
+      dst_p[y * dst_stride + x] = in_p[sy * in_stride + w - 1];
+    }
+  }
+}
+
+
+static heif_error vvenc_start_sequence_encoding_intern(void* encoder_raw, const heif_image* image,
+                                                       enum heif_image_input_class input_class,
+                                                       uint32_t framerate_num, uint32_t framerate_denom,
+                                                       const heif_sequence_encoding_options* options,
+                                                       bool image_sequence)
+{
+  encoder_struct_vvenc* encoder = (encoder_struct_vvenc*) encoder_raw;
+
+  vvenc_config params;
+
+  int bit_depth = heif_image_get_bits_per_pixel_range(image, heif_channel_Y);
+  if (bit_depth != 8) {
+    return heif_error{
+      heif_error_Encoder_plugin_error,
+      heif_suberror_Unsupported_image_type,
+      kError_unsupported_bit_depth
+  };
+  }
+
+  int input_width = heif_image_get_width(image, heif_channel_Y);
+  int input_height = heif_image_get_height(image, heif_channel_Y);
+
+  vvenc_query_encoded_size(encoder_raw, input_width, input_height,
+    &encoder->encoded_width, &encoder->encoded_height);
+
+
+  // invert encoder quality range and scale to 0-63
+  int encoder_quality = 63 - encoder->quality*63/100;
+
+  int ret = vvenc_init_default(&params,
+                               static_cast<int>(encoder->encoded_width),
+                               static_cast<int>(encoder->encoded_height),
+                               static_cast<int>((framerate_denom + framerate_num / 2) / framerate_num),
+                               0,
+                               encoder_quality,
+                               VVENC_MEDIUM);
+  if (ret != VVENC_OK) {
+    // TODO: cleanup memory
+
+    return heif_error{
+      heif_error_Encoder_plugin_error,
+      heif_suberror_Encoder_encoding,
+      kError_unspecified_error
+  };
+  }
+
+  params.m_inputBitDepth[0] = bit_depth;
+  params.m_inputBitDepth[1] = bit_depth;
+  params.m_outputBitDepth[0] = bit_depth;
+  params.m_outputBitDepth[1] = bit_depth;
+  params.m_internalBitDepth[0] = bit_depth;
+  params.m_internalBitDepth[1] = bit_depth;
+
+  bool isGreyscale = (heif_image_get_colorspace(image) == heif_colorspace_monochrome);
+  if (isGreyscale) {
+    params.m_internChromaFormat = VVENC_CHROMA_400;
+  }
+
+  params.m_FrameRate = framerate_denom;
+  params.m_FrameScale = framerate_num;
+
+  if (image_sequence) {
+    if (options->keyframe_distance_max) {
+      params.m_IntraPeriod = options->keyframe_distance_max;
+    }
+
+    switch (options->gop_structure) {
+      case heif_sequence_gop_structure_intra_only:
+        params.m_IntraPeriod = 1;
+        break;
+      case heif_sequence_gop_structure_lowdelay:
+        params.m_picReordering = 0;
+        params.m_GOPSize = 8; // as of vvcenc 1.13.1, this only works with GOPSize=8. see https://github.com/fraunhoferhhi/vvenc/issues/284
+        params.m_DecodingRefreshType = VVENC_DRT_NONE;
+        params.m_poc0idr = true;
+        break;
+      case heif_sequence_gop_structure_unrestricted:
+        ;
+    }
+  }
+
+  vvencEncoder* vvencoder = encoder->vvencoder = vvenc_encoder_create();
+
+  //ret = vvenc_check_config(vvencoder, &params);
+  //const char* err = vvenc_get_last_error(vvencoder);
+
+  ret = vvenc_encoder_open(vvencoder, &params);
+  //err = vvenc_get_last_error(vvencoder);
+  if (ret != VVENC_OK) {
+    // TODO: cleanup memory
+
+    return heif_error{
+      heif_error_Encoder_plugin_error,
+      heif_suberror_Encoder_encoding,
+      kError_unspecified_error
+  };
+  }
+
+  return heif_error_ok;
+}
+
+
+static heif_error vvenc_encode_sequence_frame(void* encoder_raw, const heif_image* image,
+                                              uintptr_t framenr)
+{
+  encoder_struct_vvenc* encoder = (encoder_struct_vvenc*) encoder_raw;
+  vvencEncoder* vvencoder = encoder->vvencoder;
+
+  bool isGreyscale = (heif_image_get_colorspace(image) == heif_colorspace_monochrome);
+  heif_chroma chroma = heif_image_get_chroma_format(image);
+
+
+
+  int input_width = heif_image_get_width(image, heif_channel_Y);
+  int input_height = heif_image_get_height(image, heif_channel_Y);
+
+  int input_chroma_width = 0;
+  int input_chroma_height = 0;
+
+  uint32_t encoded_width, encoded_height;
+  vvenc_query_encoded_size(encoder_raw, input_width, input_height, &encoded_width, &encoded_height);
+
+  vvencChromaFormat vvencChroma;
+  int chroma_stride_shift = 0;
+  int chroma_height_shift = 0;
+
+  if (isGreyscale) {
+    vvencChroma = VVENC_CHROMA_400;
+  }
+  else if (chroma == heif_chroma_420) {
+    vvencChroma = VVENC_CHROMA_420;
+    chroma_stride_shift = 1;
+    chroma_height_shift = 1;
+    input_chroma_width = (input_width + 1) / 2;
+    input_chroma_height = (input_height + 1) / 2;
+  }
+  else if (chroma == heif_chroma_422) {
+    vvencChroma = VVENC_CHROMA_422;
+    chroma_stride_shift = 1;
+    chroma_height_shift = 0;
+    input_chroma_width = (input_width + 1) / 2;
+    input_chroma_height = input_height;
+  }
+  else if (chroma == heif_chroma_444) {
+    vvencChroma = VVENC_CHROMA_444;
+    chroma_stride_shift = 0;
+    chroma_height_shift = 0;
+    input_chroma_width = input_width;
+    input_chroma_height = input_height;
+  }
+  else {
+    return heif_error{
+        heif_error_Encoder_plugin_error,
+        heif_suberror_Unsupported_image_type,
+        kError_unsupported_chroma
+    };
+  }
+
+  encoder->vvencChroma = vvencChroma;
+
+  if (chroma != heif_chroma_monochrome) {
+    int w = heif_image_get_width(image, heif_channel_Y);
+    int h = heif_image_get_height(image, heif_channel_Y);
+    if (chroma != heif_chroma_444) { w = (w + 1) / 2; }
+    if (chroma == heif_chroma_420) { h = (h + 1) / 2; }
+
+    assert(heif_image_get_width(image, heif_channel_Cb) == w);
+    assert(heif_image_get_width(image, heif_channel_Cr) == w);
+    assert(heif_image_get_height(image, heif_channel_Cb) == h);
+    assert(heif_image_get_height(image, heif_channel_Cr) == h);
+    (void) w;
+    (void) h;
+  }
+
+
+  heif_color_profile_nclx* nclx = nullptr;
+  heif_error err = heif_image_get_nclx_color_profile(image, &nclx);
+  if (err.code != heif_error_Ok) {
+    nclx = nullptr;
+  }
+
+  // make sure NCLX profile is deleted at end of function
+  auto nclx_deleter = std::unique_ptr<heif_color_profile_nclx, void (*)(heif_color_profile_nclx*)>(nclx, heif_nclx_color_profile_free);
+
+#if 0
+  if (nclx) {
+    config->vui.fullrange = nclx->full_range_flag;
+  }
+  else {
+    config->vui.fullrange = 1;
+  }
+
+  if (nclx &&
+      (input_class == heif_image_input_class_normal ||
+       input_class == heif_image_input_class_thumbnail)) {
+    config->vui.colorprim = nclx->color_primaries;
+    config->vui.transfer = nclx->transfer_characteristics;
+    config->vui.colormatrix = nclx->matrix_coefficients;
+  }
+
+  config->qp = ((100 - encoder->quality) * 51 + 50) / 100;
+  config->lossless = encoder->lossless ? 1 : 0;
+
+  config->width = encoded_width;
+  config->height = encoded_height;
+#endif
+
+  // Note: it is ok to cast away the const, as the image content is not changed.
+  // However, we have to guarantee that there are no plane pointers or stride values kept over calling the svt_encode_image() function.
+  /*
+  err = heif_image_extend_padding_to_size(const_cast<struct heif_image*>(image),
+                                          param->sourceWidth,
+                                          param->sourceHeight);
+  if (err.code) {
+    return err;
+  }
+*/
+
+  vvencYUVBuffer* yuvbuf = vvenc_YUVBuffer_alloc();
+  vvenc_YUVBuffer_alloc_buffer(yuvbuf, vvencChroma, encoded_width, encoded_height);
+
+  vvencAccessUnit* au = vvenc_accessUnit_alloc();
+
+  const int auSizeScale = (vvencChroma <= VVENC_CHROMA_420 ? 2 : 3);
+  vvenc_accessUnit_alloc_payload(au, auSizeScale * encoded_width * encoded_height + 1024);
+
+  // vvenc_init_pass( encoder, pass, statsfilename );
+
+  if (isGreyscale) {
+    size_t stride;
+    const uint8_t* data = heif_image_get_plane_readonly2(image, heif_channel_Y, &stride);
+
+    copy_plane(yuvbuf->planes[0].ptr, yuvbuf->planes[0].stride, data, stride, input_width, input_height, encoded_width, encoded_height);
+  }
+  else {
+    size_t stride;
+    const uint8_t* data;
+
+    data = heif_image_get_plane_readonly2(image, heif_channel_Y, &stride);
+    copy_plane(yuvbuf->planes[0].ptr, yuvbuf->planes[0].stride, data, stride, input_width, input_height, encoded_width, encoded_height);
+
+    data = heif_image_get_plane_readonly2(image, heif_channel_Cb, &stride);
+    copy_plane(yuvbuf->planes[1].ptr, yuvbuf->planes[1].stride, data, stride, input_chroma_width, input_chroma_height,
+               encoded_width >> chroma_stride_shift, encoded_height >> chroma_height_shift);
+
+    data = heif_image_get_plane_readonly2(image, heif_channel_Cr, &stride);
+    copy_plane(yuvbuf->planes[2].ptr, yuvbuf->planes[2].stride, data, stride, input_chroma_width, input_chroma_height,
+               encoded_width >> chroma_stride_shift, encoded_height >> chroma_height_shift);
+  }
+
+
+  yuvbuf->cts     = framenr;
+  yuvbuf->ctsValid = true;
+
+
+  bool encDone;
+
+  int ret = vvenc_encode(vvencoder, yuvbuf, au, &encDone);
+  if (ret != VVENC_OK) {
+    //vvenc_encoder_close(vvencoder);
+    vvenc_YUVBuffer_free_buffer(yuvbuf);
+    vvenc_YUVBuffer_free(yuvbuf, false); // release storage and payload memory
+    vvenc_accessUnit_free(au, true); // release storage and payload memory
+
+    return heif_error{
+        heif_error_Encoder_plugin_error,
+        heif_suberror_Encoder_encoding,
+        kError_unspecified_error
+    };
+  }
+
+  if (au->payloadUsedSize > 0) {
+    append_chunk_data(encoder, au, au->cts);
+  }
+
+  vvenc_YUVBuffer_free_buffer(yuvbuf);
+  vvenc_YUVBuffer_free(yuvbuf, false); // release storage and payload memory
+  vvenc_accessUnit_free(au, true); // release storage and payload memory
+
+  /*
+  delete[] yptr;
+  delete[] cbptr;
+  delete[] crptr;
+*/
+
+  return heif_error_ok;
+}
+
+
+static heif_error vvenc_end_sequence_encoding(void* encoder_raw)
+{
+  encoder_struct_vvenc* encoder = (encoder_struct_vvenc*) encoder_raw;
+  vvencEncoder* vvencoder = encoder->vvencoder;
+
+  vvencAccessUnit* au = vvenc_accessUnit_alloc();
+
+  const int auSizeScale = (encoder->vvencChroma <= VVENC_CHROMA_420 ? 2 : 3);
+  vvenc_accessUnit_alloc_payload(au, auSizeScale * encoder->encoded_width * encoder->encoded_height + 1024);
+
+  bool encDone = false;
+
+  while (!encDone) {
+    int ret = vvenc_encode(vvencoder, nullptr, au, &encDone);
+    if (ret != VVENC_OK) {
+      //vvenc_encoder_close(vvencoder);
+      vvenc_accessUnit_free(au, true); // release storage and payload memory
+
+      return heif_error{
+        heif_error_Encoder_plugin_error,
+        heif_suberror_Encoder_encoding,
+        kError_unspecified_error
+    };
+    }
+
+    if (au->payloadUsedSize > 0) {
+      append_chunk_data(encoder, au, au->cts);
+    }
+  }
+
+  vvenc_accessUnit_free(au, true); // release storage and payload memory
+
+  return heif_error_ok;
+}
+
+
+static heif_error vvenc_encode_image(void* encoder_raw, const heif_image* image,
+                                     heif_image_input_class input_class)
+{
+  heif_error err;
+  err = vvenc_start_sequence_encoding_intern(encoder_raw, image, input_class, 1,25, nullptr, false);
+  if (err.code) {
+    return err;
+  }
+
+  err = vvenc_encode_sequence_frame(encoder_raw, image, 0);
+  if (err.code) {
+    return err;
+  }
+
+  vvenc_end_sequence_encoding(encoder_raw);
+
+  return heif_error_ok;
+}
+
+static heif_error vvenc_start_sequence_encoding(void* encoder_raw, const heif_image* image,
+                                                enum heif_image_input_class input_class,
+                                                uint32_t framerate_num, uint32_t framerate_denom,
+                                                const heif_sequence_encoding_options* options)
+{
+  return vvenc_start_sequence_encoding_intern(encoder_raw, image, input_class, framerate_num, framerate_denom, options, true);
+}
+
+
+
+static heif_error vvenc_get_compressed_data_intern(void* encoder_raw, uint8_t** data, int* size,
+                                              uintptr_t* frame_nr, int* more_frame_packets)
+{
+  encoder_struct_vvenc* encoder = (encoder_struct_vvenc*) encoder_raw;
+
+  if (encoder->output_data.empty()) {
+    *data = nullptr;
+    *size = 0;
+
+    return heif_error_ok;
+  }
+
+  std::vector<uint8_t>& pktdata = encoder->output_data.front().data;
+
+  if (frame_nr) {
+    *frame_nr = encoder->output_data.front().frameNr;
+  }
+/*
+  if (more_frame_packets &&
+      encoder->output_data.size() > 1 &&
+      encoder->output_data[0].frameNr == encoder->output_data[1].frameNr) {
+    *more_frame_packets = 1;
+  }
+*/
+
+  if (more_frame_packets) {
+    *more_frame_packets = encoder->output_data.front().more_nals;
+  }
+
+  encoder->active_data = std::move(pktdata);
+  encoder->output_data.pop_front();
+
+  *data = encoder->active_data.data();
+  *size = static_cast<int>(encoder->active_data.size());
+
+  return heif_error_ok;
+}
+
+
+static heif_error vvenc_get_compressed_data(void* encoder_raw, uint8_t** data, int* size,
+                                           heif_encoded_data_type* type)
+{
+  return vvenc_get_compressed_data_intern(encoder_raw, data, size, nullptr, nullptr);
+}
+
+static heif_error vvenc_get_compressed_data2(void* encoder_raw, uint8_t** data, int* size,
+                                            uintptr_t* frame_nr, int* is_keyframe, int* more_frame_packets)
+{
+  return vvenc_get_compressed_data_intern(encoder_raw, data, size, frame_nr, more_frame_packets);
+}
+
+
+static const heif_encoder_plugin encoder_plugin_vvenc
+    {
+        /* plugin_api_version */ 4,
+        /* compression_format */ heif_compression_VVC,
+        /* id_name */ "vvenc",
+        /* priority */ vvenc_PLUGIN_PRIORITY,
+        /* supports_lossy_compression */ true,
+        /* supports_lossless_compression */ true,
+        /* get_plugin_name */ vvenc_plugin_name,
+        /* init_plugin */ vvenc_init_plugin,
+        /* cleanup_plugin */ vvenc_cleanup_plugin,
+        /* new_encoder */ vvenc_new_encoder,
+        /* free_encoder */ vvenc_free_encoder,
+        /* set_parameter_quality */ vvenc_set_parameter_quality,
+        /* get_parameter_quality */ vvenc_get_parameter_quality,
+        /* set_parameter_lossless */ vvenc_set_parameter_lossless,
+        /* get_parameter_lossless */ vvenc_get_parameter_lossless,
+        /* set_parameter_logging_level */ vvenc_set_parameter_logging_level,
+        /* get_parameter_logging_level */ vvenc_get_parameter_logging_level,
+        /* list_parameters */ vvenc_list_parameters,
+        /* set_parameter_integer */ vvenc_set_parameter_integer,
+        /* get_parameter_integer */ vvenc_get_parameter_integer,
+        /* set_parameter_boolean */ vvenc_set_parameter_integer, // boolean also maps to integer function
+        /* get_parameter_boolean */ vvenc_get_parameter_integer, // boolean also maps to integer function
+        /* set_parameter_string */ vvenc_set_parameter_string,
+        /* get_parameter_string */ vvenc_get_parameter_string,
+        /* query_input_colorspace */ vvenc_query_input_colorspace,
+        /* encode_image */ vvenc_encode_image,
+        /* get_compressed_data */ vvenc_get_compressed_data,
+        /* query_input_colorspace (v2) */ vvenc_query_input_colorspace2,
+        /* query_encoded_size (v3) */ vvenc_query_encoded_size,
+        /* minimum_required_libheif_version */ LIBHEIF_MAKE_VERSION(1,21,0),
+        /* start_sequence_encoding (v4) */ vvenc_start_sequence_encoding,
+        /* encode_sequence_frame (v4) */ vvenc_encode_sequence_frame,
+        /* end_sequence_encoding (v4) */ vvenc_end_sequence_encoding,
+        /* get_compressed_data2 (v4) */ vvenc_get_compressed_data2,
+        /* does_indicate_keyframes (v4) */ 0
+    };
+
+const heif_encoder_plugin* get_encoder_plugin_vvenc()
+{
+  return &encoder_plugin_vvenc;
+}
+
+
+#if PLUGIN_VVENC
+heif_plugin_info plugin_info {
+  1,
+  heif_plugin_type_encoder,
+  &encoder_plugin_vvenc
+};
+#endif
diff --git a/libheif/plugins/encoder_vvenc.h b/libheif/plugins/encoder_vvenc.h
new file mode 100644
index 0000000000..bf739dcdc1
--- /dev/null
+++ b/libheif/plugins/encoder_vvenc.h
@@ -0,0 +1,34 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_ENCODER_VVENC_H
+#define LIBHEIF_ENCODER_VVENC_H
+
+#include "common_utils.h"
+
+const struct heif_encoder_plugin* get_encoder_plugin_vvenc();
+
+#if PLUGIN_VVENC
+extern "C" {
+MAYBE_UNUSED LIBHEIF_API extern heif_plugin_info plugin_info;
+}
+#endif
+
+#endif
diff --git a/libheif/plugins/encoder_x264.cc b/libheif/plugins/encoder_x264.cc
new file mode 100644
index 0000000000..bce1d522d7
--- /dev/null
+++ b/libheif/plugins/encoder_x264.cc
@@ -0,0 +1,1238 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2025 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "libheif/heif.h"
+#include "libheif/heif_plugin.h"
+#include "encoder_x264.h"
+#include <memory>
+#include <sstream>
+#include <string>
+#include <cstring>
+#include <cassert>
+#include <deque>
+#include <vector>
+
+#include "logging.h"
+#include <utility>
+
+extern "C" {
+#include <x264.h>
+}
+
+#if 0
+static const char* naltype_table[] = {
+  /*  0 */ "unspecified",
+  /*  1 */ "non-IDR",
+  /*  2 */ "partition A",
+  /*  3 */ "partition B",
+  /*  4 */ "partition C",
+  /*  5 */ "IDR",
+  /*  6 */ "SEI",
+  /*  7 */ "SPS",
+  /*  8 */ "PPS",
+  /*  9 */ "AU-delimiter",
+  /* 10 */ "EOSequence",
+  /* 11 */ "EOStream",
+  /* 12 */ "FillerData",
+  /* 13 */ "SPS-extension",
+  /* 14 */ "Prefix-NAL",
+  /* 15 */ "Subset-SPS",
+  /* 16 */ "reserved",
+  /* 17 */ "reserved",
+  /* 18 */ "reserved",
+  /* 19 */ "aux-coded-picture",
+  /* 20 */ "slice-in-scalable-extension"
+};
+
+
+static const char* naltype(uint8_t type)
+{
+  if (type <= 20) {
+    return naltype_table[type];
+  }
+  else {
+    return "reserved";
+  }
+}
+#endif
+
+
+enum parameter_type
+{
+  UndefinedType, Int, Bool, String
+};
+
+struct parameter
+{
+  parameter_type type = UndefinedType;
+  std::string name;
+
+  int value_int = 0; // also used for boolean
+  std::string value_string;
+};
+
+
+struct encoder_struct_x264
+{
+  x264_t* encoder = nullptr;
+  x264_param_t param{};
+
+  uintptr_t out_frameNr = 0;
+  int bit_depth = 0;
+
+  heif_chroma chroma;
+
+
+  // --- parameters
+
+  std::vector<parameter> parameters;
+
+  void add_param(const parameter&);
+
+  void add_param(const std::string& name, int value);
+
+  void add_param(const std::string& name, bool value);
+
+  void add_param(const std::string& name, const std::string& value);
+
+  parameter get_param(const std::string& name) const;
+
+  std::string preset;
+  std::string tune;
+
+  int logLevel = X264_LOG_NONE;
+
+  // --- output
+
+  struct Packet
+  {
+    std::vector<uint8_t> data;
+    uintptr_t frameNr = 0;
+    bool more_packets = false;
+  };
+
+  std::deque<Packet> m_output_packets;
+  std::vector<uint8_t> m_active_output;
+
+  void append_nals(const x264_nal_t* nals, int num_nals, uintptr_t frameNr);
+
+  std::string last_error_message;
+};
+
+
+void encoder_struct_x264::append_nals(const x264_nal_t* nals, int num_nals, uintptr_t frameNr)
+{
+#if 0
+  std::cout << "append " << num_nals << " NALs for frame " << frameNr << "\n";
+
+  for (int i=0;i<num_nals;i++) {
+    std::cout << "dequeue header NAL : " << naltype(nals[i].i_type) << "\n";
+  }
+#endif
+
+  for (int i=0;i<num_nals;i++) {
+    const auto& nal = nals[i];
+
+    Packet pkt;
+    pkt.data.insert(pkt.data.end(), nal.p_payload, nal.p_payload + nal.i_payload);
+    pkt.more_packets = true; // below, it will be set to 'false' for the last packet
+    pkt.frameNr = frameNr;
+
+    m_output_packets.emplace_back(std::move(pkt));
+  }
+
+  m_output_packets.back().more_packets = false;
+}
+
+
+void encoder_struct_x264::add_param(const parameter& p)
+{
+  // if there is already a parameter of that name, remove it from list
+
+  for (size_t i = 0; i < parameters.size(); i++) {
+    if (parameters[i].name == p.name) {
+      for (size_t k = i + 1; k < parameters.size(); k++) {
+        parameters[k - 1] = parameters[k];
+      }
+      parameters.pop_back();
+      break;
+    }
+  }
+
+  // and add the new parameter at the end of the list
+
+  parameters.push_back(p);
+}
+
+
+void encoder_struct_x264::add_param(const std::string& name, int value)
+{
+  parameter p;
+  p.type = Int;
+  p.name = name;
+  p.value_int = value;
+  add_param(p);
+}
+
+void encoder_struct_x264::add_param(const std::string& name, bool value)
+{
+  parameter p;
+  p.type = Bool;
+  p.name = name;
+  p.value_int = value;
+  add_param(p);
+}
+
+void encoder_struct_x264::add_param(const std::string& name, const std::string& value)
+{
+  parameter p;
+  p.type = String;
+  p.name = name;
+  p.value_string = value;
+  add_param(p);
+}
+
+
+parameter encoder_struct_x264::get_param(const std::string& name) const
+{
+  for (size_t i = 0; i < parameters.size(); i++) {
+    if (parameters[i].name == name) {
+      return parameters[i];
+    }
+  }
+
+  return parameter();
+}
+
+
+static const char* kParam_preset = "preset";
+static const char* kParam_tune = "tune";
+static const char* kParam_TU_intra_depth = "tu-intra-depth";
+static const char* kParam_complexity = "complexity";
+
+static const char* const kParam_preset_valid_values[] = {
+    "ultrafast", "superfast", "veryfast", "faster", "fast", "medium",
+    "slow", "slower", "veryslow", "placebo", nullptr
+};
+
+static const char* const kParam_tune_valid_values[] = {
+    "psnr", "ssim", "grain", "fastdecode", nullptr
+    // note: zerolatency is missing, because we do not need it for single images
+};
+
+static const char* kParam_chroma = "chroma";
+static const char* const kParam_chroma_valid_values[] = {
+    "420", "422", "444", nullptr
+};
+
+
+static const int X264_PLUGIN_PRIORITY = 100;
+
+#define MAX_PLUGIN_NAME_LENGTH 80
+
+static char plugin_name[MAX_PLUGIN_NAME_LENGTH];
+
+
+static void x264_set_default_parameters(void* encoder);
+
+
+static const char* x264_plugin_name()
+{
+  strcpy(plugin_name, "x264 AVC encoder");
+
+  const char* x264_version = X264_VERSION;
+
+  if (strlen(x264_version) + strlen(plugin_name) + 4 < MAX_PLUGIN_NAME_LENGTH) {
+    strcat(plugin_name, " (");
+    strcat(plugin_name, x264_version);
+    strcat(plugin_name, ")");
+  }
+
+  return plugin_name;
+}
+
+
+#define MAX_NPARAMETERS 10
+
+static heif_encoder_parameter x264_encoder_params[MAX_NPARAMETERS];
+static const heif_encoder_parameter* x264_encoder_parameter_ptrs[MAX_NPARAMETERS + 1];
+
+static void x264_init_parameters()
+{
+  heif_encoder_parameter* p = x264_encoder_params;
+  const heif_encoder_parameter** d = x264_encoder_parameter_ptrs;
+  int i = 0;
+
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = heif_encoder_parameter_name_quality;
+  p->type = heif_encoder_parameter_type_integer;
+  p->integer.default_value = 50;
+  p->has_default = true;
+  p->integer.have_minimum_maximum = true;
+  p->integer.minimum = 0;
+  p->integer.maximum = 100;
+  p->integer.valid_values = NULL;
+  p->integer.num_valid_values = 0;
+  d[i++] = p++;
+
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = heif_encoder_parameter_name_lossless;
+  p->type = heif_encoder_parameter_type_boolean;
+  p->boolean.default_value = false;
+  p->has_default = true;
+  d[i++] = p++;
+
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = kParam_preset;
+  p->type = heif_encoder_parameter_type_string;
+  p->string.default_value = "slow";  // increases computation time
+  p->has_default = true;
+  p->string.valid_values = kParam_preset_valid_values;
+  d[i++] = p++;
+
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = kParam_tune;
+  p->type = heif_encoder_parameter_type_string;
+  p->string.default_value = "ssim";
+  p->has_default = true;
+  p->string.valid_values = kParam_tune_valid_values;
+  d[i++] = p++;
+
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = kParam_TU_intra_depth;
+  p->type = heif_encoder_parameter_type_integer;
+  p->integer.default_value = 2;  // increases computation time
+  p->has_default = true;
+  p->integer.have_minimum_maximum = true;
+  p->integer.minimum = 1;
+  p->integer.maximum = 4;
+  p->integer.valid_values = NULL;
+  p->integer.num_valid_values = 0;
+  d[i++] = p++;
+
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = kParam_complexity;
+  p->type = heif_encoder_parameter_type_integer;
+  p->integer.default_value = 50;
+  p->has_default = false;
+  p->integer.have_minimum_maximum = true;
+  p->integer.minimum = 0;
+  p->integer.maximum = 100;
+  p->integer.valid_values = NULL;
+  p->integer.num_valid_values = 0;
+  d[i++] = p++;
+
+  assert(i < MAX_NPARAMETERS);
+  p->version = 2;
+  p->name = kParam_chroma;
+  p->type = heif_encoder_parameter_type_string;
+  p->string.default_value = "420";
+  p->has_default = true;
+  p->string.valid_values = kParam_chroma_valid_values;
+  d[i++] = p++;
+
+  d[i++] = nullptr;
+}
+
+
+const heif_encoder_parameter** x264_list_parameters(void* encoder)
+{
+  return x264_encoder_parameter_ptrs;
+}
+
+
+static void x264_init_plugin()
+{
+  x264_init_parameters();
+}
+
+
+static void x264_cleanup_plugin()
+{
+}
+
+
+static heif_error x264_new_encoder(void** enc)
+{
+  encoder_struct_x264* encoder = new encoder_struct_x264();
+  heif_error err = heif_error_ok;
+
+
+  // encoder has to be allocated in x264_encode_image, because it needs to know the image size
+  encoder->encoder = nullptr;
+
+  encoder->bit_depth = 8;
+
+  *enc = encoder;
+
+
+  // set default parameters
+
+  x264_set_default_parameters(encoder);
+
+  return err;
+}
+
+static void x264_free_encoder(void* encoder_raw)
+{
+  encoder_struct_x264* encoder = (encoder_struct_x264*) encoder_raw;
+
+  if (encoder->encoder) {
+    x264_encoder_close(encoder->encoder);
+    encoder->encoder = nullptr;
+  }
+
+  delete encoder;
+}
+
+static heif_error x264_set_parameter_quality(void* encoder_raw, int quality)
+{
+  encoder_struct_x264* encoder = (encoder_struct_x264*) encoder_raw;
+
+  if (quality < 0 || quality > 100) {
+    return heif_error_invalid_parameter_value;
+  }
+
+  encoder->add_param(heif_encoder_parameter_name_quality, quality);
+
+  return heif_error_ok;
+}
+
+static heif_error x264_get_parameter_quality(void* encoder_raw, int* quality)
+{
+  encoder_struct_x264* encoder = (encoder_struct_x264*) encoder_raw;
+
+  parameter p = encoder->get_param(heif_encoder_parameter_name_quality);
+  *quality = p.value_int;
+
+  return heif_error_ok;
+}
+
+static heif_error x264_set_parameter_lossless(void* encoder_raw, int enable)
+{
+  encoder_struct_x264* encoder = (encoder_struct_x264*) encoder_raw;
+
+  encoder->add_param(heif_encoder_parameter_name_lossless, (bool) enable);
+
+  return heif_error_ok;
+}
+
+static heif_error x264_get_parameter_lossless(void* encoder_raw, int* enable)
+{
+  encoder_struct_x264* encoder = (encoder_struct_x264*) encoder_raw;
+
+  parameter p = encoder->get_param(heif_encoder_parameter_name_lossless);
+  *enable = p.value_int;
+
+  return heif_error_ok;
+}
+
+static heif_error x264_set_parameter_logging_level(void* encoder_raw, int logging)
+{
+  encoder_struct_x264* encoder = (encoder_struct_x264*) encoder_raw;
+
+  if (logging < 0 || logging > 4) {
+    return heif_error_invalid_parameter_value;
+  }
+
+  encoder->logLevel = logging;
+
+  return heif_error_ok;
+}
+
+static heif_error x264_get_parameter_logging_level(void* encoder_raw, int* loglevel)
+{
+  encoder_struct_x264* encoder = (encoder_struct_x264*) encoder_raw;
+
+  *loglevel = encoder->logLevel;
+
+  return heif_error_ok;
+}
+
+
+static heif_error x264_set_parameter_integer(void* encoder_raw, const char* name, int value)
+{
+  encoder_struct_x264* encoder = (encoder_struct_x264*) encoder_raw;
+
+  if (strcmp(name, heif_encoder_parameter_name_quality) == 0) {
+    return x264_set_parameter_quality(encoder, value);
+  }
+  else if (strcmp(name, heif_encoder_parameter_name_lossless) == 0) {
+    return x264_set_parameter_lossless(encoder, value);
+  }
+  else if (strcmp(name, kParam_TU_intra_depth) == 0) {
+    if (value < 1 || value > 4) {
+      return heif_error_invalid_parameter_value;
+    }
+
+    encoder->add_param(name, value);
+    return heif_error_ok;
+  }
+  else if (strcmp(name, kParam_complexity) == 0) {
+    if (value < 0 || value > 100) {
+      return heif_error_invalid_parameter_value;
+    }
+
+    encoder->add_param(name, value);
+    return heif_error_ok;
+  }
+
+  return heif_error_unsupported_parameter;
+}
+
+static heif_error x264_get_parameter_integer(void* encoder_raw, const char* name, int* value)
+{
+  encoder_struct_x264* encoder = (encoder_struct_x264*) encoder_raw;
+
+  if (strcmp(name, heif_encoder_parameter_name_quality) == 0) {
+    return x264_get_parameter_quality(encoder, value);
+  }
+  else if (strcmp(name, heif_encoder_parameter_name_lossless) == 0) {
+    return x264_get_parameter_lossless(encoder, value);
+  }
+  else if (strcmp(name, kParam_TU_intra_depth) == 0) {
+    *value = encoder->get_param(name).value_int;
+    return heif_error_ok;
+  }
+  else if (strcmp(name, kParam_complexity) == 0) {
+    *value = encoder->get_param(name).value_int;
+    return heif_error_ok;
+  }
+
+  return heif_error_unsupported_parameter;
+}
+
+
+static heif_error x264_set_parameter_boolean(void* encoder, const char* name, int value)
+{
+  if (strcmp(name, heif_encoder_parameter_name_lossless) == 0) {
+    return x264_set_parameter_lossless(encoder, value);
+  }
+
+  return heif_error_unsupported_parameter;
+}
+
+// Unused, will use "x264_get_parameter_integer" instead.
+/*
+static struct heif_error x264_get_parameter_boolean(void* encoder, const char* name, int* value)
+{
+  if (strcmp(name, heif_encoder_parameter_name_lossless)==0) {
+    return x264_get_parameter_lossless(encoder,value);
+  }
+
+  return heif_error_unsupported_parameter;
+}
+*/
+
+
+static bool string_list_contains(const char* const* values_list, const char* value)
+{
+  for (int i = 0; values_list[i]; i++) {
+    if (strcmp(values_list[i], value) == 0) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+
+static heif_error x264_set_parameter_string(void* encoder_raw, const char* name, const char* value)
+{
+  encoder_struct_x264* encoder = (encoder_struct_x264*) encoder_raw;
+
+  if (strcmp(name, kParam_preset) == 0) {
+    if (!string_list_contains(kParam_preset_valid_values, value)) {
+      return heif_error_invalid_parameter_value;
+    }
+
+    encoder->preset = value;
+    return heif_error_ok;
+  }
+  else if (strcmp(name, kParam_tune) == 0) {
+    if (!string_list_contains(kParam_tune_valid_values, value)) {
+      return heif_error_invalid_parameter_value;
+    }
+
+    encoder->tune = value;
+    return heif_error_ok;
+  }
+  else if (strncmp(name, "x264:", 5) == 0) {
+    encoder->add_param(name, std::string(value));
+    return heif_error_ok;
+  }
+  else if (strcmp(name, kParam_chroma) == 0) {
+    if (strcmp(value, "420") == 0) {
+      encoder->chroma = heif_chroma_420;
+      return heif_error_ok;
+    }
+    else if (strcmp(value, "422") == 0) {
+      encoder->chroma = heif_chroma_422;
+      return heif_error_ok;
+    }
+    else if (strcmp(value, "444") == 0) {
+      encoder->chroma = heif_chroma_444;
+      return heif_error_ok;
+    }
+    else {
+      return heif_error_invalid_parameter_value;
+    }
+  }
+
+  return heif_error_unsupported_parameter;
+}
+
+static void save_strcpy(char* dst, int dst_size, const char* src)
+{
+  strncpy(dst, src, dst_size - 1);
+  dst[dst_size - 1] = 0;
+}
+
+static heif_error x264_get_parameter_string(void* encoder_raw, const char* name,
+                                            char* value, int value_size)
+{
+  encoder_struct_x264* encoder = (encoder_struct_x264*) encoder_raw;
+
+  if (strcmp(name, kParam_preset) == 0) {
+    save_strcpy(value, value_size, encoder->preset.c_str());
+    return heif_error_ok;
+  }
+  else if (strcmp(name, kParam_tune) == 0) {
+    save_strcpy(value, value_size, encoder->tune.c_str());
+    return heif_error_ok;
+  }
+  else if (strcmp(name, kParam_chroma) == 0) {
+    switch (encoder->chroma) {
+      case heif_chroma_420:
+        save_strcpy(value, value_size, "420");
+        break;
+      case heif_chroma_422:
+        save_strcpy(value, value_size, "422");
+        break;
+      case heif_chroma_444:
+        save_strcpy(value, value_size, "444");
+        break;
+      default:
+        assert(false);
+        return heif_error_invalid_parameter_value;
+    }
+    return heif_error_ok;
+  }
+
+  return heif_error_unsupported_parameter;
+}
+
+
+static void x264_set_default_parameters(void* encoder)
+{
+  for (const heif_encoder_parameter** p = x264_encoder_parameter_ptrs; *p; p++) {
+    const heif_encoder_parameter* param = *p;
+
+    if (param->has_default) {
+      switch (param->type) {
+        case heif_encoder_parameter_type_integer:
+          x264_set_parameter_integer(encoder, param->name, param->integer.default_value);
+          break;
+        case heif_encoder_parameter_type_boolean:
+          x264_set_parameter_boolean(encoder, param->name, param->boolean.default_value);
+          break;
+        case heif_encoder_parameter_type_string:
+          x264_set_parameter_string(encoder, param->name, param->string.default_value);
+          break;
+      }
+    }
+  }
+}
+
+
+static void x264_query_input_colorspace(heif_colorspace* colorspace, heif_chroma* chroma)
+{
+  if (*colorspace == heif_colorspace_monochrome) {
+    *colorspace = heif_colorspace_monochrome;
+    *chroma = heif_chroma_monochrome;
+  }
+  else {
+    *colorspace = heif_colorspace_YCbCr;
+    *chroma = heif_chroma_420;
+  }
+}
+
+
+static void x264_query_input_colorspace2(void* encoder_raw, heif_colorspace* colorspace, heif_chroma* chroma)
+{
+  auto* encoder = (encoder_struct_x264*) encoder_raw;
+
+  if (*colorspace == heif_colorspace_monochrome) {
+    *colorspace = heif_colorspace_monochrome;
+    *chroma = heif_chroma_monochrome;
+  }
+  else {
+    *colorspace = heif_colorspace_YCbCr;
+    *chroma = encoder->chroma;
+  }
+}
+
+
+static int rounded_size(int s)
+{
+  s = (s + 1) & ~1;
+
+  if (s < 64) {
+    s = 64;
+  }
+
+  return s;
+}
+
+
+static heif_error x264_start_sequence_encoding_intern(void* encoder_raw, const heif_image* image,
+                                       heif_image_input_class input_class,
+                                       uint32_t framerate_num, uint32_t framerate_denom,
+                                       const heif_sequence_encoding_options* options,
+                                       bool image_sequence)
+{
+  encoder_struct_x264* encoder = (encoder_struct_x264*) encoder_raw;
+
+
+  // close previous encoder if there is still one hanging around
+  if (encoder->encoder) {
+    x264_encoder_close(encoder->encoder);
+    encoder->encoder = nullptr;
+  }
+
+
+  int bit_depth = heif_image_get_bits_per_pixel_range(image, heif_channel_Y);
+  bool isGreyscale = (heif_image_get_colorspace(image) == heif_colorspace_monochrome);
+  heif_chroma chroma = heif_image_get_chroma_format(image);
+
+
+  x264_param_t& param = encoder->param;
+
+  x264_param_default_preset(&param, encoder->preset.c_str(), encoder->tune.c_str());
+
+  if (bit_depth == 8) {
+    x264_param_apply_profile(&param, "main");
+  }
+  else if (bit_depth == 10) x264_param_apply_profile(&param, "main10-intra");
+  else if (bit_depth == 12) x264_param_apply_profile(&param, "main12-intra");
+  else {
+    return heif_error_unsupported_parameter;
+  }
+
+
+  param.i_fps_num = framerate_num;
+  param.i_fps_den = framerate_denom;
+
+  if (options) {
+    if (options->keyframe_distance_min) {
+      param.i_keyint_min = options->keyframe_distance_min;
+    }
+
+    if (options->keyframe_distance_max) {
+      param.i_keyint_max = options->keyframe_distance_max;
+    }
+
+    switch (options->gop_structure) {
+      case heif_sequence_gop_structure_intra_only:
+        param.i_bframe = 0;
+        param.i_keyint_min=1;
+        param.i_keyint_max=1;
+        break;
+      case heif_sequence_gop_structure_lowdelay:
+        param.i_bframe = 0;
+        break;
+      case heif_sequence_gop_structure_unrestricted:
+        //param.i_bframe = 1;
+        break;
+    }
+  }
+
+  // BPG uses CQP. It does not seem to be better though.
+  //  param->rc.rateControlMode = X264_RC_CQP;
+  //  param->rc.qp = (100 - encoder->quality)/2;
+  param.i_frame_total = image_sequence ? 0 : 1; // TODO
+
+  if (isGreyscale) {
+    param.i_csp = X264_CSP_I400;
+  }
+  else if (chroma == heif_chroma_420) {
+    param.i_csp = X264_CSP_I420;
+  }
+  else if (chroma == heif_chroma_422) {
+    param.i_csp = X264_CSP_I422;
+  }
+  else if (chroma == heif_chroma_444) {
+    param.i_csp = X264_CSP_I444;
+  }
+
+  if (chroma != heif_chroma_monochrome) {
+    int w = heif_image_get_width(image, heif_channel_Y);
+    int h = heif_image_get_height(image, heif_channel_Y);
+    if (chroma != heif_chroma_444) { w = (w + 1) / 2; }
+    if (chroma == heif_chroma_420) { h = (h + 1) / 2; }
+
+    assert(heif_image_get_width(image, heif_channel_Cb)==w);
+    assert(heif_image_get_width(image, heif_channel_Cr)==w);
+    assert(heif_image_get_height(image, heif_channel_Cb)==h);
+    assert(heif_image_get_height(image, heif_channel_Cr)==h);
+    (void) w;
+    (void) h;
+  }
+
+  // TODO: which of these exist ?
+  x264_param_parse(&param, "info", "0");
+  x264_param_parse(&param, "limit-modes", "0");
+  x264_param_parse(&param, "limit-refs", "0");
+  x264_param_parse(&param, "rskip", "0");
+
+  x264_param_parse(&param, "rect", "1");
+  x264_param_parse(&param, "amp", "1");
+  x264_param_parse(&param, "aq-mode", "1");
+  x264_param_parse(&param, "psy-rd", "1.0");
+  x264_param_parse(&param, "psy-rdoq", "1.0");
+
+  heif_color_profile_nclx* nclx = nullptr;
+  heif_error err = heif_image_get_nclx_color_profile(image, &nclx);
+  if (err.code != heif_error_Ok) {
+    assert(nclx == nullptr);
+  }
+
+  // make sure NCLX profile is deleted at end of function
+  auto nclx_deleter = std::unique_ptr<heif_color_profile_nclx, void (*)(heif_color_profile_nclx*)>(nclx, heif_nclx_color_profile_free);
+
+  if (nclx) {
+    x264_param_parse(&param, "range", nclx->full_range_flag ? "full" : "limited");
+  }
+  else {
+    x264_param_parse(&param, "range", "full");
+  }
+
+  if (nclx &&
+      (input_class == heif_image_input_class_normal ||
+       input_class == heif_image_input_class_thumbnail)) {
+
+    {
+      std::stringstream sstr;
+      sstr << nclx->color_primaries;
+      x264_param_parse(&param, "colorprim", sstr.str().c_str());
+    }
+
+    {
+      std::stringstream sstr;
+      sstr << nclx->transfer_characteristics;
+      x264_param_parse(&param, "transfer", sstr.str().c_str());
+    }
+
+    {
+      std::stringstream sstr;
+      sstr << nclx->matrix_coefficients;
+      x264_param_parse(&param, "colormatrix", sstr.str().c_str());
+    }
+  }
+
+  for (const auto& p : encoder->parameters) {
+    if (p.name == heif_encoder_parameter_name_quality) {
+      // quality=0   -> crf=50
+      // quality=50  -> crf=25
+      // quality=100 -> crf=0
+
+      param.rc.f_rf_constant = (float)(100 - p.value_int) / 2.0f;
+    }
+    else if (p.name == heif_encoder_parameter_name_lossless) {
+      if (p.value_int) {
+        param.rc.i_qp_constant = 0;
+      }
+    }
+    else if (p.name == kParam_complexity) {
+      const int complexity = p.value_int;
+
+      if (complexity >= 60) {
+        x264_param_parse(&param, "rd-refine", "1"); // increases computation time
+        x264_param_parse(&param, "rd", "6");
+      }
+    }
+    else if (strncmp(p.name.c_str(), "x264:", 5) == 0) {
+      std::string x264p = p.name.substr(5);
+      if (x264_param_parse(&param, x264p.c_str(), p.value_string.c_str()) < 0) {
+        encoder->last_error_message = std::string{"Unsupported x264 encoder parameter: "} + x264p;
+
+        return {
+          .code = heif_error_Usage_error,
+          .subcode = heif_suberror_Unsupported_parameter,
+          .message = encoder->last_error_message.c_str()
+        };
+      }
+    }
+  }
+
+  param.i_log_level = encoder->logLevel;
+
+
+  param.i_width = heif_image_get_width(image, heif_channel_Y);
+  param.i_height = heif_image_get_height(image, heif_channel_Y);
+  //param->internalBitDepth = bit_depth;
+
+  param.i_width = rounded_size(param.i_width);
+  param.i_height = rounded_size(param.i_height);
+
+#if 0
+  // This enforces that x264 will not queue frames.
+  // Without this, it needs to be flushed 18x until it returns some NALs.
+  // -> we now use x264_encoder_delayed_frames(), which works fine.
+
+  param.b_sliced_threads = 1;
+  param.i_slice_count_max = 1;
+  param.i_slice_count = 1;
+  param.i_slice_max_mbs = 0;
+  param.i_slice_max_size = 0;
+#endif
+
+  // output NALs with size, no startcodes (actually, we don't care since we skip the 4 bytes anyways)
+  param.b_annexb = 0;
+
+  encoder->bit_depth = bit_depth;
+
+  encoder->encoder = x264_encoder_open(&param);
+  if (!encoder->encoder) {
+    return heif_error{
+      heif_error_Encoder_plugin_error,
+      heif_suberror_Unspecified,
+      "Cannot create x264 encoder"
+    };
+  }
+
+  if (image_sequence) {
+    x264_nal_t* nals = nullptr;
+    int num_nals = 0;
+
+    x264_encoder_headers(encoder->encoder,
+                         &nals,
+                         &num_nals);
+
+    if (num_nals) {
+      encoder->append_nals(nals, num_nals, 0);
+    }
+  }
+
+  return heif_error_ok;
+}
+
+
+static heif_error x264_start_sequence_encoding(void* encoder_raw, const heif_image* image,
+                                       enum heif_image_input_class input_class,
+                                       uint32_t framerate_num, uint32_t framerate_denom,
+                                       const heif_sequence_encoding_options* options)
+{
+  return x264_start_sequence_encoding_intern(encoder_raw, image, input_class,
+                                             framerate_num, framerate_denom, options, true);
+}
+
+
+static heif_error x264_encode_sequence_frame(void* encoder_raw, const heif_image* image,
+                                             uintptr_t frame_nr)
+{
+  encoder_struct_x264* encoder = (encoder_struct_x264*) encoder_raw;
+  x264_param_t& param = encoder->param;
+
+  if (!encoder->encoder) {
+    return {
+      heif_error_Usage_error,
+      heif_suberror_Unspecified,
+      "called plugin encode_sequence_frame() without start_sequence_encoding()"
+    };
+  }
+
+  heif_error err;
+
+  // Note: it is ok to cast away the const, as the image content is not changed.
+  // However, we have to guarantee that there are no plane pointers or stride values kept over calling the svt_encode_image() function.
+  err = heif_image_extend_padding_to_size(const_cast<heif_image*>(image),
+                                          param.i_width,
+                                          param.i_height);
+  if (err.code) {
+    return err;
+  }
+
+  x264_picture_t pic;
+  x264_picture_init(&pic);
+
+  pic.img.i_csp = param.i_csp;
+
+  // TODO: check that all input images use the same color format
+
+  bool isGreyscale = (heif_image_get_colorspace(image) == heif_colorspace_monochrome);
+
+  if (isGreyscale) {
+    pic.img.plane[0] = const_cast<uint8_t*>(heif_image_get_plane_readonly(image, heif_channel_Y, &pic.img.i_stride[0]));
+  }
+  else {
+    pic.img.plane[0] = const_cast<uint8_t*>(heif_image_get_plane_readonly(image, heif_channel_Y, &pic.img.i_stride[0]));
+    pic.img.plane[1] = const_cast<uint8_t*>(heif_image_get_plane_readonly(image, heif_channel_Cb, &pic.img.i_stride[1]));
+    pic.img.plane[2] = const_cast<uint8_t*>(heif_image_get_plane_readonly(image, heif_channel_Cr, &pic.img.i_stride[2]));
+  }
+
+  // pic->bitDepth = encoder->bit_depth;
+  pic.i_pts = frame_nr;
+
+  x264_nal_t* nals = nullptr;
+  int num_nals = 0;
+
+  x264_picture_t out_pic;
+  int result = x264_encoder_encode(encoder->encoder,
+                                   &nals,
+                                   &num_nals,
+                                   &pic,
+                                   &out_pic);
+  (void)result; // TODO: check for error
+
+  if (num_nals) {
+    encoder->append_nals(nals, num_nals, out_pic.i_pts);
+  }
+
+  return heif_error_ok;
+}
+
+
+static heif_error x264_end_sequence_encoding(void* encoder_raw)
+{
+  encoder_struct_x264* encoder = (encoder_struct_x264*) encoder_raw;
+
+#if 0
+  // TODO (hack)
+  if (encoder->nal_output_counter < encoder->num_nals) {
+    return heif_error_ok;
+  }
+#endif
+
+  // check that all NALs have been drained
+  //assert(encoder->nal_output_counter == encoder->num_nals);
+  //encoder->nal_output_counter = 0;
+
+  x264_nal_t* nals = nullptr;
+  int num_nals = 0;
+
+  while (x264_encoder_delayed_frames(encoder->encoder) > 0) {
+    x264_picture_t out_pic;
+    int result = x264_encoder_encode(encoder->encoder,
+                                     &nals,
+                                     &num_nals,
+                                     nullptr,
+                                     &out_pic);
+    (void)result; // TODO: check for error
+    encoder->out_frameNr = out_pic.i_pts;
+
+    if (num_nals) {
+      encoder->append_nals(nals, num_nals, out_pic.i_pts);
+      break;
+    }
+  }
+
+  x264_param_cleanup(&encoder->param);
+
+  //encoder->nal_output_counter = 0; // TODO: is this needed ?
+
+  return heif_error_ok;
+}
+
+
+static heif_error x264_encode_image(void* encoder_raw, const heif_image* image,
+                                    heif_image_input_class input_class)
+{
+  heif_error err;
+  err = x264_start_sequence_encoding_intern(encoder_raw, image, input_class, 1,25, nullptr, false);
+  if (err.code) {
+    return err;
+  }
+
+  err = x264_encode_sequence_frame(encoder_raw, image, 0);
+  if (err.code) {
+    return err;
+  }
+
+  x264_end_sequence_encoding(encoder_raw);
+
+  return heif_error_ok;
+}
+
+
+static heif_error x264_get_compressed_data_intern(void* encoder_raw, uint8_t** data, int* size,
+                                                  uintptr_t* out_frame_nr, int* more_packets)
+{
+  encoder_struct_x264* encoder = ( encoder_struct_x264*) encoder_raw;
+
+  if (encoder->encoder == nullptr) {
+    *data = nullptr;
+    *size = 0;
+
+    return heif_error_ok;
+  }
+
+  if (encoder->m_output_packets.empty()) {
+    *data = nullptr;
+    *size = 0;
+
+    return heif_error_ok;
+  }
+
+  auto& pkt = encoder->m_output_packets.front();
+  encoder->m_active_output = std::move(pkt.data);
+
+  if (out_frame_nr) {
+    *out_frame_nr = pkt.frameNr;
+  }
+
+  if (more_packets) {
+    *more_packets = pkt.more_packets;
+  }
+
+  *data = encoder->m_active_output.data() + 4;
+  *size = (int)encoder->m_active_output.size() - 4;
+
+  encoder->m_output_packets.pop_front();
+
+#if 0
+  // const x264_api* api = x264_api_get(encoder->bit_depth);
+
+  /*for (;;)*/ {
+    while (encoder->nal_output_counter < encoder->num_nals) {
+      *data = encoder->nals[encoder->nal_output_counter].p_payload;
+      *size = encoder->nals[encoder->nal_output_counter].i_payload;
+      encoder->nal_output_counter++;
+
+      // --- skip start code ---
+
+      // skip '0' bytes
+      while (**data == 0 && *size > 0) {
+        (*data)++;
+        (*size)--;
+      }
+
+      // skip '1' byte
+      (*data)++;
+      (*size)--;
+
+      const uint8_t nal_type = ((*data)[0] & 0x1f);
+      std::cout << "NAL type: " << ((int)nal_type) << "\n";
+      std::cout << write_raw_data_as_hex(*data, *size,
+                              "data: ",
+                              "      ");
+
+      // --- skip NALs with irrelevant data ---
+
+      if (*size >= 3 && (*data)[0] == 0x4e && (*data)[2] == 5) {
+        // skip "unregistered user data SEI"
+
+      }
+      else {
+        // output NAL
+
+        if (out_frame_nr) {
+          *out_frame_nr = encoder->out_frameNr;
+        }
+
+        return heif_error_ok;
+      }
+    }
+  }
+
+  *data = nullptr;
+  *size = 0;
+
+  if (out_frame_nr) {
+    *out_frame_nr = 0;
+  }
+#endif
+
+  return heif_error_ok;
+}
+
+
+static heif_error x264_get_compressed_data(void* encoder_raw, uint8_t** data, int* size,
+                                           heif_encoded_data_type* type)
+{
+  return x264_get_compressed_data_intern(encoder_raw, data, size, nullptr, nullptr);
+}
+
+static heif_error x264_get_compressed_data2(void* encoder_raw, uint8_t** data, int* size,
+                                            uintptr_t* frame_nr, int* is_keyframe,
+                                            int* more_frame_packets)
+{
+  return x264_get_compressed_data_intern(encoder_raw, data, size, frame_nr, more_frame_packets);
+}
+
+
+static const heif_encoder_plugin encoder_plugin_x264
+    {
+        /* plugin_api_version */ 4,
+        /* compression_format */ heif_compression_AVC,
+        /* id_name */ "x264",
+        /* priority */ X264_PLUGIN_PRIORITY,
+        /* supports_lossy_compression */ true,
+        /* supports_lossless_compression */ true,
+        /* get_plugin_name */ x264_plugin_name,
+        /* init_plugin */ x264_init_plugin,
+        /* cleanup_plugin */ x264_cleanup_plugin,
+        /* new_encoder */ x264_new_encoder,
+        /* free_encoder */ x264_free_encoder,
+        /* set_parameter_quality */ x264_set_parameter_quality,
+        /* get_parameter_quality */ x264_get_parameter_quality,
+        /* set_parameter_lossless */ x264_set_parameter_lossless,
+        /* get_parameter_lossless */ x264_get_parameter_lossless,
+        /* set_parameter_logging_level */ x264_set_parameter_logging_level,
+        /* get_parameter_logging_level */ x264_get_parameter_logging_level,
+        /* list_parameters */ x264_list_parameters,
+        /* set_parameter_integer */ x264_set_parameter_integer,
+        /* get_parameter_integer */ x264_get_parameter_integer,
+        /* set_parameter_boolean */ x264_set_parameter_integer, // boolean also maps to integer function
+        /* get_parameter_boolean */ x264_get_parameter_integer, // boolean also maps to integer function
+        /* set_parameter_string */ x264_set_parameter_string,
+        /* get_parameter_string */ x264_get_parameter_string,
+        /* query_input_colorspace */ x264_query_input_colorspace,
+        /* encode_image */ x264_encode_image,
+        /* get_compressed_data */ x264_get_compressed_data,
+        /* query_input_colorspace (v2) */ x264_query_input_colorspace2,
+        /* query_encoded_size (v3) */ nullptr,
+        /* minimum_required_libheif_version */ LIBHEIF_MAKE_VERSION(1,21,0),
+        /* start_sequence_encoding (v4) */ x264_start_sequence_encoding,
+        /* encode_sequence_frame (v4) */ x264_encode_sequence_frame,
+        /* end_sequence_encoding (v4) */ x264_end_sequence_encoding,
+        /* get_compressed_data2 (v4) */ x264_get_compressed_data2,
+        /* does_indicate_keyframes (v4) */ 0
+    };
+
+const heif_encoder_plugin* get_encoder_plugin_x264()
+{
+  return &encoder_plugin_x264;
+}
+
+
+#if PLUGIN_X264
+heif_plugin_info plugin_info {
+  1,
+  heif_plugin_type_encoder,
+  &encoder_plugin_x264
+};
+#endif
diff --git a/libheif/plugins/encoder_x264.h b/libheif/plugins/encoder_x264.h
new file mode 100644
index 0000000000..941d9ce2ab
--- /dev/null
+++ b/libheif/plugins/encoder_x264.h
@@ -0,0 +1,34 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2025 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_ENCODER_X264_H
+#define LIBHEIF_ENCODER_X264_H
+
+#include "common_utils.h"
+
+const struct heif_encoder_plugin* get_encoder_plugin_x264();
+
+#if PLUGIN_X264
+extern "C" {
+MAYBE_UNUSED LIBHEIF_API extern heif_plugin_info plugin_info;
+}
+#endif
+
+#endif
diff --git a/libheif/heif_encoder_x265.cc b/libheif/plugins/encoder_x265.cc
similarity index 58%
rename from libheif/heif_encoder_x265.cc
rename to libheif/plugins/encoder_x265.cc
index ce9f4a5c37..1c35c0a483 100644
--- a/libheif/heif_encoder_x265.cc
+++ b/libheif/plugins/encoder_x265.cc
@@ -1,6 +1,6 @@
 /*
  * HEIF codec.
- * Copyright (c) 2017 struktur AG, Dirk Farin <farin@struktur.de>
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>
  *
  * This file is part of libheif.
  *
@@ -18,19 +18,18 @@
  * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "heif.h"
-#include "heif_plugin.h"
-#include "heif_api_structs.h"
-
-#if defined(HAVE_CONFIG_H)
-#include "config.h"
-#endif
-
+#include "libheif/heif.h"
+#include "libheif/heif_plugin.h"
+#include "encoder_x265.h"
+#include <memory>
+#include <sstream>
 #include <string>
 #include <cstring>
 #include <cstdio>
 #include <cassert>
+#include <deque>
 #include <vector>
+#include <utility>
 
 extern "C" {
 #include <x265.h>
@@ -39,7 +38,7 @@ extern "C" {
 
 static const char* kError_unsupported_bit_depth = "Bit depth not supported by x265";
 static const char* kError_unsupported_image_size = "Images smaller than 16 pixels are not supported";
-static const char* kError_out_of_memory = "Out of memory";
+static const char* kError_unsupported_ctu_size = "Unsupported CTU size";
 
 
 enum parameter_type
@@ -49,8 +48,6 @@ enum parameter_type
 
 struct parameter
 {
-
-
   parameter_type type = UndefinedType;
   std::string name;
 
@@ -62,33 +59,47 @@ struct parameter
 struct encoder_struct_x265
 {
   x265_encoder* encoder = nullptr;
+  const x265_api* api = nullptr;
+  x265_param* param = nullptr;
 
-  x265_nal* nals = nullptr;
-  uint32_t num_nals = 0;
-  uint32_t nal_output_counter = 0;
   int bit_depth = 0;
 
   heif_chroma chroma;
 
 
+  // --- output
+
+  struct Packet
+  {
+    std::vector<uint8_t> data;
+    uintptr_t frameNr = 0;
+  };
+
+  std::deque<Packet> output_data;
+  std::vector<uint8_t> active_output_nal;
+
+  void append_nal_packets(x265_nal* nals, uint32_t num_nals, uintptr_t frameNr);
+
   // --- parameters
 
   std::vector<parameter> parameters;
 
   void add_param(const parameter&);
 
-  void add_param(std::string name, int value);
+  void add_param(const std::string& name, int value);
 
-  void add_param(std::string name, bool value);
+  void add_param(const std::string& name, bool value);
 
-  void add_param(std::string name, std::string value);
+  void add_param(const std::string& name, const std::string& value);
 
-  parameter get_param(std::string name) const;
+  parameter get_param(const std::string& name) const;
 
   std::string preset;
   std::string tune;
 
   int logLevel = X265_LOG_NONE;
+
+  std::string last_error_message;
 };
 
 
@@ -112,7 +123,7 @@ void encoder_struct_x265::add_param(const parameter& p)
 }
 
 
-void encoder_struct_x265::add_param(std::string name, int value)
+void encoder_struct_x265::add_param(const std::string& name, int value)
 {
   parameter p;
   p.type = Int;
@@ -121,7 +132,7 @@ void encoder_struct_x265::add_param(std::string name, int value)
   add_param(p);
 }
 
-void encoder_struct_x265::add_param(std::string name, bool value)
+void encoder_struct_x265::add_param(const std::string& name, bool value)
 {
   parameter p;
   p.type = Bool;
@@ -130,7 +141,7 @@ void encoder_struct_x265::add_param(std::string name, bool value)
   add_param(p);
 }
 
-void encoder_struct_x265::add_param(std::string name, std::string value)
+void encoder_struct_x265::add_param(const std::string& name, const std::string& value)
 {
   parameter p;
   p.type = String;
@@ -140,7 +151,7 @@ void encoder_struct_x265::add_param(std::string name, std::string value)
 }
 
 
-parameter encoder_struct_x265::get_param(std::string name) const
+parameter encoder_struct_x265::get_param(const std::string& name) const
 {
   for (size_t i = 0; i < parameters.size(); i++) {
     if (parameters[i].name == name) {
@@ -187,8 +198,9 @@ static const char* x265_plugin_name()
 {
   strcpy(plugin_name, "x265 HEVC encoder");
 
-  const char* x265_version = (x265_version_str != nullptr ? x265_version_str : "null");
-  
+  const x265_api* api = x265_api_get(0);
+  const char* x265_version = ((api != nullptr && api->version_str != nullptr) ? api->version_str : "null");
+
   if (strlen(x265_version) + strlen(plugin_name) + 4 < MAX_PLUGIN_NAME_LENGTH) {
     strcat(plugin_name, " (");
     strcat(plugin_name, x265_version);
@@ -201,13 +213,13 @@ static const char* x265_plugin_name()
 
 #define MAX_NPARAMETERS 10
 
-static struct heif_encoder_parameter x265_encoder_params[MAX_NPARAMETERS];
-static const struct heif_encoder_parameter* x265_encoder_parameter_ptrs[MAX_NPARAMETERS + 1];
+static heif_encoder_parameter x265_encoder_params[MAX_NPARAMETERS];
+static const heif_encoder_parameter* x265_encoder_parameter_ptrs[MAX_NPARAMETERS + 1];
 
 static void x265_init_parameters()
 {
-  struct heif_encoder_parameter* p = x265_encoder_params;
-  const struct heif_encoder_parameter** d = x265_encoder_parameter_ptrs;
+  heif_encoder_parameter* p = x265_encoder_params;
+  const heif_encoder_parameter** d = x265_encoder_parameter_ptrs;
   int i = 0;
 
   assert(i < MAX_NPARAMETERS);
@@ -288,7 +300,7 @@ static void x265_init_parameters()
 }
 
 
-const struct heif_encoder_parameter** x265_list_parameters(void* encoder)
+const heif_encoder_parameter** x265_list_parameters(void* encoder)
 {
   return x265_encoder_parameter_ptrs;
 }
@@ -302,21 +314,19 @@ static void x265_init_plugin()
 
 static void x265_cleanup_plugin()
 {
+  x265_cleanup();
 }
 
 
-static struct heif_error x265_new_encoder(void** enc)
+static heif_error x265_new_encoder(void** enc)
 {
-  struct encoder_struct_x265* encoder = new encoder_struct_x265();
-  struct heif_error err = heif_error_ok;
+  encoder_struct_x265* encoder = new encoder_struct_x265();
+  heif_error err = heif_error_ok;
 
 
   // encoder has to be allocated in x265_encode_image, because it needs to know the image size
   encoder->encoder = nullptr;
 
-  encoder->nals = nullptr;
-  encoder->num_nals = 0;
-  encoder->nal_output_counter = 0;
   encoder->bit_depth = 8;
 
   *enc = encoder;
@@ -331,7 +341,7 @@ static struct heif_error x265_new_encoder(void** enc)
 
 static void x265_free_encoder(void* encoder_raw)
 {
-  struct encoder_struct_x265* encoder = (struct encoder_struct_x265*) encoder_raw;
+  encoder_struct_x265* encoder = (encoder_struct_x265*) encoder_raw;
 
   if (encoder->encoder) {
     const x265_api* api = x265_api_get(encoder->bit_depth);
@@ -341,9 +351,9 @@ static void x265_free_encoder(void* encoder_raw)
   delete encoder;
 }
 
-static struct heif_error x265_set_parameter_quality(void* encoder_raw, int quality)
+static heif_error x265_set_parameter_quality(void* encoder_raw, int quality)
 {
-  struct encoder_struct_x265* encoder = (struct encoder_struct_x265*) encoder_raw;
+  encoder_struct_x265* encoder = (encoder_struct_x265*) encoder_raw;
 
   if (quality < 0 || quality > 100) {
     return heif_error_invalid_parameter_value;
@@ -354,9 +364,9 @@ static struct heif_error x265_set_parameter_quality(void* encoder_raw, int quali
   return heif_error_ok;
 }
 
-static struct heif_error x265_get_parameter_quality(void* encoder_raw, int* quality)
+static heif_error x265_get_parameter_quality(void* encoder_raw, int* quality)
 {
-  struct encoder_struct_x265* encoder = (struct encoder_struct_x265*) encoder_raw;
+  encoder_struct_x265* encoder = (encoder_struct_x265*) encoder_raw;
 
   parameter p = encoder->get_param(heif_encoder_parameter_name_quality);
   *quality = p.value_int;
@@ -364,18 +374,18 @@ static struct heif_error x265_get_parameter_quality(void* encoder_raw, int* qual
   return heif_error_ok;
 }
 
-static struct heif_error x265_set_parameter_lossless(void* encoder_raw, int enable)
+static heif_error x265_set_parameter_lossless(void* encoder_raw, int enable)
 {
-  struct encoder_struct_x265* encoder = (struct encoder_struct_x265*) encoder_raw;
+  encoder_struct_x265* encoder = (encoder_struct_x265*) encoder_raw;
 
   encoder->add_param(heif_encoder_parameter_name_lossless, (bool) enable);
 
   return heif_error_ok;
 }
 
-static struct heif_error x265_get_parameter_lossless(void* encoder_raw, int* enable)
+static heif_error x265_get_parameter_lossless(void* encoder_raw, int* enable)
 {
-  struct encoder_struct_x265* encoder = (struct encoder_struct_x265*) encoder_raw;
+  encoder_struct_x265* encoder = (encoder_struct_x265*) encoder_raw;
 
   parameter p = encoder->get_param(heif_encoder_parameter_name_lossless);
   *enable = p.value_int;
@@ -383,9 +393,9 @@ static struct heif_error x265_get_parameter_lossless(void* encoder_raw, int* ena
   return heif_error_ok;
 }
 
-static struct heif_error x265_set_parameter_logging_level(void* encoder_raw, int logging)
+static heif_error x265_set_parameter_logging_level(void* encoder_raw, int logging)
 {
-  struct encoder_struct_x265* encoder = (struct encoder_struct_x265*) encoder_raw;
+  encoder_struct_x265* encoder = (encoder_struct_x265*) encoder_raw;
 
   if (logging < 0 || logging > 4) {
     return heif_error_invalid_parameter_value;
@@ -396,9 +406,9 @@ static struct heif_error x265_set_parameter_logging_level(void* encoder_raw, int
   return heif_error_ok;
 }
 
-static struct heif_error x265_get_parameter_logging_level(void* encoder_raw, int* loglevel)
+static heif_error x265_get_parameter_logging_level(void* encoder_raw, int* loglevel)
 {
-  struct encoder_struct_x265* encoder = (struct encoder_struct_x265*) encoder_raw;
+  encoder_struct_x265* encoder = (encoder_struct_x265*) encoder_raw;
 
   *loglevel = encoder->logLevel;
 
@@ -406,9 +416,9 @@ static struct heif_error x265_get_parameter_logging_level(void* encoder_raw, int
 }
 
 
-static struct heif_error x265_set_parameter_integer(void* encoder_raw, const char* name, int value)
+static heif_error x265_set_parameter_integer(void* encoder_raw, const char* name, int value)
 {
-  struct encoder_struct_x265* encoder = (struct encoder_struct_x265*) encoder_raw;
+  encoder_struct_x265* encoder = (encoder_struct_x265*) encoder_raw;
 
   if (strcmp(name, heif_encoder_parameter_name_quality) == 0) {
     return x265_set_parameter_quality(encoder, value);
@@ -436,9 +446,9 @@ static struct heif_error x265_set_parameter_integer(void* encoder_raw, const cha
   return heif_error_unsupported_parameter;
 }
 
-static struct heif_error x265_get_parameter_integer(void* encoder_raw, const char* name, int* value)
+static heif_error x265_get_parameter_integer(void* encoder_raw, const char* name, int* value)
 {
-  struct encoder_struct_x265* encoder = (struct encoder_struct_x265*) encoder_raw;
+  encoder_struct_x265* encoder = (encoder_struct_x265*) encoder_raw;
 
   if (strcmp(name, heif_encoder_parameter_name_quality) == 0) {
     return x265_get_parameter_quality(encoder, value);
@@ -459,7 +469,7 @@ static struct heif_error x265_get_parameter_integer(void* encoder_raw, const cha
 }
 
 
-static struct heif_error x265_set_parameter_boolean(void* encoder, const char* name, int value)
+static heif_error x265_set_parameter_boolean(void* encoder, const char* name, int value)
 {
   if (strcmp(name, heif_encoder_parameter_name_lossless) == 0) {
     return x265_set_parameter_lossless(encoder, value);
@@ -493,9 +503,9 @@ static bool string_list_contains(const char* const* values_list, const char* val
 }
 
 
-static struct heif_error x265_set_parameter_string(void* encoder_raw, const char* name, const char* value)
+static heif_error x265_set_parameter_string(void* encoder_raw, const char* name, const char* value)
 {
-  struct encoder_struct_x265* encoder = (struct encoder_struct_x265*) encoder_raw;
+  encoder_struct_x265* encoder = (encoder_struct_x265*) encoder_raw;
 
   if (strcmp(name, kParam_preset) == 0) {
     if (!string_list_contains(kParam_preset_valid_values, value)) {
@@ -535,7 +545,6 @@ static struct heif_error x265_set_parameter_string(void* encoder_raw, const char
     }
   }
 
-
   return heif_error_unsupported_parameter;
 }
 
@@ -545,10 +554,10 @@ static void save_strcpy(char* dst, int dst_size, const char* src)
   dst[dst_size - 1] = 0;
 }
 
-static struct heif_error x265_get_parameter_string(void* encoder_raw, const char* name,
-                                                   char* value, int value_size)
+static heif_error x265_get_parameter_string(void* encoder_raw, const char* name,
+                                            char* value, int value_size)
 {
-  struct encoder_struct_x265* encoder = (struct encoder_struct_x265*) encoder_raw;
+  encoder_struct_x265* encoder = (encoder_struct_x265*) encoder_raw;
 
   if (strcmp(name, kParam_preset) == 0) {
     save_strcpy(value, value_size, encoder->preset.c_str());
@@ -573,6 +582,7 @@ static struct heif_error x265_get_parameter_string(void* encoder_raw, const char
         assert(false);
         return heif_error_invalid_parameter_value;
     }
+    return heif_error_ok;
   }
 
   return heif_error_unsupported_parameter;
@@ -581,8 +591,8 @@ static struct heif_error x265_get_parameter_string(void* encoder_raw, const char
 
 static void x265_set_default_parameters(void* encoder)
 {
-  for (const struct heif_encoder_parameter** p = x265_encoder_parameter_ptrs; *p; p++) {
-    const struct heif_encoder_parameter* param = *p;
+  for (const heif_encoder_parameter** p = x265_encoder_parameter_ptrs; *p; p++) {
+    const heif_encoder_parameter* param = *p;
 
     if (param->has_default) {
       switch (param->type) {
@@ -616,7 +626,7 @@ static void x265_query_input_colorspace(heif_colorspace* colorspace, heif_chroma
 
 static void x265_query_input_colorspace2(void* encoder_raw, heif_colorspace* colorspace, heif_chroma* chroma)
 {
-  auto* encoder = (struct encoder_struct_x265*) encoder_raw;
+  auto* encoder = (encoder_struct_x265*) encoder_raw;
 
   if (*colorspace == heif_colorspace_monochrome) {
     *colorspace = heif_colorspace_monochrome;
@@ -640,13 +650,111 @@ static int rounded_size(int s)
   return s;
 }
 
+#if 0
+static const char* naltype_table[] = {
+  /*  0 */ "TRAIL_N",
+  /*  1 */ "TRAIL_R",
+  /*  2 */ "TSA_N",
+  /*  3 */ "TSA_R",
+  /*  4 */ "STSA_N",
+  /*  5 */ "STSA_R",
+  /*  6 */ "RADL_N",
+  /*  7 */ "RADL_R",
+  /*  8 */ "RASL_N",
+  /*  9 */ "RASL_R",
+  /* 10 */ "RSV_VCL_N10",
+  /* 11 */ "RSV_VCL_R11",
+  /* 12 */ "RSV_VCL_N12",
+  /* 13 */ "RSV_VCL_R13",
+  /* 14 */ "RSV_VCL_N14",
+  /* 15 */ "RSV_VCL_R15",
+  /* 16 */ "BLA_W_LP",
+  /* 17 */ "BLA_W_RADL",
+  /* 18 */ "BLA_N_LP",
+  /* 19 */ "IDR_W_RADL",
+  /* 20 */ "IDR_N_LP",
+  /* 21 */ "CRA_NUT",
+  /* 22 */ "RSV_IRAP_VCL22",
+  /* 23 */ "RSV_IRAP_VCL23",
+  /* 24 */ "RSV_VCL24",
+  /* 25 */ "RSV_VCL25",
+  /* 26 */ "RSV_VCL26",
+  /* 27 */ "RSV_VCL27",
+  /* 28 */ "RSV_VCL28",
+  /* 29 */ "RSV_VCL29",
+  /* 30 */ "RSV_VCL30",
+  /* 31 */ "RSV_VCL31",
+  /* 32 */ "VPS_NUT",
+  /* 33 */ "SPS_NUT",
+  /* 34 */ "PPS_NUT",
+  /* 35 */ "AUD_NUT",
+  /* 36 */ "EOS_NUT",
+  /* 37 */ "EOB_NUT",
+  /* 38 */ "FD_NUT",
+  /* 39 */ "PREFIX_SEI_NUT",
+  /* 40 */ "SUFFIX_SEI_NUT"
+};
+
 
-static struct heif_error x265_encode_image(void* encoder_raw, const struct heif_image* image,
-                                           heif_image_input_class input_class)
+static const char* naltype(uint8_t type)
 {
-  struct encoder_struct_x265* encoder = (struct encoder_struct_x265*) encoder_raw;
+  if (type <= 40) {
+    return naltype_table[type];
+  }
+  else {
+    return "reserved";
+  }
+}
+#endif
+
+void encoder_struct_x265::append_nal_packets(x265_nal* nals, uint32_t num_nals, uintptr_t frameNr)
+{
+  for (uint32_t nal_idx=0 ; nal_idx < num_nals; nal_idx++) {
+    uint8_t* data = nals[nal_idx].payload;
+    uint32_t size = nals[nal_idx].sizeBytes;
+
+    // --- skip start code ---
+
+    // skip '0' bytes
+    while (*data == 0 && size > 0) {
+      data++;
+      size--;
+    }
+
+    // skip '1' byte
+    data++;
+    size--;
+
+
+    // --- skip NALs with irrelevant data ---
+
+    if (size >= 3 && data[0] == 0x4e && data[2] == 5) {
+      // skip "unregistered user data SEI"
+    }
+    else {
+      // output NAL
+
+      Packet pkt;
+      pkt.data.resize(size);
+      memcpy(pkt.data.data(), data, size);
+      pkt.frameNr = frameNr;
+
+      output_data.push_back(pkt);
+    }
+  }
+}
+
 
-  // close previous encoder if there is still one hanging around
+static heif_error x265_start_sequence_encoding_intern(void* encoder_raw, const heif_image* image,
+                                       enum heif_image_input_class input_class,
+                                       uint32_t framerate_num, uint32_t framerate_denom,
+                                       const heif_sequence_encoding_options* options,
+                                       bool image_sequence)
+{
+  encoder_struct_x265* encoder = (encoder_struct_x265*) encoder_raw;
+
+
+    // close previous encoder if there is still one hanging around
   if (encoder->encoder) {
     const x265_api* api = x265_api_get(encoder->bit_depth);
     api->encoder_close(encoder->encoder);
@@ -659,6 +767,7 @@ static struct heif_error x265_encode_image(void* encoder_raw, const struct heif_
   heif_chroma chroma = heif_image_get_chroma_format(image);
 
   const x265_api* api = x265_api_get(bit_depth);
+  encoder->api = api;
   if (api == nullptr) {
     struct heif_error err = {
         heif_error_Encoder_plugin_error,
@@ -669,9 +778,21 @@ static struct heif_error x265_encode_image(void* encoder_raw, const struct heif_
   }
 
   x265_param* param = api->param_alloc();
+  if (encoder->param) {
+    api->param_free(encoder->param);
+  }
+  encoder->param = param;
+
   api->param_default_preset(param, encoder->preset.c_str(), encoder->tune.c_str());
 
-  if (bit_depth == 8) api->param_apply_profile(param, "mainstillpicture");
+  if (bit_depth == 8) {
+    if (image_sequence) {
+      api->param_apply_profile(param, "main");
+    }
+    else {
+      api->param_apply_profile(param, "mainstillpicture");
+    }
+  }
   else if (bit_depth == 10) api->param_apply_profile(param, "main10-intra");
   else if (bit_depth == 12) api->param_apply_profile(param, "main12-intra");
   else {
@@ -680,10 +801,6 @@ static struct heif_error x265_encode_image(void* encoder_raw, const struct heif_
   }
 
 
-  param->fpsNum = 1;
-  param->fpsDenom = 1;
-
-
   // x265 cannot encode images smaller than one CTU size
   // https://bitbucket.org/multicoreware/x265/issues/475/x265-does-not-allow-image-sizes-smaller
   // -> use smaller CTU sizes for very small images
@@ -699,12 +816,11 @@ static struct heif_error x265_encode_image(void* encoder_raw, const struct heif_
 
   if (ctuSize < 16) {
     api->param_free(param);
-    struct heif_error err = {
+    return {
         heif_error_Encoder_plugin_error,
         heif_suberror_Invalid_parameter_value,
         kError_unsupported_image_size
     };
-    return err;
   }
 #else
   // TODO: There seems to be a bug in x265 where increasing the CTU size between
@@ -736,18 +852,41 @@ static struct heif_error x265_encode_image(void* encoder_raw, const struct heif_
       ctu = "16";
       break;
     default:
-      struct heif_error err = {
+      return {
           heif_error_Encoder_plugin_error,
           heif_suberror_Invalid_parameter_value,
-          kError_unsupported_image_size
+          kError_unsupported_ctu_size
       };
-      return err;
+  }
+
+  if (options) {
+    if (options->keyframe_distance_min) {
+      param->keyframeMin = options->keyframe_distance_min;
+    }
+
+    if (options->keyframe_distance_max) {
+      param->keyframeMax = options->keyframe_distance_max;
+    }
+
+    switch (options->gop_structure) {
+      case heif_sequence_gop_structure_intra_only:
+        param->bframes = 0;
+        param->keyframeMin=1;
+        param->keyframeMax=1;
+        break;
+      case heif_sequence_gop_structure_lowdelay:
+        param->bframes = 0;
+        break;
+      case heif_sequence_gop_structure_unrestricted:
+        param->bframes = 1;
+        break;
+    }
   }
 
   // BPG uses CQP. It does not seem to be better though.
   //  param->rc.rateControlMode = X265_RC_CQP;
   //  param->rc.qp = (100 - encoder->quality)/2;
-  param->totalFrames = 1;
+  param->totalFrames = image_sequence ? 0 : 1; // TODO
 
   if (isGreyscale) {
     param->internalCsp = X265_CSP_I400;
@@ -772,6 +911,8 @@ static struct heif_error x265_encode_image(void* encoder_raw, const struct heif_
     assert(heif_image_get_width(image, heif_channel_Cr)==w);
     assert(heif_image_get_height(image, heif_channel_Cb)==h);
     assert(heif_image_get_height(image, heif_channel_Cr)==h);
+    (void) w;
+    (void) h;
   }
 
   api->param_parse(param, "info", "0");
@@ -786,9 +927,17 @@ static struct heif_error x265_encode_image(void* encoder_raw, const struct heif_
   api->param_parse(param, "psy-rd", "1.0");
   api->param_parse(param, "psy-rdoq", "1.0");
 
-  auto nclx = image->image->get_color_profile_nclx();
+  heif_color_profile_nclx* nclx = nullptr;
+  heif_error err = heif_image_get_nclx_color_profile(image, &nclx);
+  if (err.code != heif_error_Ok) {
+    assert(nclx == nullptr);
+  }
+
+  // make sure NCLX profile is deleted at end of function
+  auto nclx_deleter = std::unique_ptr<heif_color_profile_nclx, void (*)(heif_color_profile_nclx*)>(nclx, heif_nclx_color_profile_free);
+
   if (nclx) {
-    api->param_parse(param, "range", nclx->get_full_range_flag() ? "full" : "limited");
+    api->param_parse(param, "range", nclx->full_range_flag ? "full" : "limited");
   }
   else {
     api->param_parse(param, "range", "full");
@@ -800,19 +949,19 @@ static struct heif_error x265_encode_image(void* encoder_raw, const struct heif_
 
     {
       std::stringstream sstr;
-      sstr << nclx->get_colour_primaries();
+      sstr << nclx->color_primaries;
       api->param_parse(param, "colorprim", sstr.str().c_str());
     }
 
     {
       std::stringstream sstr;
-      sstr << nclx->get_transfer_characteristics();
+      sstr << nclx->transfer_characteristics;
       api->param_parse(param, "transfer", sstr.str().c_str());
     }
 
     {
       std::stringstream sstr;
-      sstr << nclx->get_matrix_coefficients();
+      sstr << nclx->matrix_coefficients;
       api->param_parse(param, "colormatrix", sstr.str().c_str());
     }
   }
@@ -829,9 +978,8 @@ static struct heif_error x265_encode_image(void* encoder_raw, const struct heif_
       param->bLossless = p.value_int;
     }
     else if (p.name == kParam_TU_intra_depth) {
-      char buf[100];
-      sprintf(buf, "%d", p.value_int);
-      api->param_parse(param, "tu-intra-depth", buf);
+      auto valString = std::to_string(p.value_int);
+      api->param_parse(param, "tu-intra-depth", valString.c_str());
     }
     else if (p.name == kParam_complexity) {
       const int complexity = p.value_int;
@@ -851,7 +999,15 @@ static struct heif_error x265_encode_image(void* encoder_raw, const struct heif_
     }
     else if (strncmp(p.name.c_str(), "x265:", 5) == 0) {
       std::string x265p = p.name.substr(5);
-      api->param_parse(param, x265p.c_str(), p.value_string.c_str());
+      if (api->param_parse(param, x265p.c_str(), p.value_string.c_str()) < 0) {
+        encoder->last_error_message = std::string{"Unsupported x265 encoder parameter: "} + x265p;
+
+        return {
+          .code = heif_error_Usage_error,
+          .subcode = heif_suberror_Unsupported_parameter,
+          .message = encoder->last_error_message.c_str()
+        };
+      }
     }
   }
 
@@ -865,18 +1021,74 @@ static struct heif_error x265_encode_image(void* encoder_raw, const struct heif_
   param->sourceWidth = rounded_size(param->sourceWidth);
   param->sourceHeight = rounded_size(param->sourceHeight);
 
-  bool success = image->image->extend_padding_to_size(param->sourceWidth, param->sourceHeight);
-  if (!success) {
-    struct heif_error err = {
-        heif_error_Memory_allocation_error,
-        heif_suberror_Unspecified,
-        kError_out_of_memory
+  param->fpsNum = framerate_num;
+  param->fpsDenom = framerate_denom;
+
+  encoder->bit_depth = bit_depth;
+
+  encoder->encoder = api->encoder_open(param);
+
+  if (image_sequence) {
+    x265_nal* nals = nullptr;
+    uint32_t num_nals = 0;
+
+    api->encoder_headers(encoder->encoder,
+                         &nals,
+                         &num_nals);
+
+    encoder->append_nal_packets(nals, num_nals, 0);
+
+    for (uint32_t i = 0; i < num_nals; i++) {
+      //std::cout << "dequeue header NAL : " << naltype(encoder->nals[i].type) << "\n";
+    }
+  }
+
+  return heif_error_ok;
+}
+
+
+static heif_error x265_start_sequence_encoding(void* encoder_raw, const heif_image* image,
+                                       enum heif_image_input_class input_class,
+                                       uint32_t framerate_num, uint32_t framerate_denom,
+                                       const heif_sequence_encoding_options* options)
+{
+  return x265_start_sequence_encoding_intern(encoder_raw, image, input_class,
+                                             framerate_num, framerate_denom, options, true);
+}
+
+
+static heif_error x265_encode_sequence_frame(void* encoder_raw, const heif_image* image,
+                                             uintptr_t frame_nr)
+{
+  encoder_struct_x265* encoder = (encoder_struct_x265*) encoder_raw;
+
+  if (!encoder->api) {
+    return {
+      heif_error_Usage_error,
+      heif_suberror_Unspecified,
+      "called plugin encode_sequence_frame() without start_sequence_encoding()"
     };
+  }
+
+  const x265_api* api = encoder->api;
+
+  heif_error err;
+
+  // Note: it is ok to cast away the const, as the image content is not changed.
+  // However, we have to guarantee that there are no plane pointers or stride values kept over calling the svt_encode_image() function.
+  err = heif_image_extend_padding_to_size(const_cast<heif_image*>(image),
+                                          encoder->param->sourceWidth,
+                                          encoder->param->sourceHeight);
+  if (err.code) {
     return err;
   }
 
   x265_picture* pic = api->picture_alloc();
-  api->picture_init(param, pic);
+  api->picture_init(encoder->param, pic);
+
+  // TODO: check that all input images use the same color format
+
+  bool isGreyscale = (heif_image_get_colorspace(image) == heif_colorspace_monochrome);
 
   if (isGreyscale) {
     pic->planes[0] = (void*) heif_image_get_plane_readonly(image, heif_channel_Y, &pic->stride[0]);
@@ -887,97 +1099,156 @@ static struct heif_error x265_encode_image(void* encoder_raw, const struct heif_
     pic->planes[2] = (void*) heif_image_get_plane_readonly(image, heif_channel_Cr, &pic->stride[2]);
   }
 
-  pic->bitDepth = bit_depth;
-
+  pic->bitDepth = encoder->bit_depth;
+  pic->userData = reinterpret_cast<void*>(frame_nr);
 
-  encoder->bit_depth = bit_depth;
-
-  encoder->encoder = api->encoder_open(param);
+  x265_nal* nals = nullptr;
+  uint32_t num_nals = 0;
 
+#if X265_BUILD == 212
+  // In x265 build version 212, the signature of the encoder_encode() function was changed. But it was changed back in version 213.
+  // https://bitbucket.org/multicoreware/x265_git/issues/952/crash-in-libheif-tests
+  x265_picture* out_pic = NULL;
   api->encoder_encode(encoder->encoder,
-                      &encoder->nals,
-                      &encoder->num_nals,
+                      &nals,
+                      &num_nals,
                       pic,
-                      NULL);
+                      &out_pic);
+  uintptr_t frameNr = reinterpret_cast<uintptr_t>(out_pic->userData);
+#else
+  x265_picture out_pic;
+  api->encoder_encode(encoder->encoder,
+                      &nals,
+                      &num_nals,
+                      pic,
+                      &out_pic);
 
-  api->picture_free(pic);
-  api->param_free(param);
+  uintptr_t frameNr = reinterpret_cast<uintptr_t>(out_pic.userData);
+  for (uint32_t i = 0; i < num_nals; i++) {
+    //std::cout << " dequeue frame " << encoder->out_frameNr << ": " << naltype(encoder->nals[i].type) << "\n";
+  }
 
-  encoder->nal_output_counter = 0;
+  encoder->append_nal_packets(nals, num_nals, frameNr);
+
+#endif
+
+  api->picture_free(pic);
 
   return heif_error_ok;
 }
 
 
-static struct heif_error x265_get_compressed_data(void* encoder_raw, uint8_t** data, int* size,
-                                                  enum heif_encoded_data_type* type)
+static heif_error x265_end_sequence_encoding(void* encoder_raw)
 {
-  struct encoder_struct_x265* encoder = (struct encoder_struct_x265*) encoder_raw;
+  encoder_struct_x265* encoder = (encoder_struct_x265*) encoder_raw;
 
+  const x265_api* api = encoder->api;
 
-  if (encoder->encoder == nullptr) {
-    *data = nullptr;
-    *size = 0;
+  x265_nal* nals = nullptr;
+  uint32_t num_nals = 0;
 
-    return heif_error_ok;
+#if X265_BUILD == 212
+  x265_picture* out_pic = NULL;
+  int result = api->encoder_encode(encoder->encoder,
+                                   &nals,
+                                   &num_nals,
+                                   NULL,
+                                   &out_pic);
+  uintptr_t frameNr = reinterpret_cast<uintptr_t>(out_pic->userData);
+#else
+  x265_picture out_pic;
+  int result = api->encoder_encode(encoder->encoder,
+                                   &nals,
+                                   &num_nals,
+                                   NULL,
+                                   &out_pic);
+  uintptr_t frameNr = reinterpret_cast<uintptr_t>(out_pic.userData);
+
+  for (uint32_t i = 0; i < num_nals; i++) {
+    //std::cout << "EOS flush, frame " << encoder->out_frameNr << ": " << naltype(encoder->nals[i].type) << "\n";
   }
+#endif
+  if (result <= 0) {
+    // TODO: do we need this ?
+    //*data = nullptr;
+    //*size = 0;
 
-  const x265_api* api = x265_api_get(encoder->bit_depth);
+    return heif_error_ok; // ?
+  }
 
-  for (;;) {
-    while (encoder->nal_output_counter < encoder->num_nals) {
-      *data = encoder->nals[encoder->nal_output_counter].payload;
-      *size = encoder->nals[encoder->nal_output_counter].sizeBytes;
-      encoder->nal_output_counter++;
+  encoder->append_nal_packets(nals, num_nals, frameNr);
 
-      // --- skip start code ---
+  encoder->api->param_free(encoder->param);
+  encoder->param = nullptr;
 
-      // skip '0' bytes
-      while (**data == 0 && *size > 0) {
-        (*data)++;
-        (*size)--;
-      }
+  return heif_error_ok;
+}
 
-      // skip '1' byte
-      (*data)++;
-      (*size)--;
 
+static heif_error x265_encode_image(void* encoder_raw, const heif_image* image,
+                                    heif_image_input_class input_class)
+{
+  heif_error err;
+  err = x265_start_sequence_encoding_intern(encoder_raw, image, input_class, 1,25, nullptr, false);
+  if (err.code) {
+    return err;
+  }
 
-      // --- skip NALs with irrelevant data ---
+  err = x265_encode_sequence_frame(encoder_raw, image, 0);
+  if (err.code) {
+    return err;
+  }
 
-      if (*size >= 3 && (*data)[0] == 0x4e && (*data)[2] == 5) {
-        // skip "unregistered user data SEI"
+  x265_end_sequence_encoding(encoder_raw);
 
-      }
-      else {
-        // output NAL
+  return heif_error_ok;
+}
 
-        return heif_error_ok;
-      }
-    }
 
+static heif_error x265_get_compressed_data_intern(void* encoder_raw, uint8_t** data, int* size,
+                                                  uintptr_t* out_frame_nr)
+{
+  encoder_struct_x265* encoder = ( encoder_struct_x265*) encoder_raw;
 
-    encoder->nal_output_counter = 0;
+  if (encoder->output_data.empty()) {
+    *data = nullptr;
+    *size = 0;
 
+    return heif_error_ok;
+  }
 
-    int result = api->encoder_encode(encoder->encoder,
-                                     &encoder->nals,
-                                     &encoder->num_nals,
-                                     NULL,
-                                     NULL);
-    if (result <= 0) {
-      *data = nullptr;
-      *size = 0;
+  encoder->active_output_nal = std::move(encoder->output_data.front().data);
 
-      return heif_error_ok;
-    }
+  if (out_frame_nr) {
+    *out_frame_nr = encoder->output_data.front().frameNr;
   }
+
+  encoder->output_data.pop_front();
+
+  *data = encoder->active_output_nal.data();
+  *size = static_cast<int>(encoder->active_output_nal.size());
+
+  return heif_error_ok;
 }
 
 
-static const struct heif_encoder_plugin encoder_plugin_x265
+static heif_error x265_get_compressed_data(void* encoder_raw, uint8_t** data, int* size,
+                                           heif_encoded_data_type* type)
+{
+  return x265_get_compressed_data_intern(encoder_raw, data, size, nullptr);
+}
+
+static heif_error x265_get_compressed_data2(void* encoder_raw, uint8_t** data, int* size,
+                                            uintptr_t* frame_nr, int* is_keyframe,
+                                            int* more_frame_packets)
+{
+  return x265_get_compressed_data_intern(encoder_raw, data, size, frame_nr);
+}
+
+
+static const heif_encoder_plugin encoder_plugin_x265
     {
-        /* plugin_api_version */ 2,
+        /* plugin_api_version */ 4,
         /* compression_format */ heif_compression_HEVC,
         /* id_name */ "x265",
         /* priority */ X265_PLUGIN_PRIORITY,
@@ -1004,10 +1275,26 @@ static const struct heif_encoder_plugin encoder_plugin_x265
         /* query_input_colorspace */ x265_query_input_colorspace,
         /* encode_image */ x265_encode_image,
         /* get_compressed_data */ x265_get_compressed_data,
-        /* query_input_colorspace (v2) */ x265_query_input_colorspace2
+        /* query_input_colorspace (v2) */ x265_query_input_colorspace2,
+        /* query_encoded_size (v3) */ nullptr,
+        /* minimum_required_libheif_version */ LIBHEIF_MAKE_VERSION(1,21,0),
+        /* start_sequence_encoding (v4) */ x265_start_sequence_encoding,
+        /* encode_sequence_frame (v4) */ x265_encode_sequence_frame,
+        /* end_sequence_encoding (v4) */ x265_end_sequence_encoding,
+        /* get_compressed_data2 (v4) */ x265_get_compressed_data2,
+        /* does_indicate_keyframes (v4) */ 0
     };
 
-const struct heif_encoder_plugin* get_encoder_plugin_x265()
+const heif_encoder_plugin* get_encoder_plugin_x265()
 {
   return &encoder_plugin_x265;
 }
+
+
+#if PLUGIN_X265
+heif_plugin_info plugin_info {
+  1,
+  heif_plugin_type_encoder,
+  &encoder_plugin_x265
+};
+#endif
diff --git a/libheif/heif_encoder_x265.h b/libheif/plugins/encoder_x265.h
similarity index 83%
rename from libheif/heif_encoder_x265.h
rename to libheif/plugins/encoder_x265.h
index d39a147d31..4869280e23 100644
--- a/libheif/heif_encoder_x265.h
+++ b/libheif/plugins/encoder_x265.h
@@ -1,6 +1,6 @@
 /*
  * HEIF codec.
- * Copyright (c) 2017 struktur AG, Dirk Farin <farin@struktur.de>
+ * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>x
  *
  * This file is part of libheif.
  *
@@ -18,9 +18,10 @@
  * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef LIBHEIF_HEIF_ENCODER_X265_H
-#define LIBHEIF_HEIF_ENCODER_X265_H
+#ifndef LIBHEIF_ENCODER_X265_H
+#define LIBHEIF_ENCODER_X265_H
 
+#include "common_utils.h"
 
 /* Image sizes in HEVC: since HEVC does not allow for odd image dimensions when
    using chroma 4:2:0, our strategy is as follows.
@@ -35,4 +36,10 @@
 
 const struct heif_encoder_plugin* get_encoder_plugin_x265();
 
+#if PLUGIN_X265
+extern "C" {
+MAYBE_UNUSED LIBHEIF_API extern heif_plugin_info plugin_info;
+}
+#endif
+
 #endif
diff --git a/libheif/plugins/nalu_utils.cc b/libheif/plugins/nalu_utils.cc
new file mode 100644
index 0000000000..f4f3731d60
--- /dev/null
+++ b/libheif/plugins/nalu_utils.cc
@@ -0,0 +1,97 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <map>
+#include <memory>
+#include <utility>
+#include "nalu_utils.h"
+
+NalUnit::NalUnit()
+{
+    nal_data_ptr = NULL;
+    nal_unit_type = 0;
+    nal_data_size = 0;
+}
+
+bool NalUnit::set_data(const unsigned char* in_data, int n)
+{
+    nal_data_ptr = in_data;
+    nal_unit_type = bitExtracted(nal_data_ptr[0], 6, 2);
+    nal_data_size = n;
+    return true;
+}
+
+int NalUnit::bitExtracted(int number, int bits_count, int position_nr)
+{
+    return (((1 << bits_count) - 1) & (number >> (position_nr - 1)));
+}
+
+size_t NalMap::count(int nal_type)
+{
+    return map.count(nal_type);
+}
+
+const unsigned char* NalMap::data(int nal_type) 
+{
+    return map[nal_type]->data();
+}
+
+int NalMap::size(int nal_type) 
+{
+    return map[nal_type]->size();
+}
+
+const heif_error NalMap::parseHevcNalu(const uint8_t *cdata, size_t size)
+{
+    size_t ptr = 0;
+    while (ptr < size)
+    {
+        if (4 > size - ptr)
+        {
+            struct heif_error err = {heif_error_Decoder_plugin_error,
+                                    heif_suberror_End_of_data,
+                                    "insufficient data"};
+            return err;
+        }
+
+        uint32_t nal_size = (cdata[ptr] << 24) | (cdata[ptr + 1] << 16) | (cdata[ptr + 2] << 8) | (cdata[ptr + 3]);
+        ptr += 4;
+
+        if (nal_size > size - ptr)
+        {
+            struct heif_error err = {heif_error_Decoder_plugin_error,
+                                    heif_suberror_End_of_data,
+                                    "insufficient data"};
+            return err;
+        }
+
+        std::unique_ptr<NalUnit> nal_unit = std::unique_ptr<NalUnit>(new NalUnit());
+        nal_unit->set_data(cdata + ptr, nal_size);
+
+        // overwrite NalMap (frees old NalUnit, if it was set)
+        map[nal_unit->unit_type()] = std::move(nal_unit);
+
+        ptr += nal_size;
+    }
+
+    return heif_error_success;
+}
+
+void NalMap::clear() { map.clear(); }
\ No newline at end of file
diff --git a/libheif/plugins/nalu_utils.h b/libheif/plugins/nalu_utils.h
new file mode 100644
index 0000000000..d6500319b2
--- /dev/null
+++ b/libheif/plugins/nalu_utils.h
@@ -0,0 +1,74 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <map>
+#include <memory>
+#include "libheif/heif.h"
+
+static const int AVC_NAL_UNIT_MAX_VCL    = 5;
+static const int AVC_NAL_UNIT_SPS_NUT    = 7;
+static const int AVC_NAL_UNIT_PPS_NUT    = 8;
+static const int AVC_NAL_UNIT_SPS_EXT_NUT = 13;
+
+static const int HEVC_NAL_UNIT_MAX_VCL    = 31;
+static const int HEVC_NAL_UNIT_VPS_NUT    = 32;
+static const int HEVC_NAL_UNIT_SPS_NUT    = 33;
+static const int HEVC_NAL_UNIT_PPS_NUT    = 34;
+static const int HEVC_NAL_UNIT_IDR_W_RADL = 19;
+static const int HEVC_NAL_UNIT_IDR_N_LP   = 20;
+
+static const int VVC_NAL_UNIT_MAX_VCL    = 11;
+static const int VVC_NAL_UNIT_VPS_NUT    = 14;
+static const int VVC_NAL_UNIT_SPS_NUT    = 15;
+static const int VVC_NAL_UNIT_PPS_NUT    = 16;
+static const int VVC_NAL_UNIT_SUFFIX_SEI_NUT = 24;
+
+
+class NalUnit
+{
+public:
+    NalUnit();
+    ~NalUnit() = default;
+    bool set_data(const unsigned char* in_data, int n);
+    int size() const { return nal_data_size; }
+    int unit_type() const { return nal_unit_type;  }
+    const unsigned char* data() const { return nal_data_ptr; }
+    int bitExtracted(int number, int bits_count, int position_nr);
+private:
+    const unsigned char* nal_data_ptr;
+    int nal_unit_type;
+    int nal_data_size;
+};
+
+class NalMap
+{
+public:
+    size_t count(int nal_type);
+
+    const unsigned char* data(int nal_type);
+
+    int size(int nal_type);
+
+    const heif_error parseHevcNalu(const uint8_t *cdata, size_t size);
+
+    void clear();
+private:
+    std::map<int, std::unique_ptr<NalUnit>> map;
+};
\ No newline at end of file
diff --git a/libheif/plugins_unix.cc b/libheif/plugins_unix.cc
new file mode 100644
index 0000000000..e7ca9e6666
--- /dev/null
+++ b/libheif/plugins_unix.cc
@@ -0,0 +1,119 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "plugins_unix.h"
+#include "libheif/heif_plugin.h"
+#include <sstream>
+
+#include <dlfcn.h>
+#include <cstring>
+
+#ifndef _DEFAULT_SOURCE
+#define _DEFAULT_SOURCE
+#endif
+#include <dirent.h>
+
+
+std::vector<std::string> get_plugin_directories_from_environment_variable_unix()
+{
+  char* path_variable = getenv("LIBHEIF_PLUGIN_PATH");
+  if (path_variable == nullptr) {
+    return {};
+  }
+
+  // --- split LIBHEIF_PLUGIN_PATH value at ':' into separate directories
+
+  std::vector<std::string> plugin_paths;
+
+  std::istringstream paths(path_variable);
+  std::string dir;
+  while (getline(paths, dir, ':')) {
+    plugin_paths.push_back(dir);
+  }
+
+  return plugin_paths;
+}
+
+
+std::vector<std::string> list_all_potential_plugins_in_directory_unix(const char* directory)
+{
+  std::vector<std::string> result;
+
+  DIR* dir = opendir(directory);
+  if (dir == nullptr) {
+    return {}; // TODO: return error_cannot_read_plugin_directory;
+  }
+
+  struct dirent* d;
+  for (;;) {
+    d = readdir(dir);
+    if (d == nullptr) {
+      break;
+    }
+
+    bool correct_filetype = true;
+#ifdef DT_REG
+    correct_filetype = (d->d_type == DT_REG || d->d_type == DT_LNK || d->d_type == DT_UNKNOWN);
+#endif
+
+    if (correct_filetype &&
+	strlen(d->d_name) > 3 &&
+        strcmp(d->d_name + strlen(d->d_name) - 3, ".so") == 0) {
+      std::string filename = directory;
+      filename += '/';
+      filename += d->d_name;
+      //printf("load %s\n", filename.c_str());
+
+      result.push_back(filename);
+    }
+  }
+
+  closedir(dir);
+
+  return result;
+}
+
+
+heif_error PluginLibrary_Unix::load_from_file(const char* filename)
+{
+  m_library_handle = dlopen(filename, RTLD_LAZY);
+  if (!m_library_handle) {
+    fprintf(stderr, "dlopen: %s\n", dlerror());
+    return error_dlopen;
+  }
+
+  m_plugin_info = (heif_plugin_info*) dlsym(m_library_handle, "plugin_info");
+  if (!m_plugin_info) {
+    fprintf(stderr, "dlsym: %s\n", dlerror());
+    return error_dlopen;
+  }
+
+  return heif_error_ok;
+}
+
+void PluginLibrary_Unix::release()
+{
+  if (m_library_handle) {
+    dlclose(m_library_handle);
+    m_library_handle = nullptr;
+  }
+}
+
diff --git a/libheif/plugins_unix.h b/libheif/plugins_unix.h
new file mode 100644
index 0000000000..25681cb4cc
--- /dev/null
+++ b/libheif/plugins_unix.h
@@ -0,0 +1,51 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_PLUGINS_UNIX_H
+#define LIBHEIF_PLUGINS_UNIX_H
+
+#include <vector>
+#include <string>
+#include "init.h"
+
+std::vector<std::string> get_plugin_directories_from_environment_variable_unix();
+
+std::vector<std::string> list_all_potential_plugins_in_directory_unix(const char*);
+
+class PluginLibrary_Unix : public PluginLibrary
+{
+public:
+  heif_error load_from_file(const char* filename) override;
+
+  void release() override;
+
+  heif_plugin_info* get_plugin_info() override { return m_plugin_info; }
+
+  bool operator==(const PluginLibrary_Unix& b) const
+  {
+    return m_library_handle == b.m_library_handle;
+  }
+
+private:
+  void* m_library_handle = nullptr;
+  heif_plugin_info* m_plugin_info = nullptr;
+};
+
+#endif //LIBHEIF_PLUGINS_UNIX_H
diff --git a/libheif/plugins_windows.cc b/libheif/plugins_windows.cc
new file mode 100644
index 0000000000..b11cec9440
--- /dev/null
+++ b/libheif/plugins_windows.cc
@@ -0,0 +1,109 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "plugins_windows.h"
+#include "libheif/heif_plugin.h"
+#include <sstream>
+
+
+std::vector<std::string> get_plugin_directories_from_environment_variable_windows()
+{
+  char* path_variable = getenv("LIBHEIF_PLUGIN_PATH");
+  if (path_variable == nullptr) {
+    return {};
+  }
+
+  // --- split LIBHEIF_PLUGIN_PATH value at ';' into separate directories
+
+  std::vector<std::string> plugin_paths;
+
+  std::istringstream paths(path_variable);
+  std::string dir;
+  while (getline(paths, dir, ';')) {
+    plugin_paths.push_back(dir);
+  }
+
+  return plugin_paths;
+}
+
+
+std::vector<std::string> list_all_potential_plugins_in_directory_windows(const char* directory)
+{
+  std::vector<std::string> result;
+
+  HANDLE hFind;
+  WIN32_FIND_DATA FindFileData;
+
+  std::string findPattern{directory};
+  findPattern += "\\*.dll";
+
+#if 0
+  DIR* dir = opendir(directory);
+  if (dir == nullptr) {
+    return error_cannot_read_plugin_directory;
+  }
+#endif
+
+ if ((hFind = FindFirstFile(findPattern.c_str(), &FindFileData)) != INVALID_HANDLE_VALUE) {
+    do {
+      std::string filename = directory;
+      filename += '/';
+      filename += FindFileData.cFileName;
+
+      result.push_back(filename);
+    } while (FindNextFile(hFind, &FindFileData));
+
+    FindClose(hFind);
+  }
+
+  return result;
+}
+
+
+
+heif_error PluginLibrary_Windows::load_from_file(const char* filename)
+{
+  m_library_handle = LoadLibraryA(filename);
+  if (!m_library_handle) {
+    fprintf(stderr, "LoadLibraryA error: %lu\n", GetLastError());
+    return error_dlopen;
+  }
+
+  m_plugin_info = (heif_plugin_info*) GetProcAddress(m_library_handle, "plugin_info");
+  if (!m_plugin_info) {
+    fprintf(stderr, "GetProcAddress error for dll '%s': %lu\n", filename, GetLastError());
+    return error_dlopen;
+  }
+
+  // Remember filename for comparison whether the plugin was already loaded.
+  // We need this since LoadLibraryA() returns a separate instance if we load the same DLL twice.
+  m_filename = filename;
+
+  return heif_error_ok;
+}
+
+void PluginLibrary_Windows::release()
+{
+  if (m_library_handle) {
+    FreeLibrary(m_library_handle);
+    m_library_handle = nullptr;
+  }
+}
diff --git a/libheif/plugins_windows.h b/libheif/plugins_windows.h
new file mode 100644
index 0000000000..f7660d7619
--- /dev/null
+++ b/libheif/plugins_windows.h
@@ -0,0 +1,54 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef LIBHEIF_PLUGINS_WINDOWS_H
+#define LIBHEIF_PLUGINS_WINDOWS_H
+
+#include <vector>
+#include <string>
+#include "init.h"
+#include <windows.h>
+
+std::vector<std::string> get_plugin_directories_from_environment_variable_windows();
+
+std::vector<std::string> list_all_potential_plugins_in_directory_windows(const char*);
+
+class PluginLibrary_Windows : public PluginLibrary
+{
+public:
+  heif_error load_from_file(const char* filename) override;
+
+  void release() override;
+
+  heif_plugin_info* get_plugin_info() override { return m_plugin_info; }
+
+  bool operator==(const PluginLibrary_Windows& b) const
+  {
+    return m_filename == b.m_filename;
+  }
+
+private:
+  std::string m_filename;
+  HMODULE m_library_handle = nullptr;
+  heif_plugin_info* m_plugin_info = nullptr;
+};
+
+#endif //LIBHEIF_PLUGINS_WINDOWS_H
diff --git a/libheif/region.cc b/libheif/region.cc
new file mode 100644
index 0000000000..591566ef39
--- /dev/null
+++ b/libheif/region.cc
@@ -0,0 +1,635 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "region.h"
+#include "error.h"
+#include "file.h"
+#include "box.h"
+#include "libheif/heif_regions.h"
+#include <algorithm>
+#include <utility>
+#include <limits>
+
+
+Error RegionItem::parse(const std::vector<uint8_t>& data,
+                        const heif_security_limits* limits)
+{
+  if (data.size() < 8) {
+    return Error(heif_error_Invalid_input, heif_suberror_Invalid_region_data,
+                 "Less than 8 bytes of data");
+  }
+
+  uint8_t version = data[0];
+  (void) version; // version is unused
+
+  uint8_t flags = data[1];
+  int field_size = ((flags & 1) ? 32 : 16);
+
+  unsigned int dataOffset;
+  if (field_size == 32) {
+    if (data.size() < 12) {
+      return Error(heif_error_Invalid_input, heif_suberror_Invalid_region_data,
+                   "Region data incomplete");
+    }
+    reference_width = four_bytes_to_uint32(data[2], data[3], data[4], data[5]);
+    reference_height = four_bytes_to_uint32(data[6], data[7], data[8], data[9]);
+    dataOffset = 10;
+  }
+  else {
+    reference_width = four_bytes_to_uint32(0, 0, data[2], data[3]);
+    reference_height = four_bytes_to_uint32(0, 0, data[4], data[5]);
+    dataOffset = 6;
+  }
+
+  uint8_t region_count = data[dataOffset];
+  dataOffset += 1;
+  for (int i = 0; i < region_count; i++) {
+    if (data.size() <= dataOffset) {
+      return Error(heif_error_Invalid_input, heif_suberror_Invalid_region_data,
+                   "Region data incomplete");
+    }
+
+    uint8_t geometry_type = data[dataOffset];
+    dataOffset += 1;
+
+    std::shared_ptr<RegionGeometry> region;
+
+    if (geometry_type == heif_region_type_point) {
+      region = std::make_shared<RegionGeometry_Point>();
+    }
+    else if (geometry_type == heif_region_type_rectangle) {
+      region = std::make_shared<RegionGeometry_Rectangle>();
+    }
+    else if (geometry_type == heif_region_type_ellipse) {
+      region = std::make_shared<RegionGeometry_Ellipse>();
+    }
+    else if (geometry_type == heif_region_type_polygon) {
+      auto polygon = std::make_shared<RegionGeometry_Polygon>();
+      polygon->closed = true;
+      region = polygon;
+    }
+    else if (geometry_type == heif_region_type_referenced_mask) {
+      region = std::make_shared<RegionGeometry_ReferencedMask>();
+    }
+    else if (geometry_type == heif_region_type_inline_mask) {
+      region = std::make_shared<RegionGeometry_InlineMask>();
+    }
+    else if (geometry_type == heif_region_type_polyline) {
+      auto polygon = std::make_shared<RegionGeometry_Polygon>();
+      polygon->closed = false;
+      region = polygon;
+    }
+    else {
+      //     // TODO: this isn't going to work - we can only exit here.
+      //   std::cout << "ignoring unsupported region geometry type: "
+      //             << (int)geometry_type << std::endl;
+
+      continue;
+    }
+
+    Error error = region->parse(data, field_size, &dataOffset, limits);
+    if (error) {
+      return error;
+    }
+
+    mRegions.push_back(region);
+  }
+  return Error::Ok;
+}
+
+Error RegionItem::encode(std::vector<uint8_t>& result) const
+{
+  StreamWriter writer;
+
+  writer.write8(0);
+
+  // --- compute required field size
+
+  int field_size_bytes = 2;
+
+  if (reference_width <= 0xFFFF &&
+      reference_height <= 0xFFFF) {
+    field_size_bytes = 4;
+  }
+
+  if (field_size_bytes != 4) {
+    for (auto& region : mRegions) {
+      if (region->encode_needs_32bit()) {
+        field_size_bytes = 4;
+        break;
+      }
+    }
+  }
+
+  // --- write flags
+
+  uint8_t flags = 0;
+
+  if (field_size_bytes == 4) {
+    flags |= 1;
+  }
+
+  writer.write8(flags);
+
+  // --- write reference size
+
+  writer.write(field_size_bytes, reference_width);
+  writer.write(field_size_bytes, reference_height);
+
+  // --- write regions
+
+  if (mRegions.size() >= 256) {
+    return Error(heif_error_Encoding_error, heif_suberror_Too_many_regions);
+  }
+
+  writer.write8((uint8_t) mRegions.size());
+
+  for (auto& region : mRegions) {
+    region->encode(writer, field_size_bytes);
+  }
+
+  result = writer.get_data();
+
+  return Error::Ok;
+}
+
+
+uint32_t RegionGeometry::parse_unsigned(const std::vector<uint8_t>& data,
+                                        int field_size,
+                                        unsigned int* dataOffset)
+{
+  uint32_t x;
+  if (field_size == 32) {
+    x = four_bytes_to_uint32(data[*dataOffset + 0],
+                             data[*dataOffset + 1],
+                             data[*dataOffset + 2],
+                             data[*dataOffset + 3]);
+    *dataOffset = *dataOffset + 4;
+  }
+  else {
+    x = four_bytes_to_uint32(0, 0, data[*dataOffset], data[*dataOffset + 1]);
+    *dataOffset = *dataOffset + 2;
+  }
+  return x;
+}
+
+int32_t RegionGeometry::parse_signed(const std::vector<uint8_t>& data,
+                                     int field_size,
+                                     unsigned int* dataOffset)
+{
+  if (field_size == 32) {
+    return (int32_t)parse_unsigned(data, field_size, dataOffset);
+  } else {
+    return (int16_t)parse_unsigned(data, field_size, dataOffset);
+  }
+}
+
+Error RegionGeometry_Point::parse(const std::vector<uint8_t>& data,
+                                  int field_size,
+                                  unsigned int* dataOffset,
+                                  const heif_security_limits* limits)
+{
+  unsigned int bytesRequired = (field_size / 8) * 2;
+  if (data.size() - *dataOffset < bytesRequired) {
+    return Error(heif_error_Invalid_input, heif_suberror_Invalid_region_data,
+                 "Insufficient data remaining for point region");
+  }
+  x = parse_signed(data, field_size, dataOffset);
+  y = parse_signed(data, field_size, dataOffset);
+
+  return Error::Ok;
+}
+
+
+static bool exceeds_s16(int32_t v)
+{
+  return (v > 32767 || v < -32768);
+}
+
+static bool exceeds_u16(uint32_t v)
+{
+  return v > 0xFFFF;
+}
+
+
+bool RegionGeometry_Point::encode_needs_32bit() const
+{
+  return exceeds_s16(x) || exceeds_s16(y);
+}
+
+
+void RegionGeometry_Point::encode(StreamWriter& writer, int field_size_bytes) const
+{
+  writer.write8(heif_region_type_point);
+  writer.write(field_size_bytes, x);
+  writer.write(field_size_bytes, y);
+}
+
+
+Error RegionGeometry_Rectangle::parse(const std::vector<uint8_t>& data,
+                                      int field_size,
+                                      unsigned int* dataOffset,
+                                      const heif_security_limits* limits)
+{
+  unsigned int bytesRequired = (field_size / 8) * 4;
+  if (data.size() - *dataOffset < bytesRequired) {
+    return Error(heif_error_Invalid_input, heif_suberror_Invalid_region_data,
+                 "Insufficient data remaining for rectangle region");
+  }
+  x = parse_signed(data, field_size, dataOffset);
+  y = parse_signed(data, field_size, dataOffset);
+  width = parse_unsigned(data, field_size, dataOffset);
+  height = parse_unsigned(data, field_size, dataOffset);
+  return Error::Ok;
+}
+
+
+bool RegionGeometry_Rectangle::encode_needs_32bit() const
+{
+  return exceeds_s16(x) || exceeds_s16(y) || exceeds_u16(width) || exceeds_u16(height);
+}
+
+
+void RegionGeometry_Rectangle::encode(StreamWriter& writer, int field_size_bytes) const
+{
+  writer.write8(heif_region_type_rectangle);
+  writer.write(field_size_bytes, x);
+  writer.write(field_size_bytes, y);
+  writer.write(field_size_bytes, width);
+  writer.write(field_size_bytes, height);
+}
+
+Error RegionGeometry_Ellipse::parse(const std::vector<uint8_t>& data,
+                                    int field_size,
+                                    unsigned int* dataOffset,
+                                    const heif_security_limits* limits)
+{
+  unsigned int bytesRequired = (field_size / 8) * 4;
+  if (data.size() - *dataOffset < bytesRequired) {
+    return Error(heif_error_Invalid_input, heif_suberror_Invalid_region_data,
+                 "Insufficient data remaining for ellipse region");
+  }
+  x = parse_signed(data, field_size, dataOffset);
+  y = parse_signed(data, field_size, dataOffset);
+  radius_x = parse_unsigned(data, field_size, dataOffset);
+  radius_y = parse_unsigned(data, field_size, dataOffset);
+  return Error::Ok;
+}
+
+bool RegionGeometry_Ellipse::encode_needs_32bit() const
+{
+  return exceeds_s16(x) || exceeds_s16(y) || exceeds_u16(radius_x) || exceeds_u16(radius_y);
+}
+
+
+void RegionGeometry_Ellipse::encode(StreamWriter& writer, int field_size_bytes) const
+{
+  writer.write8(heif_region_type_ellipse);
+  writer.write(field_size_bytes, x);
+  writer.write(field_size_bytes, y);
+  writer.write(field_size_bytes, radius_x);
+  writer.write(field_size_bytes, radius_y);
+}
+
+
+
+Error RegionGeometry_Polygon::parse(const std::vector<uint8_t>& data,
+                                    int field_size,
+                                    unsigned int* dataOffset,
+                                    const heif_security_limits* limits)
+{
+  uint32_t bytesRequired1 = (field_size / 8) * 1;
+  if (data.size() - *dataOffset < bytesRequired1) {
+    return Error(heif_error_Invalid_input, heif_suberror_Invalid_region_data,
+                 "Insufficient data remaining for polygon");
+  }
+
+  // Note: we need to do the calculation in uint64_t because numPoints may be any 32-bit number
+  // and it is multiplied by (at most) 8.
+
+  uint32_t numPoints = parse_unsigned(data, field_size, dataOffset);
+  uint64_t bytesRequired2 = (field_size / 8) * uint64_t(numPoints) * 2;
+  if (data.size() - *dataOffset < bytesRequired2) {
+    return Error(heif_error_Invalid_input, heif_suberror_Invalid_region_data,
+                 "Insufficient data remaining for polygon");
+  }
+
+  if (closed) {
+    if (numPoints < 3) {
+      return {
+        heif_error_Invalid_input,
+        heif_suberror_Unspecified,
+        "Region polygon with less than 3 points."
+      };
+    }
+  }
+  else {
+    if (numPoints < 2) {
+      return {
+        heif_error_Invalid_input,
+        heif_suberror_Unspecified,
+        "Region polyline with less than 2 points."
+      };
+    }
+  }
+
+  if (UINT32_MAX / numPoints < sizeof(Point)) {
+    return {
+      heif_error_Memory_allocation_error,
+      heif_suberror_Unspecified,
+      "Region polygon size exceeds integer range."
+    };
+  }
+
+  if (auto err = m_memory_handle.alloc(numPoints * sizeof(Point), limits, "region polygon")) {
+    return err;
+  }
+
+  for (uint32_t i = 0; i < numPoints; i++) {
+    Point p;
+    p.x = parse_signed(data, field_size, dataOffset);
+    p.y = parse_signed(data, field_size, dataOffset);
+    points.push_back(p);
+  }
+
+  return Error::Ok;
+}
+
+
+Error RegionGeometry_ReferencedMask::parse(const std::vector<uint8_t>& data,
+                                          int field_size,
+                                          unsigned int* dataOffset,
+                                          const heif_security_limits* limits)
+{
+  unsigned int bytesRequired = (field_size / 8) * 4;
+  if (data.size() - *dataOffset < bytesRequired) {
+    return Error(heif_error_Invalid_input, heif_suberror_Invalid_region_data,
+                 "Insufficient data remaining for referenced mask region");
+  }
+  x = parse_signed(data, field_size, dataOffset);
+  y = parse_signed(data, field_size, dataOffset);
+  width = parse_unsigned(data, field_size, dataOffset);
+  height = parse_unsigned(data, field_size, dataOffset);
+  return Error::Ok;
+}
+
+
+void RegionGeometry_ReferencedMask::encode(StreamWriter& writer, int field_size_bytes) const
+{
+  writer.write8(heif_region_type_referenced_mask);
+  writer.write(field_size_bytes, x);
+  writer.write(field_size_bytes, y);
+  writer.write(field_size_bytes, width);
+  writer.write(field_size_bytes, height);
+}
+
+bool RegionGeometry_Polygon::encode_needs_32bit() const
+{
+  if (exceeds_u16((uint32_t)points.size())) {
+    return true;
+  }
+
+  for (auto& p : points) {
+    if (exceeds_s16(p.x) || exceeds_s16(p.y)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+
+void RegionGeometry_Polygon::encode(StreamWriter& writer, int field_size_bytes) const
+{
+  writer.write8(closed ? heif_region_type_polygon : heif_region_type_polyline);
+
+  writer.write(field_size_bytes, points.size());
+
+  for (auto& p : points) {
+    writer.write(field_size_bytes, p.x);
+    writer.write(field_size_bytes, p.y);
+  }
+}
+
+
+Error RegionGeometry_InlineMask::parse(const std::vector<uint8_t>& data,
+                                       int field_size,
+                                       unsigned int* dataOffset,
+                                       const heif_security_limits* limits)
+{
+  unsigned int bytesRequired = (field_size / 8) * 4 + 1;
+  if (data.size() - *dataOffset < bytesRequired) {
+    return Error(heif_error_Invalid_input, heif_suberror_Invalid_region_data,
+                 "Insufficient data remaining for inline mask region");
+  }
+  x = parse_signed(data, field_size, dataOffset);
+  y = parse_signed(data, field_size, dataOffset);
+  width = parse_unsigned(data, field_size, dataOffset);
+  height = parse_unsigned(data, field_size, dataOffset);
+  uint8_t mask_coding_method = data[*dataOffset];
+  *dataOffset = *dataOffset + 1;
+
+  if (mask_coding_method != 0) {
+    return Error(heif_error_Invalid_input, heif_suberror_Invalid_region_data,
+                 "Deflate compressed inline mask is not yet supported");
+  }
+
+  if (width==0 || height==0) {
+    return {
+      heif_error_Invalid_input,
+      heif_suberror_Unspecified,
+      "Zero size mask image."
+    };
+  }
+
+  // Mask is stored with one bit per pixel, no padding exists at the end of the line.
+  // Only the very last byte is padded.
+
+  // error if:
+  // (width * height + 7) / 8 > UINT32_MAX
+  // more strict:
+  // (width * height + height) / 8 > UINT32_MAX
+  // width/8 * height + 1 > UINT32_MAX
+
+  uint64_t bytes_for_mask = (static_cast<uint64_t>(width) * height + 7) / 8;
+  if (bytes_for_mask > std::numeric_limits<ptrdiff_t>::max()) {
+    return {
+      heif_error_Memory_allocation_error,
+      heif_suberror_Unspecified,
+      "Mask image size exceeds maximum integer range."
+    };
+  }
+
+  if (limits->max_image_size_pixels / width < height) {
+    return {
+      heif_error_Memory_allocation_error,
+      heif_suberror_Security_limit_exceeded,
+      "Inline mask image exceeds maximum image size."
+    };
+  }
+
+  if (data.size() - *dataOffset < bytes_for_mask) {
+        return Error(heif_error_Invalid_input, heif_suberror_Invalid_region_data,
+                 "Insufficient data remaining for inline mask region data[]");
+  }
+
+  if (auto err = m_memory_handle.alloc(bytes_for_mask, limits, "region mask")) {
+    return err;
+  }
+
+  mask_data.resize(bytes_for_mask);
+  std::copy(data.begin() + *dataOffset, data.begin() + *dataOffset + static_cast<ptrdiff_t>(bytes_for_mask), mask_data.begin());
+  return Error::Ok;
+}
+
+
+void RegionGeometry_InlineMask::encode(StreamWriter& writer, int field_size_bytes) const
+{
+  writer.write8(heif_region_type_inline_mask);
+  writer.write(field_size_bytes, x);
+  writer.write(field_size_bytes, y);
+  writer.write(field_size_bytes, width);
+  writer.write(field_size_bytes, height);
+  writer.write8(0); // coding method
+  // if using some other coding method, there are parameters to write out here.
+  writer.write(mask_data);
+}
+
+
+RegionCoordinateTransform RegionCoordinateTransform::create(std::shared_ptr<HeifFile> file,
+                                                            heif_item_id item_id,
+                                                            int reference_width, int reference_height)
+{
+  std::vector<std::shared_ptr<Box>> properties;
+
+  Error err = file->get_properties(item_id, properties);
+  if (err) {
+    return {};
+  }
+
+  uint32_t image_width = 0, image_height = 0;
+
+  for (auto& property : properties) {
+    if (auto ispe = std::dynamic_pointer_cast<Box_ispe>(property)) {
+      image_width = ispe->get_width();
+      image_height = ispe->get_height();
+      break;
+    }
+  }
+
+  if (image_width == 0 || image_height == 0) {
+    return {};
+  }
+
+  RegionCoordinateTransform transform;
+  transform.a = image_width / (double) reference_width;
+  transform.d = image_height / (double) reference_height;
+
+  for (auto& property : properties) {
+    switch (property->get_short_type()) {
+      case fourcc("imir"): {
+        auto imir = std::dynamic_pointer_cast<Box_imir>(property);
+        if (imir->get_mirror_direction() == heif_transform_mirror_direction_horizontal) {
+          transform.a = -transform.a;
+          transform.b = -transform.b;
+          transform.tx = image_width - 1 - transform.tx;
+        }
+        else {
+          transform.c = -transform.c;
+          transform.d = -transform.d;
+          transform.ty = image_height - 1 - transform.ty;
+        }
+        break;
+      }
+      case fourcc("irot"): {
+        auto irot = std::dynamic_pointer_cast<Box_irot>(property);
+        RegionCoordinateTransform tmp;
+        switch (irot->get_rotation_ccw()) {
+          case 90:
+            tmp.a = transform.c;
+            tmp.b = transform.d;
+            tmp.c = -transform.a;
+            tmp.d = -transform.b;
+            tmp.tx = transform.ty;
+            tmp.ty = -transform.tx + image_width - 1;
+            transform = tmp;
+            std::swap(image_width, image_height);
+            break;
+          case 180:
+            transform.a = -transform.a;
+            transform.b = -transform.b;
+            transform.tx = image_width - 1 - transform.tx;
+            transform.c = -transform.c;
+            transform.d = -transform.d;
+            transform.ty = image_height - 1 - transform.ty;
+            break;
+          case 270:
+            tmp.a = -transform.c;
+            tmp.b = -transform.d;
+            tmp.c = transform.a;
+            tmp.d = transform.b;
+            tmp.tx = -transform.ty + image_height - 1;
+            tmp.ty = transform.tx;
+            transform = tmp;
+            std::swap(image_width, image_height);
+            break;
+          default:
+            break;
+        }
+        break;
+      }
+      case fourcc("clap"): {
+        auto clap = std::dynamic_pointer_cast<Box_clap>(property);
+        int left = clap->left_rounded(image_width);
+        int top = clap->top_rounded(image_height);
+        transform.tx -= left;
+        transform.ty -= top;
+        image_width = clap->get_width_rounded();
+        image_height = clap->get_height_rounded();
+        break;
+      }
+      default:
+        break;
+    }
+  }
+
+  return transform;
+}
+
+
+RegionCoordinateTransform::Point RegionCoordinateTransform::transform_point(Point p)
+{
+  Point newp;
+  newp.x = p.x * a + p.x * b + tx;
+  newp.y = p.x * c + p.y * d + ty;
+  return newp;
+}
+
+
+RegionCoordinateTransform::Extent RegionCoordinateTransform::transform_extent(Extent e)
+{
+  Extent newe;
+  newe.x = e.x * a + e.y * b;
+  newe.y = e.x * c + e.y * d;
+  return newe;
+}
+
+
+
diff --git a/libheif/region.h b/libheif/region.h
new file mode 100644
index 0000000000..b21c7a5a65
--- /dev/null
+++ b/libheif/region.h
@@ -0,0 +1,213 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_REGION_H
+#define LIBHEIF_REGION_H
+
+#include <cstdint>
+#include <vector>
+#include <memory>
+#include "pixelimage.h"
+#include "libheif/heif_regions.h"
+
+
+class RegionGeometry;
+
+class RegionItem
+{
+public:
+  RegionItem() = default;
+
+  RegionItem(heif_item_id itemId, uint32_t ref_width, uint32_t ref_height)
+      : item_id(itemId), reference_width(ref_width), reference_height(ref_height) {}
+
+  Error parse(const std::vector<uint8_t>& data, const heif_security_limits*);
+
+  Error encode(std::vector<uint8_t>& result) const;
+
+  int get_number_of_regions() { return (int) mRegions.size(); }
+
+  std::vector<std::shared_ptr<RegionGeometry>> get_regions() { return mRegions; }
+
+  void add_region(const std::shared_ptr<RegionGeometry>& region)
+  {
+    mRegions.push_back(region);
+  }
+
+  heif_item_id item_id = 0;
+  uint32_t reference_width = 0;
+  uint32_t reference_height = 0;
+
+private:
+  std::vector<std::shared_ptr<RegionGeometry>> mRegions;
+};
+
+
+class RegionGeometry
+{
+public:
+  virtual ~RegionGeometry() = default;
+
+  virtual heif_region_type getRegionType() = 0;
+
+  virtual Error parse(const std::vector<uint8_t>& data, int field_size, unsigned int* dataOffset,
+                      const heif_security_limits* limits) = 0;
+
+  virtual bool encode_needs_32bit() const { return false; }
+
+  virtual void encode(StreamWriter&, int field_size_bytes) const {}
+
+protected:
+  uint32_t parse_unsigned(const std::vector<uint8_t>& data, int field_size, unsigned int* dataOffset);
+
+  int32_t parse_signed(const std::vector<uint8_t>& data, int field_size, unsigned int* dataOffset);
+};
+
+class RegionGeometry_Point : public RegionGeometry
+{
+public:
+  Error parse(const std::vector<uint8_t>& data, int field_size, unsigned int* dataOffset,
+              const heif_security_limits* limits) override;
+
+  bool encode_needs_32bit() const override;
+
+  void encode(StreamWriter&, int field_size_bytes) const override;
+
+  heif_region_type getRegionType() override { return heif_region_type_point; }
+
+  int32_t x, y;
+};
+
+class RegionGeometry_Rectangle : public RegionGeometry
+{
+public:
+  Error parse(const std::vector<uint8_t>& data, int field_size, unsigned int* dataOffset,
+              const heif_security_limits* limits) override;
+
+  bool encode_needs_32bit() const override;
+
+  void encode(StreamWriter&, int field_size_bytes) const override;
+
+  heif_region_type getRegionType() override { return heif_region_type_rectangle; }
+
+  int32_t x, y;
+  uint32_t width, height;
+};
+
+class RegionGeometry_Ellipse : public RegionGeometry
+{
+public:
+  Error parse(const std::vector<uint8_t>& data, int field_size, unsigned int* dataOffset,
+              const heif_security_limits* limits) override;
+
+  bool encode_needs_32bit() const override;
+
+  void encode(StreamWriter&, int field_size_bytes) const override;
+
+  heif_region_type getRegionType() override { return heif_region_type_ellipse; }
+
+  int32_t x, y;
+  uint32_t radius_x, radius_y;
+};
+
+class RegionGeometry_Polygon : public RegionGeometry
+{
+public:
+  Error parse(const std::vector<uint8_t>& data, int field_size, unsigned int* dataOffset,
+              const heif_security_limits* limits) override;
+
+  bool encode_needs_32bit() const override;
+
+  void encode(StreamWriter&, int field_size_bytes) const override;
+
+  heif_region_type getRegionType() override
+  {
+    return closed ? heif_region_type_polygon : heif_region_type_polyline;
+  }
+
+  struct Point
+  {
+    int32_t x, y;
+  };
+
+  bool closed = true;
+  std::vector<Point> points;
+  MemoryHandle m_memory_handle;
+};
+
+class RegionGeometry_ReferencedMask : public RegionGeometry
+{
+public:
+  Error parse(const std::vector<uint8_t>& data, int field_size, unsigned int* dataOffset,
+              const heif_security_limits* limits) override;
+
+  void encode(StreamWriter&, int field_size_bytes) const override;
+
+  heif_region_type getRegionType() override { return heif_region_type_referenced_mask; }
+
+  int32_t x,y;
+  uint32_t width, height;
+  heif_item_id referenced_item;
+};
+
+class RegionGeometry_InlineMask : public RegionGeometry
+{
+public:
+  Error parse(const std::vector<uint8_t>& data, int field_size, unsigned int* dataOffset,
+              const heif_security_limits* limits) override;
+
+  void encode(StreamWriter&, int field_size_bytes) const override;
+
+  int32_t x,y;
+  uint32_t width, height;
+  std::vector<uint8_t> mask_data;
+  MemoryHandle m_memory_handle;
+
+  heif_region_type getRegionType() override { return heif_region_type_inline_mask; }
+};
+
+class HeifFile;
+
+class RegionCoordinateTransform
+{
+public:
+  static RegionCoordinateTransform create(std::shared_ptr<HeifFile> file,
+                                          heif_item_id item_id,
+                                          int reference_width, int reference_height);
+
+  struct Point
+  {
+    double x, y;
+  };
+
+  struct Extent
+  {
+    double x, y;
+  };
+
+  Point transform_point(Point);
+
+  Extent transform_extent(Extent);
+
+private:
+  double a = 1.0, b = 0.0, c = 0.0, d = 1.0, tx = 0.0, ty = 0.0;
+};
+
+#endif //LIBHEIF_REGION_H
diff --git a/libheif/security_limits.cc b/libheif/security_limits.cc
new file mode 100644
index 0000000000..ed8241c650
--- /dev/null
+++ b/libheif/security_limits.cc
@@ -0,0 +1,255 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "security_limits.h"
+#include <limits>
+#include <map>
+#include <mutex>
+
+
+heif_security_limits global_security_limits{
+    .version = 4,
+
+    // --- version 1
+
+    // Artificial limit to avoid allocating too much memory.
+    // 32768^2 = 1.5 GB as YUV-4:2:0 or 4 GB as RGB32
+    .max_image_size_pixels = 32768 * 32768,
+    .max_number_of_tiles = 4096 * 4096,
+    .max_bayer_pattern_pixels = 16 * 16,
+    .max_items = 1000,
+
+    .max_color_profile_size = 100 * 1024 * 1024, // 100 MB
+    .max_memory_block_size = UINT64_C(4) * 1024 * 1024 * 1024,  // 4 GB
+
+    .max_components = 256,
+    .max_iloc_extents_per_item = 32,
+    .max_size_entity_group = 64,
+
+    .max_children_per_box = 100,
+
+    // --- version 2
+
+    .max_total_memory = UINT64_C(4) * 1024 * 1024 * 1024,  // 4 GB
+    .max_sample_description_box_entries = 1024,
+    .max_sample_group_description_box_entries = 1024,
+
+    // --- version 3
+
+    .max_sequence_frames = 18'000'000,  // 100 hours at 50 fps
+    .max_number_of_file_brands = 1000,
+    .max_bad_pixels = 1000
+};
+
+
+heif_security_limits disabled_security_limits{
+    .version = 4
+};
+
+
+Error check_for_valid_image_size(const heif_security_limits* limits, uint32_t width, uint32_t height)
+{
+  uint64_t maximum_image_size_limit = limits->max_image_size_pixels;
+
+  // --- check whether the image size is "too large"
+
+  if (maximum_image_size_limit > 0) {
+    auto max_width_height = static_cast<uint32_t>(std::numeric_limits<int>::max());
+    if ((width > max_width_height || height > max_width_height) ||
+        (height != 0 && width > maximum_image_size_limit / height)) {
+      std::stringstream sstr;
+      sstr << "Image size " << width << "x" << height << " exceeds the maximum image size "
+           << maximum_image_size_limit << "\n";
+
+      return {heif_error_Memory_allocation_error,
+              heif_suberror_Security_limit_exceeded,
+              sstr.str()};
+    }
+  }
+
+  if (width == 0 || height == 0) {
+    return {heif_error_Memory_allocation_error,
+            heif_suberror_Invalid_image_size,
+            "zero width or height"};
+  }
+
+  return Error::Ok;
+}
+
+
+struct memory_stats {
+  size_t total_memory_usage = 0;
+  size_t max_memory_usage = 0;
+};
+
+std::mutex& get_memory_usage_mutex()
+{
+  static std::mutex sMutex;
+  return sMutex;
+}
+
+static std::map<const heif_security_limits*, memory_stats> sMemoryUsage;
+
+TotalMemoryTracker::TotalMemoryTracker(const heif_security_limits* limits)
+{
+  std::lock_guard<std::mutex> lock(get_memory_usage_mutex());
+
+  sMemoryUsage[limits] = {};
+  m_limits_context = limits;
+}
+
+TotalMemoryTracker::~TotalMemoryTracker()
+{
+  std::lock_guard<std::mutex> lock(get_memory_usage_mutex());
+  sMemoryUsage.erase(m_limits_context);
+}
+
+
+size_t TotalMemoryTracker::get_max_total_memory_used() const
+{
+  std::lock_guard<std::mutex> lock(get_memory_usage_mutex());
+
+  auto it = sMemoryUsage.find(m_limits_context);
+  if (it != sMemoryUsage.end()) {
+    return it->second.max_memory_usage;
+  }
+  else {
+    assert(false);
+    return 0;
+  }
+}
+
+
+Error MemoryHandle::alloc(size_t memory_amount, const heif_security_limits* limits_context,
+                          const char* reason_description)
+{
+  // we allow several allocations on the same handle, but they have to be for the same context
+  if (m_limits_context) {
+    assert(m_limits_context == limits_context);
+  }
+
+
+  // --- check whether limits are exceeded
+
+  if (!limits_context) {
+    return Error::Ok;
+  }
+
+  // check against maximum memory block size
+
+  if (limits_context->max_memory_block_size != 0 &&
+      memory_amount > limits_context->max_memory_block_size) {
+    std::stringstream sstr;
+
+    if (reason_description) {
+      sstr << "Allocating " << memory_amount << " bytes for " << reason_description <<" exceeds the security limit of "
+           << limits_context->max_memory_block_size << " bytes";
+    }
+    else {
+      sstr << "Allocating " << memory_amount << " bytes exceeds the security limit of "
+           << limits_context->max_memory_block_size << " bytes";
+    }
+
+    return {heif_error_Memory_allocation_error,
+            heif_suberror_Security_limit_exceeded,
+            sstr.str()};
+  }
+
+  if (limits_context == &global_security_limits ||
+      limits_context == &disabled_security_limits) {
+    return Error::Ok;
+  }
+
+  std::lock_guard<std::mutex> lock(get_memory_usage_mutex());
+  auto it = sMemoryUsage.find(limits_context);
+  if (it == sMemoryUsage.end()) {
+    assert(false);
+    return Error::Ok;
+  }
+
+  // check against maximum total memory usage
+
+  if (limits_context->max_total_memory != 0 &&
+      it->second.total_memory_usage + memory_amount > limits_context->max_total_memory) {
+    std::stringstream sstr;
+
+    if (reason_description) {
+      sstr << "Memory usage of " << it->second.total_memory_usage + memory_amount
+           << " bytes for " << reason_description << " exceeds the security limit of "
+           << limits_context->max_total_memory << " bytes of total memory usage";
+    }
+    else {
+      sstr << "Memory usage of " << it->second.total_memory_usage + memory_amount
+           << " bytes exceeds the security limit of "
+           << limits_context->max_total_memory << " bytes of total memory usage";
+    }
+
+    return {heif_error_Memory_allocation_error,
+            heif_suberror_Security_limit_exceeded,
+            sstr.str()};
+  }
+
+
+  // --- register memory usage
+
+  m_limits_context = limits_context;
+  m_memory_amount += memory_amount;
+
+  it->second.total_memory_usage += memory_amount;
+
+  // remember maximum memory usage (for informational purpose)
+  if (it->second.total_memory_usage > it->second.max_memory_usage) {
+    it->second.max_memory_usage = it->second.total_memory_usage;
+  }
+
+  return Error::Ok;
+}
+
+
+void MemoryHandle::free()
+{
+  if (m_limits_context) {
+    std::lock_guard<std::mutex> lock(get_memory_usage_mutex());
+
+    auto it = sMemoryUsage.find(m_limits_context);
+    if (it != sMemoryUsage.end()) {
+      it->second.total_memory_usage -= m_memory_amount;
+    }
+
+    m_limits_context = nullptr;
+    m_memory_amount = 0;
+  }
+}
+
+
+void MemoryHandle::free(size_t memory_amount)
+{
+  if (m_limits_context) {
+    std::lock_guard<std::mutex> lock(get_memory_usage_mutex());
+
+    auto it = sMemoryUsage.find(m_limits_context);
+    if (it != sMemoryUsage.end()) {
+      it->second.total_memory_usage -= memory_amount;
+    }
+
+    m_memory_amount -= memory_amount;
+  }
+}
+
diff --git a/libheif/security_limits.h b/libheif/security_limits.h
new file mode 100644
index 0000000000..6845008bb9
--- /dev/null
+++ b/libheif/security_limits.h
@@ -0,0 +1,84 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2018 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef LIBHEIF_SECURITY_LIMITS_H
+#define LIBHEIF_SECURITY_LIMITS_H
+
+#include "libheif/heif.h"
+#include <cinttypes>
+#include <cstddef>
+#include "error.h"
+
+
+extern heif_security_limits global_security_limits;
+extern heif_security_limits disabled_security_limits;
+
+// Maximum nesting level of boxes in input files.
+// We put a limit on this to avoid unlimited stack usage by malicious input files.
+static const int MAX_BOX_NESTING_LEVEL = 20;
+
+static const int MAX_BOX_SIZE = 0x7FFFFFFF; // 2 GB
+static const int64_t MAX_LARGE_BOX_SIZE = 0x0FFFFFFFFFFFFFFF;
+static const int64_t MAX_FILE_POS = 0x007FFFFFFFFFFFFFLL; // maximum file position
+static const int MAX_FRACTION_VALUE = 0x10000;
+
+
+Error check_for_valid_image_size(const heif_security_limits* limits, uint32_t width, uint32_t height);
+
+
+class TotalMemoryTracker
+{
+public:
+  explicit TotalMemoryTracker(const heif_security_limits* limits_context);
+  ~TotalMemoryTracker();
+
+  size_t get_max_total_memory_used() const;
+
+  void operator=(const TotalMemoryTracker&) = delete;
+  TotalMemoryTracker(const TotalMemoryTracker&) = delete;
+
+private:
+  const heif_security_limits* m_limits_context = nullptr;
+};
+
+
+class MemoryHandle
+{
+public:
+  MemoryHandle() = default;
+  ~MemoryHandle() { free(); }
+
+  Error alloc(size_t memory_amount, const heif_security_limits* limits_context, const char* reason_description);
+
+  void free();
+
+  void free(size_t memory_amount);
+
+  const heif_security_limits* get_security_limits() const { return m_limits_context; }
+
+  void operator=(const MemoryHandle&) = delete;
+  MemoryHandle(const MemoryHandle&) = delete;
+
+private:
+  const heif_security_limits* m_limits_context = nullptr;
+  size_t m_memory_amount = 0;
+};
+
+
+#endif  // LIBHEIF_SECURITY_LIMITS_H
diff --git a/libheif/sequences/chunk.cc b/libheif/sequences/chunk.cc
new file mode 100644
index 0000000000..967a1c7883
--- /dev/null
+++ b/libheif/sequences/chunk.cc
@@ -0,0 +1,114 @@
+/*
+ * HEIF image base codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "chunk.h"
+#include "context.h"
+#include "codecs/avc_enc.h"
+#include "codecs/hevc_enc.h"
+#include "codecs/avif_enc.h"
+#include "codecs/vvc_enc.h"
+#include "codecs/jpeg2000_enc.h"
+#include "codecs/jpeg_enc.h"
+
+#if WITH_UNCOMPRESSED_CODEC
+#include "codecs/uncompressed/unc_enc.h"
+#endif
+
+
+Chunk::Chunk(HeifContext* ctx, uint32_t track_id, heif_compression_format format)
+    : m_ctx(ctx),
+      m_track_id(track_id),
+      m_compression_format(format)
+{
+  switch (format) {
+    case heif_compression_HEVC:
+      m_encoder = std::make_shared<Encoder_HEVC>();
+      break;
+    case heif_compression_AV1:
+      m_encoder = std::make_shared<Encoder_AVIF>();
+      break;
+    case heif_compression_VVC:
+      m_encoder = std::make_shared<Encoder_VVC>();
+      break;
+    case heif_compression_AVC:
+      m_encoder = std::make_shared<Encoder_AVC>();
+      break;
+    case heif_compression_JPEG2000:
+      m_encoder = std::make_shared<Encoder_JPEG2000>();
+      break;
+    case heif_compression_HTJ2K:
+      m_encoder = std::make_shared<Encoder_HTJ2K>();
+      break;
+    case heif_compression_JPEG:
+      m_encoder = std::make_shared<Encoder_JPEG>();
+      break;
+#if WITH_UNCOMPRESSED_CODEC
+    case heif_compression_uncompressed:
+      m_encoder = std::make_shared<Encoder_uncompressed>();
+      break;
+#endif
+    case heif_compression_undefined:
+    default:
+      m_encoder = nullptr;
+      break;
+  }
+}
+
+
+Chunk::Chunk(HeifContext* ctx, uint32_t track_id,
+             uint32_t first_sample, uint32_t num_samples, uint64_t file_offset, const std::shared_ptr<const Box_stsz>& stsz)
+{
+  m_ctx = ctx;
+  m_track_id = track_id;
+
+  m_first_sample = first_sample;
+  m_last_sample = first_sample + num_samples - 1;
+
+  m_next_sample_to_be_decoded = first_sample;
+
+  for (uint32_t i=0;i<num_samples;i++) {
+    SampleFileRange range;
+    range.offset = file_offset;
+    if (stsz->has_fixed_sample_size()) {
+      range.size = stsz->get_fixed_sample_size();
+    }
+    else {
+      assert(first_sample + i < stsz->num_samples());
+      range.size = stsz->get_sample_sizes()[first_sample + i];
+    }
+
+    m_sample_ranges.push_back(range);
+
+    file_offset += range.size;
+  }
+}
+
+
+DataExtent Chunk::get_data_extent_for_sample(uint32_t n) const
+{
+  assert(n>= m_first_sample);
+  assert(n<= m_last_sample);
+
+  DataExtent extent;
+  extent.set_file_range(m_ctx->get_heif_file(),
+                        m_sample_ranges[n - m_first_sample].offset,
+                        m_sample_ranges[n - m_first_sample].size);
+  return extent;
+}
diff --git a/libheif/sequences/chunk.h b/libheif/sequences/chunk.h
new file mode 100644
index 0000000000..510650ef9c
--- /dev/null
+++ b/libheif/sequences/chunk.h
@@ -0,0 +1,84 @@
+/*
+ * HEIF image base codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_CHUNK_H
+#define LIBHEIF_CHUNK_H
+
+#include "codecs/decoder.h"
+#include <memory>
+#include <vector>
+
+
+class HeifContext;
+
+class Box_VisualSampleEntry;
+
+
+class Chunk
+{
+public:
+  Chunk(HeifContext* ctx, uint32_t track_id, heif_compression_format format);
+
+  Chunk(HeifContext* ctx, uint32_t track_id,
+        uint32_t first_sample, uint32_t num_samples, uint64_t file_offset, const std::shared_ptr<const Box_stsz>& sample_sizes);
+
+  virtual ~Chunk() = default;
+
+  heif_compression_format get_compression_format() const { return m_compression_format; }
+
+  virtual std::shared_ptr<class Decoder> get_decoder() const { return m_decoder; }
+
+  virtual std::shared_ptr<class Encoder> get_encoder() const { return m_encoder; }
+
+  uint32_t first_sample_number() const { return m_first_sample; }
+
+  uint32_t last_sample_number() const { return m_last_sample; }
+
+  DataExtent get_data_extent_for_sample(uint32_t n) const;
+
+  void set_decoder(std::shared_ptr<class Decoder> dec) { m_decoder = dec; }
+
+private:
+  HeifContext* m_ctx = nullptr;
+  uint32_t m_track_id = 0;
+
+  heif_compression_format m_compression_format = heif_compression_undefined;
+
+  uint32_t m_first_sample = 0;
+  uint32_t m_last_sample = 0;
+
+  //uint32_t m_sample_description_index = 0;
+
+  uint32_t m_next_sample_to_be_decoded = 0;
+
+  struct SampleFileRange
+  {
+    uint64_t offset = 0;
+    uint32_t size = 0;
+  };
+
+  std::vector<SampleFileRange> m_sample_ranges;
+
+  std::shared_ptr<class Decoder> m_decoder;
+  std::shared_ptr<class Encoder> m_encoder;
+};
+
+
+#endif //LIBHEIF_CHUNK_H
diff --git a/libheif/sequences/seq_boxes.cc b/libheif/sequences/seq_boxes.cc
new file mode 100644
index 0000000000..9da5f497b5
--- /dev/null
+++ b/libheif/sequences/seq_boxes.cc
@@ -0,0 +1,2498 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "sequences/seq_boxes.h"
+#include <iomanip>
+#include <set>
+#include <limits>
+#include <utility>
+#include <algorithm>
+
+
+Error Box_container::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  return read_children(range, READ_CHILDREN_ALL, limits);
+}
+
+
+std::string Box_container::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
+  sstr << dump_children(indent);
+
+  return sstr.str();
+}
+
+
+double Box_mvhd::get_matrix_element(int idx) const
+{
+  if (idx == 8) {
+    return 1.0;
+  }
+
+  return m_matrix[idx] / double(0x10000);
+}
+
+
+Error Box_mvhd::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  parse_full_box_header(range);
+
+  if (get_version() > 1) {
+    return unsupported_version_error("mvhd");
+  }
+
+  if (get_version() == 1) {
+    m_creation_time = range.read64();
+    m_modification_time = range.read64();
+    m_timescale = range.read32();
+    m_duration = range.read64();
+  }
+  else {
+    // version==0
+    m_creation_time = range.read32();
+    m_modification_time = range.read32();
+    m_timescale = range.read32();
+    m_duration = range.read32();
+  }
+
+  m_rate = range.read32();
+  m_volume = range.read16();
+  range.skip(2);
+  range.skip(8);
+  for (uint32_t& m : m_matrix) {
+    m = range.read32();
+  }
+  for (int i = 0; i < 6; i++) {
+    range.skip(4);
+  }
+
+  m_next_track_ID = range.read32();
+
+  return range.get_error();
+}
+
+
+std::string Box_mvhd::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << FullBox::dump(indent);
+  sstr << indent << "creation time:     " << m_creation_time << "\n"
+      << indent << "modification time: " << m_modification_time << "\n"
+      << indent << "timescale: " << m_timescale << "\n"
+      << indent << "duration: " << m_duration << "\n";
+  sstr << indent << "rate: " << get_rate() << "\n"
+      << indent << "volume: " << get_volume() << "\n"
+      << indent << "matrix:\n";
+  for (int y = 0; y < 3; y++) {
+    sstr << indent << "  ";
+    for (int i = 0; i < 3; i++) {
+      sstr << get_matrix_element(i + 3 * y) << " ";
+    }
+    sstr << "\n";
+  }
+  sstr << indent << "next_track_ID: " << m_next_track_ID << "\n";
+
+  return sstr.str();
+}
+
+
+void Box_mvhd::derive_box_version()
+{
+  if (m_creation_time > 0xFFFFFFFF ||
+      m_modification_time > 0xFFFFFFFF ||
+      m_timescale > 0xFFFFFFFF ||
+      m_duration > 0xFFFFFFFF) {
+    set_version(1);
+  }
+  else {
+    set_version(0);
+  }
+}
+
+
+Error Box_mvhd::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  if (get_version() == 1) {
+    writer.write64(m_creation_time);
+    writer.write64(m_modification_time);
+    writer.write32(m_timescale);
+    writer.write64(m_duration);
+  }
+  else {
+    // version==0
+    writer.write32(static_cast<uint32_t>(m_creation_time));
+    writer.write32(static_cast<uint32_t>(m_modification_time));
+    writer.write32(static_cast<uint32_t>(m_timescale));
+    writer.write32(static_cast<uint32_t>(m_duration));
+  }
+
+  writer.write32(m_rate);
+  writer.write16(m_volume);
+  writer.write16(0);
+  writer.write64(0);
+  for (uint32_t m : m_matrix) {
+    writer.write32(m);
+  }
+  for (int i = 0; i < 6; i++) {
+    writer.write32(0);
+  }
+
+  writer.write32(m_next_track_ID);
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+
+double Box_tkhd::get_matrix_element(int idx) const
+{
+  if (idx == 8) {
+    return 1.0;
+  }
+
+  return m_matrix[idx] / double(0x10000);
+}
+
+
+Error Box_tkhd::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  parse_full_box_header(range);
+
+  if (get_version() > 1) {
+    return unsupported_version_error("tkhd");
+  }
+
+  if (get_version() == 1) {
+    m_creation_time = range.read64();
+    m_modification_time = range.read64();
+    m_track_id = range.read32();
+    range.skip(4);
+    m_duration = range.read64();
+  }
+  else {
+    // version==0
+    m_creation_time = range.read32();
+    m_modification_time = range.read32();
+    m_track_id = range.read32();
+    range.skip(4);
+    m_duration = range.read32();
+  }
+
+  range.skip(8);
+  m_layer = range.read16();
+  m_alternate_group = range.read16();
+  m_volume = range.read16();
+  range.skip(2);
+  for (uint32_t& m : m_matrix) {
+    m = range.read32();
+  }
+
+  m_width = range.read32();
+  m_height = range.read32();
+
+  return range.get_error();
+}
+
+
+std::string Box_tkhd::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << FullBox::dump(indent);
+  sstr << indent << "track enabled: " << ((get_flags() & Track_enabled) ? "yes" : "no") << "\n"
+       << indent << "track in movie: " << ((get_flags() & Track_in_movie) ? "yes" : "no") << "\n"
+       << indent << "track in preview: " << ((get_flags() & Track_in_preview) ? "yes" : "no") << "\n"
+       << indent << "track size is aspect ratio: " << ((get_flags() & Track_size_is_aspect_ratio) ? "yes" : "no") << "\n";
+  sstr << indent << "creation time:     " << m_creation_time << "\n"
+      << indent << "modification time: " << m_modification_time << "\n"
+      << indent << "track ID: " << m_track_id << "\n"
+      << indent << "duration: " << m_duration << "\n";
+  sstr << indent << "layer: " << m_layer << "\n"
+      << indent << "alternate_group: " << m_alternate_group << "\n"
+      << indent << "volume: " << get_volume() << "\n"
+      << indent << "matrix:\n";
+  for (int y = 0; y < 3; y++) {
+    sstr << indent << "  ";
+    for (int i = 0; i < 3; i++) {
+      sstr << get_matrix_element(i + 3 * y) << " ";
+    }
+    sstr << "\n";
+  }
+
+  sstr << indent << "width: " << get_width() << "\n"
+      << indent << "height: " << get_height() << "\n";
+
+  return sstr.str();
+}
+
+
+void Box_tkhd::derive_box_version()
+{
+  if (m_creation_time > 0xFFFFFFFF ||
+      m_modification_time > 0xFFFFFFFF ||
+      m_duration > 0xFFFFFFFF) {
+    set_version(1);
+  }
+  else {
+    set_version(0);
+  }
+}
+
+
+Error Box_tkhd::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  if (get_version() == 1) {
+    writer.write64(m_creation_time);
+    writer.write64(m_modification_time);
+    writer.write32(m_track_id);
+    writer.write32(0);
+    writer.write64(m_duration);
+  }
+  else {
+    // version==0
+    writer.write32(static_cast<uint32_t>(m_creation_time));
+    writer.write32(static_cast<uint32_t>(m_modification_time));
+    writer.write32(m_track_id);
+    writer.write32(0);
+    writer.write32(static_cast<uint32_t>(m_duration));
+  }
+
+  writer.write64(0);
+  writer.write16(m_layer);
+  writer.write16(m_alternate_group);
+  writer.write16(m_volume);
+  writer.write16(0);
+  for (uint32_t m : m_matrix) {
+    writer.write32(m);
+  }
+
+  writer.write32(m_width);
+  writer.write32(m_height);
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+
+Error Box_mdhd::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  parse_full_box_header(range);
+
+  if (get_version() > 1) {
+    return unsupported_version_error("mdhd");
+  }
+
+  if (get_version() == 1) {
+    m_creation_time = range.read64();
+    m_modification_time = range.read64();
+    m_timescale = range.read32();
+    m_duration = range.read64();
+  }
+  else {
+    // version==0
+    m_creation_time = range.read32();
+    m_modification_time = range.read32();
+    m_timescale = range.read32();
+    m_duration = range.read32();
+  }
+
+  uint16_t language_packed = range.read16();
+  m_language[0] = ((language_packed >> 10) & 0x1F) + 0x60;
+  m_language[1] = ((language_packed >> 5) & 0x1F) + 0x60;
+  m_language[2] = ((language_packed >> 0) & 0x1F) + 0x60;
+  m_language[3] = 0;
+
+  range.skip(2);
+
+  return range.get_error();
+}
+
+
+std::string Box_mdhd::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << FullBox::dump(indent);
+  sstr << indent << "creation time:     " << m_creation_time << "\n"
+      << indent << "modification time: " << m_modification_time << "\n"
+      << indent << "timescale: " << m_timescale << "\n"
+      << indent << "duration: " << m_duration << "\n";
+  sstr << indent << "language: " << m_language << "\n";
+
+  return sstr.str();
+}
+
+
+void Box_mdhd::derive_box_version()
+{
+  if (m_creation_time > 0xFFFFFFFF ||
+      m_modification_time > 0xFFFFFFFF ||
+      m_duration > 0xFFFFFFFF) {
+    set_version(1);
+  }
+  else {
+    set_version(0);
+  }
+}
+
+
+Error Box_mdhd::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  if (get_version() == 1) {
+    writer.write64(m_creation_time);
+    writer.write64(m_modification_time);
+    writer.write32(m_timescale);
+    writer.write64(m_duration);
+  }
+  else {
+    // version==0
+    writer.write32(static_cast<uint32_t>(m_creation_time));
+    writer.write32(static_cast<uint32_t>(m_modification_time));
+    writer.write32(m_timescale);
+    writer.write32(static_cast<uint32_t>(m_duration));
+  }
+
+  auto language_packed = static_cast<uint16_t>((((m_language[0] - 0x60) & 0x1F) << 10) |
+                                               (((m_language[1] - 0x60) & 0x1F) << 5) |
+                                               (((m_language[2] - 0x60) & 0x1F) << 0));
+  writer.write16(language_packed);
+  writer.write16(0);
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+
+
+Error Box_vmhd::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  parse_full_box_header(range);
+
+  if (get_version() > 0) {
+    return unsupported_version_error("vmhd");
+  }
+
+  m_graphics_mode = range.read16();
+  for (uint16_t& c : m_op_color) {
+    c = range.read16();
+  }
+
+  return range.get_error();
+}
+
+
+std::string Box_vmhd::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << FullBox::dump(indent);
+  sstr << indent << "graphics mode: " << m_graphics_mode;
+  if (m_graphics_mode == 0) {
+    sstr << " (copy)";
+  }
+  sstr << "\n"
+       << indent << "op color: " << m_op_color[0] << "; " << m_op_color[1] << "; " << m_op_color[2] << "\n";
+
+  return sstr.str();
+}
+
+
+Error Box_vmhd::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  writer.write16(m_graphics_mode);
+  for (uint16_t c : m_op_color) {
+    writer.write16(c);
+  }
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+
+Error Box_nmhd::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  parse_full_box_header(range);
+
+  if (get_version() > 0) {
+    return unsupported_version_error("nmhd");
+  }
+
+  return range.get_error();
+}
+
+
+std::string Box_nmhd::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << FullBox::dump(indent);
+
+  return sstr.str();
+}
+
+
+Error Box_nmhd::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+
+Error Box_stsd::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  parse_full_box_header(range);
+
+  if (get_version() > 0) {
+    return unsupported_version_error("stsd");
+  }
+
+  uint32_t entry_count = range.read32();
+
+  if (limits->max_sample_description_box_entries &&
+      entry_count > limits->max_sample_description_box_entries) {
+    std::stringstream sstr;
+    sstr << "Allocating " << static_cast<uint64_t>(entry_count) << " sample description items exceeds the security limit of "
+         << limits->max_sample_description_box_entries << " items";
+
+    return {heif_error_Memory_allocation_error,
+            heif_suberror_Security_limit_exceeded,
+            sstr.str()};
+
+  }
+
+  for (uint32_t i = 0; i < entry_count; i++) {
+    std::shared_ptr<Box> entrybox;
+    Error err = Box::read(range, &entrybox, limits);
+    if (err) {
+      return err;
+    }
+
+#if 0
+    auto visualSampleEntry_box = std::dynamic_pointer_cast<Box_VisualSampleEntry>(entrybox);
+    if (!visualSampleEntry_box) {
+      return Error{heif_error_Invalid_input,
+                   heif_suberror_Unspecified,
+                   "Invalid or unknown VisualSampleEntry in stsd box."};
+    }
+#endif
+
+    m_sample_entries.push_back(entrybox);
+  }
+
+  return range.get_error();
+}
+
+
+std::string Box_stsd::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << FullBox::dump(indent);
+  for (size_t i = 0; i < m_sample_entries.size(); i++) {
+    sstr << indent << "[" << i << "]\n";
+    indent++;
+    sstr << m_sample_entries[i]->dump(indent);
+    indent--;
+  }
+
+  return sstr.str();
+}
+
+
+Error Box_stsd::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  writer.write32(static_cast<uint32_t>(m_sample_entries.size()));
+  for (const auto& sample : m_sample_entries) {
+    sample->write(writer);
+  }
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+
+Error Box_stts::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  parse_full_box_header(range);
+
+  if (get_version() > 0) {
+    return unsupported_version_error("stts");
+  }
+
+  uint32_t entry_count = range.read32();
+
+  if (limits->max_sequence_frames > 0 && entry_count > limits->max_sequence_frames) {
+    return {
+      heif_error_Memory_allocation_error,
+      heif_suberror_Security_limit_exceeded,
+      "Security limit for maximum number of sequence frames exceeded"
+    };
+  }
+
+  if (auto err = m_memory_handle.alloc(entry_count * sizeof(TimeToSample),
+                                       limits, "the 'stts' table")) {
+    return err;
+  }
+
+  m_entries.resize(entry_count);
+
+  for (uint32_t i = 0; i < entry_count; i++) {
+    if (range.eof()) {
+      std::stringstream sstr;
+      sstr << "stts box should contain " << entry_count << " entries, but box only contained "
+          << i << " entries";
+
+      return {
+        heif_error_Invalid_input,
+        heif_suberror_End_of_data,
+        sstr.str()
+      };
+    }
+
+    TimeToSample entry{};
+    entry.sample_count = range.read32();
+    entry.sample_delta = range.read32();
+    m_entries[i] = entry;
+  }
+
+  return range.get_error();
+}
+
+
+std::string Box_stts::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << FullBox::dump(indent);
+  for (size_t i = 0; i < m_entries.size(); i++) {
+    sstr << indent << "[" << i << "] : cnt=" << m_entries[i].sample_count << ", delta=" << m_entries[i].sample_delta << "\n";
+  }
+
+  return sstr.str();
+}
+
+
+Error Box_stts::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  writer.write32(static_cast<uint32_t>(m_entries.size()));
+  for (const auto& sample : m_entries) {
+    writer.write32(sample.sample_count);
+    writer.write32(sample.sample_delta);
+  }
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+
+uint32_t Box_stts::get_sample_duration(uint32_t sample_idx)
+{
+  for (const auto& entry : m_entries) {
+    if (sample_idx < entry.sample_count) {
+      return entry.sample_delta;
+    }
+    sample_idx -= entry.sample_count;
+  }
+
+  return 0;
+}
+
+
+void Box_stts::append_sample_duration(uint32_t duration)
+{
+  if (m_entries.empty() || m_entries.back().sample_delta != duration) {
+    TimeToSample entry{};
+    entry.sample_delta = duration;
+    entry.sample_count = 1;
+    m_entries.push_back(entry);
+    return;
+  }
+
+  m_entries.back().sample_count++;
+}
+
+
+uint64_t Box_stts::get_total_duration(bool include_last_frame_duration)
+{
+  uint64_t total = 0;
+
+  for (const auto& entry : m_entries) {
+    total += entry.sample_count * uint64_t(entry.sample_delta);
+  }
+
+  if (!include_last_frame_duration && !m_entries.empty()) {
+    total -= m_entries.back().sample_delta;
+  }
+
+  return total;
+}
+
+
+uint32_t Box_stts::get_number_of_samples() const
+{
+  uint32_t total = 0;
+  for (const auto& entry : m_entries) {
+    total += entry.sample_count;
+  }
+
+  return total;
+}
+
+
+Error Box_ctts::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  parse_full_box_header(range);
+
+  uint8_t version = get_version();
+
+  if (version > 1) {
+    return unsupported_version_error("ctts");
+  }
+
+  uint32_t entry_count = range.read32();
+
+  if (limits->max_sequence_frames > 0 && entry_count > limits->max_sequence_frames) {
+    return {
+      heif_error_Memory_allocation_error,
+      heif_suberror_Security_limit_exceeded,
+      "Security limit for maximum number of sequence frames exceeded"
+    };
+  }
+
+  if (auto err = m_memory_handle.alloc(entry_count * sizeof(OffsetToSample),
+                                       limits, "the 'ctts' table")) {
+    return err;
+  }
+
+  m_entries.resize(entry_count);
+
+  for (uint32_t i = 0; i < entry_count; i++) {
+    if (range.eof()) {
+      std::stringstream sstr;
+      sstr << "ctts box should contain " << entry_count << " entries, but box only contained "
+          << i << " entries";
+
+      return {
+        heif_error_Invalid_input,
+        heif_suberror_End_of_data,
+        sstr.str()
+      };
+    }
+
+    OffsetToSample entry{};
+    entry.sample_count = range.read32();
+    if (version == 0) {
+      uint32_t offset = range.read32();
+#if 0
+      // TODO: I disabled this because I found several files that seem to
+      //       have wrong data. Since we are not using the 'ctts' data anyway,
+      //       let's not care about it now.
+
+      if (offset > INT32_MAX) {
+        return {
+          heif_error_Unsupported_feature,
+          heif_suberror_Unsupported_parameter,
+          "We don't support offsets > 0x7fff in 'ctts' box."
+        };
+      }
+#endif
+
+      entry.sample_offset = static_cast<int32_t>(offset);
+    }
+    else if (version == 1) {
+      entry.sample_offset = range.read32s();
+    }
+    else {
+      assert(false);
+    }
+
+    m_entries[i] = entry;
+  }
+
+  return range.get_error();
+}
+
+
+std::string Box_ctts::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << FullBox::dump(indent);
+  for (size_t i = 0; i < m_entries.size(); i++) {
+    sstr << indent << "[" << i << "] : cnt=" << m_entries[i].sample_count << ", offset=" << m_entries[i].sample_offset << "\n";
+  }
+
+  return sstr.str();
+}
+
+
+int32_t Box_ctts::compute_min_offset() const
+{
+  int32_t min_offset = INT32_MAX;
+  for (const auto& entry : m_entries) {
+    min_offset = std::min(min_offset, entry.sample_offset);
+  }
+
+  return min_offset;
+}
+
+
+uint32_t Box_ctts::get_number_of_samples() const
+{
+  uint32_t total = 0;
+  for (const auto& entry : m_entries) {
+    total += entry.sample_count;
+  }
+
+  return total;
+}
+
+
+Error Box_ctts::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  int32_t min_offset;
+
+  if (get_version() == 0) {
+    // shift such that all offsets are >= 0
+    min_offset = compute_min_offset();
+  }
+  else {
+    // do not modify offsets
+    min_offset = 0;
+  }
+
+  writer.write32(static_cast<uint32_t>(m_entries.size()));
+  for (const auto& sample : m_entries) {
+    writer.write32(sample.sample_count);
+    writer.write32s(sample.sample_offset - min_offset);
+  }
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+
+int32_t Box_ctts::get_sample_offset(uint32_t sample_idx)
+{
+  for (const auto& entry : m_entries) {
+    if (sample_idx < entry.sample_count) {
+      return entry.sample_offset;
+    }
+    sample_idx -= entry.sample_count;
+  }
+
+  return 0;
+}
+
+
+void Box_ctts::append_sample_offset(int32_t offset)
+{
+  if (m_entries.empty() || m_entries.back().sample_offset != offset) {
+    OffsetToSample entry{};
+    entry.sample_offset = offset;
+    entry.sample_count = 1;
+    m_entries.push_back(entry);
+    return;
+  }
+
+  m_entries.back().sample_count++;
+}
+
+
+bool Box_ctts::is_constant_offset() const
+{
+  return m_entries.empty() || m_entries.size() == 1;
+}
+
+void Box_ctts::derive_box_version()
+{
+  set_version(1);
+}
+
+
+Error Box_stsc::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  parse_full_box_header(range);
+
+  if (get_version() > 0) {
+    return unsupported_version_error("stsc");
+  }
+
+  uint32_t entry_count = range.read32();
+  if (entry_count == 0) {
+    return {
+      heif_error_Invalid_input,
+      heif_suberror_Unspecified,
+      "'stsc' box with zero entries."};
+  }
+
+  // Note: test against maximum number of frames (upper limit) since we have no limit on maximum number of chunks
+  if (limits->max_sequence_frames > 0 && entry_count > limits->max_sequence_frames) {
+    return {
+      heif_error_Invalid_input,
+      heif_suberror_Unspecified,
+      "Number of chunks in `stsc` box exceeds security limits of maximum number of frames."};
+  }
+
+
+  if (auto err = m_memory_handle.alloc(entry_count * sizeof(SampleToChunk),
+                                       limits, "the 'stsc' table")) {
+    return err;
+  }
+
+  m_entries.resize(entry_count);
+
+  for (uint32_t i = 0; i < entry_count; i++) {
+    SampleToChunk entry{};
+    entry.first_chunk = range.read32();
+    entry.samples_per_chunk = range.read32();
+    entry.sample_description_index = range.read32();
+
+    if (entry.samples_per_chunk == 0) {
+      return {
+        heif_error_Invalid_input,
+        heif_suberror_Unspecified,
+        "'stsc' box with zero samples per chunk entry."};
+    }
+
+    if (entry.sample_description_index == 0) {
+      return {
+      heif_error_Invalid_input,
+      heif_suberror_Unspecified,
+      "'sample_description_index' in 'stsc' must not be 0."};
+    }
+
+    if (limits->max_sequence_frames > 0 && entry.samples_per_chunk > limits->max_sequence_frames) {
+      return {
+        heif_error_Invalid_input,
+        heif_suberror_Unspecified,
+        "Number of chunk samples in `stsc` box exceeds security limits of maximum number of frames."};
+    }
+
+    m_entries[i] = entry;
+  }
+
+  return range.get_error();
+}
+
+
+std::string Box_stsc::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << FullBox::dump(indent);
+  for (size_t i = 0; i < m_entries.size(); i++) {
+    sstr << indent << "[" << i << "]\n"
+        << indent << "  first chunk: " << m_entries[i].first_chunk << "\n"
+        << indent << "  samples per chunk: " << m_entries[i].samples_per_chunk << "\n"
+        << indent << "  sample description index: " << m_entries[i].sample_description_index << "\n";
+  }
+
+  return sstr.str();
+}
+
+
+Error Box_stsc::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  writer.write32(static_cast<uint32_t>(m_entries.size()));
+  for (const auto& sample : m_entries) {
+    writer.write32(sample.first_chunk);
+    writer.write32(sample.samples_per_chunk);
+    writer.write32(sample.sample_description_index);
+  }
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+
+const Box_stsc::SampleToChunk* Box_stsc::get_chunk(uint32_t idx) const
+{
+  assert(idx>=1);
+  for (size_t i = 0 ; i < m_entries.size();i++) {
+    if (idx >= m_entries[i].first_chunk && (i==m_entries.size()-1 || idx < m_entries[i+1].first_chunk)) {
+      return &m_entries[i];
+    }
+  }
+
+  return nullptr;
+}
+
+
+void Box_stsc::add_chunk(uint32_t description_index)
+{
+  SampleToChunk entry{};
+  entry.first_chunk = 1; // TODO
+  entry.samples_per_chunk = 0;
+  entry.sample_description_index = description_index;
+  m_entries.push_back(entry);
+}
+
+
+void Box_stsc::increase_samples_in_chunk(uint32_t nFrames)
+{
+  assert(!m_entries.empty());
+
+  m_entries.back().samples_per_chunk += nFrames;
+}
+
+
+Error Box_stco::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  parse_full_box_header(range);
+
+  if (get_version() > 0) {
+    return unsupported_version_error("stco");
+  }
+
+  uint32_t entry_count = range.read32();
+
+  // check required memory
+
+  uint64_t mem_size = entry_count * sizeof(uint32_t);
+  if (auto err = m_memory_handle.alloc(mem_size,
+                                       limits, "the 'stco' table")) {
+    return err;
+  }
+
+  for (uint32_t i = 0; i < entry_count; i++) {
+    m_offsets.push_back(range.read32());
+
+    if (range.error()) {
+      return range.get_error();
+    }
+  }
+
+  return range.get_error();
+}
+
+
+std::string Box_stco::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << FullBox::dump(indent);
+  for (size_t i = 0; i < m_offsets.size(); i++) {
+    sstr << indent << "[" << i << "] : 0x" << std::hex << m_offsets[i] << std::dec << "\n";
+  }
+
+  return sstr.str();
+}
+
+
+Error Box_stco::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  writer.write32(static_cast<uint32_t>(m_offsets.size()));
+
+  m_offset_start_pos = writer.get_position();
+
+  for (uint32_t offset : m_offsets) {
+    writer.write32(offset);
+  }
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+
+void Box_stco::patch_file_pointers(StreamWriter& writer, size_t offset)
+{
+  size_t oldPosition = writer.get_position();
+
+  writer.set_position(m_offset_start_pos);
+
+  for (uint32_t chunk_offset : m_offsets) {
+    if (chunk_offset + offset > std::numeric_limits<uint32_t>::max()) {
+      writer.write32(0); // TODO: error
+    }
+    else {
+      writer.write32(static_cast<uint32_t>(chunk_offset + offset));
+    }
+  }
+
+  writer.set_position(oldPosition);
+}
+
+
+
+Error Box_stsz::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  parse_full_box_header(range);
+
+  if (get_version() > 0) {
+    return unsupported_version_error("stsz");
+  }
+
+  m_fixed_sample_size = range.read32();
+  m_sample_count = range.read32();
+
+  if (m_fixed_sample_size == 0) {
+    // check required memory
+
+    if (limits->max_sequence_frames > 0 && m_sample_count > limits->max_sequence_frames) {
+      return {
+        heif_error_Memory_allocation_error,
+        heif_suberror_Security_limit_exceeded,
+        "Security limit for maximum number of sequence frames exceeded"
+      };
+    }
+
+    uint64_t mem_size = m_sample_count * sizeof(uint32_t);
+    if (auto err = m_memory_handle.alloc(mem_size, limits, "the 'stsz' table")) {
+      return err;
+    }
+
+    for (uint32_t i = 0; i < m_sample_count; i++) {
+      if (range.eof()) {
+        std::stringstream sstr;
+        sstr << "stsz box should contain " << m_sample_count << " entries, but box only contained "
+            << i << " entries";
+
+        return {
+          heif_error_Invalid_input,
+          heif_suberror_End_of_data,
+          sstr.str()
+        };
+      }
+
+      m_sample_sizes.push_back(range.read32());
+
+      if (range.error()) {
+        return range.get_error();
+      }
+    }
+  }
+
+  return range.get_error();
+}
+
+
+std::string Box_stsz::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << FullBox::dump(indent);
+  sstr << indent << "sample count: " << m_sample_count << "\n";
+  if (m_fixed_sample_size == 0) {
+    for (size_t i = 0; i < m_sample_sizes.size(); i++) {
+      sstr << indent << "[" << i << "] : " << m_sample_sizes[i] << "\n";
+    }
+  }
+  else {
+    sstr << indent << "fixed sample size: " << m_fixed_sample_size << "\n";
+  }
+
+  return sstr.str();
+}
+
+
+Error Box_stsz::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  writer.write32(m_fixed_sample_size);
+  writer.write32(m_sample_count);
+  if (m_fixed_sample_size == 0) {
+    assert(m_sample_count == m_sample_sizes.size());
+
+    for (uint32_t size : m_sample_sizes) {
+      writer.write32(size);
+    }
+  }
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+
+void Box_stsz::append_sample_size(uint32_t size)
+{
+  if (m_sample_count == 0 && size != 0) {
+    m_fixed_sample_size = size;
+    m_sample_count = 1;
+    return;
+  }
+
+  if (m_fixed_sample_size == size && size != 0) {
+    m_sample_count++;
+    return;
+  }
+
+  if (m_fixed_sample_size != 0) {
+    for (uint32_t i = 0; i < m_sample_count; i++) {
+      m_sample_sizes.push_back(m_fixed_sample_size);
+    }
+
+    m_fixed_sample_size = 0;
+  }
+
+  m_sample_sizes.push_back(size);
+  m_sample_count++;
+
+  assert(m_sample_count == m_sample_sizes.size());
+}
+
+
+Error Box_stss::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  parse_full_box_header(range);
+
+  if (get_version() > 0) {
+    return unsupported_version_error("stss");
+  }
+
+  uint32_t sample_count = range.read32();
+
+  // check required memory
+
+  uint64_t mem_size = sample_count * sizeof(uint32_t);
+  if (auto err = m_memory_handle.alloc(mem_size, limits, "the 'stss' table")) {
+    return err;
+  }
+
+  for (uint32_t i = 0; i < sample_count; i++) {
+    m_sync_samples.push_back(range.read32());
+
+    if (range.error()) {
+      return range.get_error();
+    }
+  }
+
+  return range.get_error();
+}
+
+
+std::string Box_stss::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << FullBox::dump(indent);
+  for (size_t i = 0; i < m_sync_samples.size(); i++) {
+    sstr << indent << "[" << i << "] : " << m_sync_samples[i] << "\n";
+  }
+
+  return sstr.str();
+}
+
+
+void Box_stss::set_total_number_of_samples(uint32_t num_samples)
+{
+  m_all_samples_are_sync_samples = (m_sync_samples.size() == num_samples);
+}
+
+
+Error Box_stss::write(StreamWriter& writer) const
+{
+  // If we don't need this box, skip it.
+  if (m_all_samples_are_sync_samples) {
+    return Error::Ok;
+  }
+
+  size_t box_start = reserve_box_header_space(writer);
+
+  writer.write32(static_cast<uint32_t>(m_sync_samples.size()));
+  for (uint32_t sample : m_sync_samples) {
+    writer.write32(sample);
+  }
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+
+Error VisualSampleEntry::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  (void)limits;
+
+  range.skip(6);
+  data_reference_index = range.read16();
+
+  pre_defined = range.read16();
+  range.skip(2);
+  for (uint32_t& p : pre_defined2) {
+    p = range.read32();
+  }
+  width = range.read16();
+  height = range.read16();
+  horizresolution = range.read32();
+  vertresolution = range.read32();
+  range.skip(4);
+  frame_count = range.read16();
+  compressorname = range.read_fixed_string(32);
+  depth = range.read16();
+  pre_defined3 = range.read16s();
+
+  // other boxes from derived specifications
+  //std::shared_ptr<Box_clap> clap; // optional // TODO
+  //std::shared_ptr<Box_pixi> pixi; // optional // TODO
+
+  return Error::Ok;
+}
+
+
+Error VisualSampleEntry::write(StreamWriter& writer) const
+{
+  writer.write32(0);
+  writer.write16(0);
+  writer.write16(data_reference_index);
+
+  writer.write16(pre_defined);
+  writer.write16(0);
+  for (uint32_t p : pre_defined2) {
+    writer.write32(p);
+  }
+
+  writer.write16(width);
+  writer.write16(height);
+  writer.write32(horizresolution);
+  writer.write32(vertresolution);
+  writer.write32(0);
+  writer.write16(frame_count);
+  writer.write_fixed_string(compressorname, 32);
+  writer.write16(depth);
+  writer.write16(pre_defined3);
+
+  return Error::Ok;
+}
+
+
+std::string VisualSampleEntry::dump(Indent& indent) const
+{
+  std::stringstream sstr;
+  sstr << indent << "data reference index: " << data_reference_index << "\n"
+       << indent << "width: " << width << "\n"
+       << indent << "height: " << height << "\n"
+       << indent << "horiz. resolution: " << get_horizontal_resolution() << "\n"
+       << indent << "vert. resolution: " << get_vertical_resolution() << "\n"
+       << indent << "frame count: " << frame_count << "\n"
+       << indent << "compressorname: " << compressorname << "\n"
+       << indent << "depth: " << depth << "\n";
+
+  return sstr.str();
+}
+
+
+Error Box_URIMetaSampleEntry::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  writer.write32(0);
+  writer.write16(0);
+  writer.write16(data_reference_index);
+
+  write_children(writer);
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+
+std::string Box_URIMetaSampleEntry::dump(Indent& indent) const
+{
+  std::stringstream sstr;
+  sstr << Box::dump(indent);
+  sstr << indent << "data reference index: " << data_reference_index << "\n";
+  sstr << dump_children(indent);
+  return sstr.str();
+}
+
+
+Error Box_URIMetaSampleEntry::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  range.skip(6);
+  data_reference_index = range.read16();
+
+  Error err = read_children(range, READ_CHILDREN_ALL, limits);
+  if (err) {
+    return err;
+  }
+
+  return Error::Ok;
+}
+
+
+Error Box_uri::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  parse_full_box_header(range);
+
+  if (get_version() > 0) {
+    return unsupported_version_error("uri ");
+  }
+
+  m_uri = range.read_string();
+
+  return range.get_error();
+}
+
+
+std::string Box_uri::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << FullBox::dump(indent);
+  sstr << indent << "uri: " << m_uri << "\n";
+
+  return sstr.str();
+}
+
+
+Error Box_uri::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  writer.write(m_uri);
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+
+
+Error Box_ccst::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  parse_full_box_header(range);
+
+  if (get_version() > 0) {
+    return unsupported_version_error("ccst");
+  }
+
+  uint32_t bits = range.read32();
+
+  auto& constraints = m_codingConstraints;
+
+  constraints.all_ref_pics_intra = (bits & 0x80000000) != 0;
+  constraints.intra_pred_used = (bits & 0x40000000) != 0;
+  constraints.max_ref_per_pic = (bits >> 26) & 0x0F;
+
+  return range.get_error();
+}
+
+
+std::string Box_ccst::dump(Indent& indent) const
+{
+  const auto& constraints = m_codingConstraints;
+
+  std::ostringstream sstr;
+  sstr << FullBox::dump(indent);
+  sstr << indent << "all ref pics intra: " << std::boolalpha <<constraints.all_ref_pics_intra << "\n"
+       << indent << "intra pred used: " << constraints.intra_pred_used << "\n"
+       << indent << "max ref per pic: " << ((int) constraints.max_ref_per_pic) << "\n";
+
+  return sstr.str();
+}
+
+
+Error Box_ccst::write(StreamWriter& writer) const
+{
+  const auto& constraints = m_codingConstraints;
+
+  size_t box_start = reserve_box_header_space(writer);
+
+  uint32_t bits = 0;
+
+  if (constraints.all_ref_pics_intra) {
+    bits |= 0x80000000;
+  }
+
+  if (constraints.intra_pred_used) {
+    bits |= 0x40000000;
+  }
+
+  bits |= constraints.max_ref_per_pic << 26;
+
+  writer.write32(bits);
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+
+Error Box_auxi::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  parse_full_box_header(range);
+
+  if (get_version() > 0) {
+    return unsupported_version_error("auxi");
+  }
+
+  m_aux_track_type = range.read_string();
+
+  return range.get_error();
+}
+
+
+std::string Box_auxi::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << FullBox::dump(indent);
+  sstr << indent << "aux track info type: " << m_aux_track_type << "\n";
+
+  return sstr.str();
+}
+
+
+Error Box_auxi::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  writer.write(m_aux_track_type);
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+
+Error Box_VisualSampleEntry::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  Error err = get_VisualSampleEntry_const().write(writer);
+  if (err) {
+    return err;
+  }
+
+  write_children(writer);
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+
+std::string Box_VisualSampleEntry::dump(Indent& indent) const
+{
+  std::stringstream sstr;
+  sstr << Box::dump(indent);
+  sstr << m_visualSampleEntry.dump(indent);
+  sstr << dump_children(indent);
+  return sstr.str();
+}
+
+
+Error Box_VisualSampleEntry::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  auto err = m_visualSampleEntry.parse(range, limits);
+  if (err) {
+    return err;
+  }
+
+  err = read_children(range, READ_CHILDREN_ALL, limits);
+  if (err) {
+    return err;
+  }
+
+  return Error::Ok;
+}
+
+
+std::string Box_sbgp::dump(Indent& indent) const
+{
+  std::stringstream sstr;
+  sstr << FullBox::dump(indent);
+  sstr << indent << "grouping_type: " << fourcc_to_string(m_grouping_type) << "\n";
+
+  if (m_grouping_type_parameter) {
+    sstr << indent << "grouping_type_parameter: " << *m_grouping_type_parameter << "\n";
+  }
+
+  uint32_t total_samples = 0;
+  for (size_t i = 0; i < m_entries.size(); i++) {
+    sstr << indent << "[" << std::setw(2) << (i + 1) << "] : " << std::setw(3) << m_entries[i].sample_count << "x " << m_entries[i].group_description_index << "\n";
+    total_samples += m_entries[i].sample_count;
+  }
+  sstr << indent << "total samples: " << total_samples << "\n";
+
+  return sstr.str();
+}
+
+
+void Box_sbgp::derive_box_version()
+{
+  if (m_grouping_type_parameter) {
+    set_version(1);
+  }
+  else {
+    set_version(0);
+  }
+}
+
+
+Error Box_sbgp::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  writer.write32(m_grouping_type);
+  if (m_grouping_type_parameter) {
+    writer.write32(*m_grouping_type_parameter);
+  }
+
+  if (m_entries.size() > 0xFFFFFFFF) {
+    return {heif_error_Usage_error,
+            heif_suberror_Invalid_parameter_value,
+            "Too many sbgp entries."};
+  }
+
+  writer.write32(static_cast<uint32_t>(m_entries.size()));
+  for (const auto& entry : m_entries) {
+    writer.write32(entry.sample_count);
+    writer.write32(entry.group_description_index);
+  }
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+
+Error Box_sbgp::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  parse_full_box_header(range);
+
+  if (get_version() > 1) {
+    return unsupported_version_error("sbgp");
+  }
+
+  m_grouping_type = range.read32();
+
+  if (get_version() == 1) {
+    m_grouping_type_parameter = range.read32();
+  }
+
+  uint32_t count = range.read32();
+  if (auto err = m_memory_handle.alloc(count * sizeof(Entry),
+                                       limits, "the 'sample to group' table")) {
+    return err;
+  }
+
+  for (uint32_t i = 0; i < count; i++) {
+    Entry e{};
+    e.sample_count = range.read32();
+    e.group_description_index = range.read32();
+    m_entries.push_back(e);
+    if (range.error()) {
+      return range.get_error();
+    }
+  }
+
+  return range.get_error();
+}
+
+
+std::string SampleGroupEntry_refs::dump() const
+{
+  std::stringstream sstr;
+  if (m_sample_id==0) {
+    sstr << "0 (non-ref) refs =";
+  }
+  else {
+    sstr << m_sample_id << " refs =";
+  }
+  for (uint32_t ref : m_direct_reference_sample_id) {
+    sstr << ' ' << ref;
+  }
+
+  return sstr.str();
+}
+
+Error SampleGroupEntry_refs::write(StreamWriter& writer) const
+{
+  return {};
+}
+
+Error SampleGroupEntry_refs::parse(BitstreamRange& range, const heif_security_limits*)
+{
+  m_sample_id = range.read32();
+  uint8_t cnt = range.read8();
+  for (uint8_t i = 0; i < cnt; i++) {
+    m_direct_reference_sample_id.push_back(range.read32());
+  }
+
+  return Error::Ok;
+}
+
+
+void Box_sgpd::derive_box_version()
+{
+  if (m_default_length) {
+    set_version(1);
+    assert(!m_default_sample_description_index);
+    return;
+  }
+
+  if (m_default_sample_description_index) {
+    set_version(2);
+    return;
+  }
+
+  set_version(0);
+}
+
+
+std::string Box_sgpd::dump(Indent& indent) const
+{
+  std::stringstream sstr;
+  sstr << FullBox::dump(indent);
+
+  sstr << indent << "grouping_type: " << fourcc_to_string(m_grouping_type) << "\n";
+  if (m_default_length) {
+    sstr << indent << "default_length: " << *m_default_length << "\n";
+  }
+  if (m_default_sample_description_index) {
+    sstr << indent << "default_sample_description_index: " << *m_default_sample_description_index << "\n";
+  }
+
+  for (size_t i=0; i<m_entries.size(); i++) {
+    sstr << indent << "[" << (i+1) << "] : ";
+    if (m_entries[i].sample_group_entry) {
+      sstr << m_entries[i].sample_group_entry->dump() << "\n";
+    }
+    else {
+      sstr << "empty (description_length=" << m_entries[i].description_length << ")\n";
+    }
+  }
+
+  return sstr.str();
+}
+
+
+Error Box_sgpd::write(StreamWriter& writer) const
+{
+return {};
+}
+
+
+Error Box_sgpd::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  parse_full_box_header(range);
+
+  m_grouping_type = range.read32();
+
+  if (get_version() == 1) {
+    m_default_length = range.read32();
+  }
+
+  if (get_version() >= 2) {
+    m_default_sample_description_index = range.read32();
+  }
+
+  uint32_t entry_count = range.read32();
+
+  if (limits->max_sample_group_description_box_entries &&
+      entry_count > limits->max_sample_group_description_box_entries) {
+    std::stringstream sstr;
+    sstr << "Allocating " << static_cast<uint64_t>(entry_count) << " sample group description items exceeds the security limit of "
+         << limits->max_sample_group_description_box_entries << " items";
+
+    return {heif_error_Memory_allocation_error,
+            heif_suberror_Security_limit_exceeded,
+            sstr.str()};
+
+  }
+
+  for (uint32_t i = 0; i < entry_count; i++) {
+    Entry entry;
+
+    if (get_version() == 1) {
+      if (*m_default_length == 0) {
+        entry.description_length = range.read32();
+      }
+    }
+
+    switch (m_grouping_type) {
+      case fourcc("refs"): {
+        entry.sample_group_entry = std::make_shared<SampleGroupEntry_refs>();
+        Error err = entry.sample_group_entry->parse(range, limits);
+        if (err) {
+          return err;
+        }
+
+        break;
+      }
+
+      default:
+        break;
+    }
+
+    m_entries.emplace_back(std::move(entry));
+  }
+
+  return Error::Ok;
+}
+
+
+std::string Box_btrt::dump(Indent& indent) const
+{
+  std::stringstream sstr;
+  sstr << FullBox::dump(indent);
+
+  sstr << indent << "bufferSizeDB: " << m_bufferSizeDB << " bytes\n";
+  sstr << indent << "max bitrate: " << m_maxBitrate << " bits/sec\n";
+  sstr << indent << "avg bitrate: " << m_avgBitrate << " bits/sec\n";
+
+  return sstr.str();
+}
+
+
+Error Box_btrt::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  writer.write32(m_bufferSizeDB);
+  writer.write32(m_maxBitrate);
+  writer.write32(m_avgBitrate);
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+
+Error Box_btrt::parse(BitstreamRange& range, const heif_security_limits*)
+{
+  m_bufferSizeDB = range.read32();
+  m_maxBitrate = range.read32();
+  m_avgBitrate = range.read32();
+
+  return Error::Ok;
+}
+
+
+
+void Box_saiz::set_aux_info_type(uint32_t aux_info_type, uint32_t aux_info_type_parameter)
+{
+  m_aux_info_type = aux_info_type;
+  m_aux_info_type_parameter = aux_info_type_parameter;
+
+  bool nonnull = (m_aux_info_type != 0 || m_aux_info_type_parameter != 0);
+  set_flags(nonnull ? 1 : 0);
+}
+
+
+void Box_saiz::add_sample_size(uint8_t s)
+{
+  // --- it is the first sample -> put into default size (except if it is a zero size = no sample aux info)
+
+  if (s != 0 && m_num_samples == 0) {
+    m_default_sample_info_size = s;
+    m_num_samples = 1;
+    return;
+  }
+
+  // --- if it's the default size, just add more to the number of default sizes
+
+  if (s != 0 && s == m_default_sample_info_size) {
+    m_num_samples++;
+    return;
+  }
+
+  // --- it is different from the default size -> add the list
+
+  // first copy samples with the default size into the list
+
+  if (m_default_sample_info_size != 0) {
+    for (uint32_t i = 0; i < m_num_samples; i++) {
+      m_sample_sizes.push_back(m_default_sample_info_size);
+    }
+
+    m_default_sample_info_size = 0;
+  }
+
+  // add the new sample size
+
+  m_num_samples++;
+  m_sample_sizes.push_back(s);
+}
+
+
+uint8_t Box_saiz::get_sample_size(uint32_t idx)
+{
+  if (m_default_sample_info_size != 0) {
+    return m_default_sample_info_size;
+  }
+
+  if (idx >= m_sample_sizes.size()) {
+    return 0;
+  }
+
+  return m_sample_sizes[idx];
+}
+
+
+std::string Box_saiz::dump(Indent& indent) const
+{
+  std::stringstream sstr;
+  sstr << FullBox::dump(indent);
+
+  sstr << indent << "aux_info_type: ";
+  if (m_aux_info_type == 0) {
+    sstr << "0\n";
+  }
+  else {
+    sstr << fourcc_to_string(m_aux_info_type) << "\n";
+  }
+
+  sstr << indent << "aux_info_type_parameter: ";
+  if (m_aux_info_type_parameter == 0) {
+    sstr << "0\n";
+  }
+  else {
+    sstr << fourcc_to_string(m_aux_info_type_parameter) << "\n";
+  }
+
+  sstr << indent << "default sample size: ";
+  if (m_default_sample_info_size == 0) {
+    sstr << "0 (variable)\n";
+  }
+  else {
+    sstr << ((int)m_default_sample_info_size) << "\n";
+  }
+
+  if (m_default_sample_info_size == 0) {
+    for (size_t i = 0; i < m_sample_sizes.size(); i++) {
+      sstr << indent << "[" << i << "] : " << ((int) m_sample_sizes[i]) << "\n";
+    }
+  }
+
+  return sstr.str();
+}
+
+
+Error Box_saiz::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  if (get_flags() & 1) {
+    writer.write32(m_aux_info_type);
+    writer.write32(m_aux_info_type_parameter);
+  }
+
+  writer.write8(m_default_sample_info_size);
+
+  if (m_default_sample_info_size == 0) {
+    assert(m_num_samples == m_sample_sizes.size());
+
+    uint32_t num_nonnull_samples = static_cast<uint32_t>(m_sample_sizes.size());
+    while (num_nonnull_samples > 0 && m_sample_sizes[num_nonnull_samples-1] == 0) {
+      num_nonnull_samples--;
+    }
+
+    writer.write32(num_nonnull_samples);
+
+    for (size_t i = 0; i < num_nonnull_samples; i++) {
+      writer.write8(m_sample_sizes[i]);
+    }
+  }
+  else {
+    writer.write32(m_num_samples);
+  }
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+
+Error Box_saiz::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  parse_full_box_header(range);
+
+  if (get_flags() & 1) {
+    m_aux_info_type = range.read32();
+    m_aux_info_type_parameter = range.read32();
+  }
+
+  m_default_sample_info_size = range.read8();
+  m_num_samples = range.read32();
+
+  if (limits && limits->max_sequence_frames > 0 && m_num_samples > limits->max_sequence_frames) {
+    return {
+      heif_error_Memory_allocation_error,
+      heif_suberror_Security_limit_exceeded,
+      "Number of 'saiz' samples exceeds the maximum number of sequence frames."
+    };
+  }
+
+  if (m_default_sample_info_size == 0) {
+    // check required memory
+
+    uint64_t mem_size = m_num_samples;
+    if (auto err = m_memory_handle.alloc(mem_size, limits, "the 'sample aux info sizes' (saiz) table")) {
+      return err;
+    }
+
+    // read whole table at once
+
+    m_sample_sizes.resize(m_num_samples);
+    range.read(m_sample_sizes.data(), m_num_samples);
+  }
+
+  return range.get_error();
+}
+
+
+
+void Box_saio::set_aux_info_type(uint32_t aux_info_type, uint32_t aux_info_type_parameter)
+{
+  m_aux_info_type = aux_info_type;
+  m_aux_info_type_parameter = aux_info_type_parameter;
+
+  bool nonnull = (m_aux_info_type != 0 || m_aux_info_type_parameter != 0);
+  set_flags(nonnull ? 1 : 0);
+}
+
+
+void Box_saio::add_chunk_offset(uint64_t s)
+{
+  if (s > 0xFFFFFFFF) {
+    m_need_64bit = true;
+    set_version(1);
+  }
+
+  m_chunk_offset.push_back(s);
+}
+
+
+uint64_t Box_saio::get_chunk_offset(uint32_t idx) const
+{
+  if (idx >= m_chunk_offset.size()) {
+    return 0;
+  }
+  else {
+    return m_chunk_offset[idx];
+  }
+}
+
+
+std::string Box_saio::dump(Indent& indent) const
+{
+  std::stringstream sstr;
+  sstr << FullBox::dump(indent);
+
+  sstr << indent << "aux_info_type: ";
+  if (m_aux_info_type == 0) {
+    sstr << "0\n";
+  }
+  else {
+    sstr << fourcc_to_string(m_aux_info_type) << "\n";
+  }
+
+  sstr << indent << "aux_info_type_parameter: ";
+  if (m_aux_info_type_parameter == 0) {
+    sstr << "0\n";
+  }
+  else {
+    sstr << fourcc_to_string(m_aux_info_type_parameter) << "\n";
+  }
+
+  for (size_t i = 0; i < m_chunk_offset.size(); i++) {
+    sstr << indent << "[" << i << "] : 0x" << std::hex << m_chunk_offset[i] << "\n";
+  }
+
+  return sstr.str();
+}
+
+
+void Box_saio::patch_file_pointers(StreamWriter& writer, size_t offset)
+{
+  size_t oldPosition = writer.get_position();
+
+  writer.set_position(m_offset_start_pos);
+
+  for (uint64_t ptr : m_chunk_offset) {
+    if (get_version() == 0 && ptr + offset > std::numeric_limits<uint32_t>::max()) {
+      writer.write32(0); // TODO: error
+    } else if (get_version() == 0) {
+      writer.write32(static_cast<uint32_t>(ptr + offset));
+    } else {
+      writer.write64(ptr + offset);
+    }
+  }
+
+  writer.set_position(oldPosition);
+}
+
+
+Error Box_saio::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  if (get_flags() & 1) {
+    writer.write32(m_aux_info_type);
+    writer.write32(m_aux_info_type_parameter);
+  }
+
+  if (m_chunk_offset.size() > std::numeric_limits<uint32_t>::max()) {
+    return Error{heif_error_Unsupported_feature,
+                 heif_suberror_Unspecified,
+                 "Maximum number of chunks exceeded"};
+  }
+  writer.write32(static_cast<uint32_t>(m_chunk_offset.size()));
+
+  m_offset_start_pos = writer.get_position();
+
+  for (uint64_t size : m_chunk_offset) {
+    if (m_need_64bit) {
+      writer.write64(size);
+    } else {
+      writer.write32(static_cast<uint32_t>(size));
+    }
+  }
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+
+Error Box_saio::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  parse_full_box_header(range);
+
+  if (get_flags() & 1) {
+    m_aux_info_type = range.read32();
+    m_aux_info_type_parameter = range.read32();
+  }
+
+  uint32_t num_chunks = range.read32();
+
+  // We have no explicit maximum on the number of chunks.
+  // Use the maximum number of frames as an upper limit.
+  if (limits && limits->max_sequence_frames > 0 && num_chunks > limits->max_sequence_frames) {
+    return {
+      heif_error_Memory_allocation_error,
+      heif_suberror_Security_limit_exceeded,
+      "Number of 'saio' chunks exceeds the maximum number of sequence frames."
+    };
+  }
+
+  // check required memory
+  uint64_t mem_size = num_chunks * sizeof(uint64_t);
+
+  if (auto err = m_memory_handle.alloc(mem_size, limits, "the 'saio' table")) {
+    return err;
+  }
+
+  m_chunk_offset.resize(num_chunks);
+
+  for (uint32_t i = 0; i < num_chunks; i++) {
+    uint64_t offset;
+    if (get_version() == 1) {
+      offset = range.read64();
+    }
+    else {
+      offset = range.read32();
+    }
+
+    m_chunk_offset[i] = offset;
+
+    if (range.error()) {
+      return range.get_error();
+    }
+  }
+
+  return Error::Ok;
+}
+
+
+std::string Box_sdtp::dump(Indent& indent) const
+{
+  std::stringstream sstr;
+  sstr << FullBox::dump(indent);
+
+  assert(m_sample_information.size() <= UINT32_MAX);
+
+  for (uint32_t i = 0; i < static_cast<uint32_t>(m_sample_information.size()); i++) {
+    const char* spaces = "            ";
+    int nSpaces = 6;
+    int k = i;
+    while (k >= 10 && nSpaces < 12) {
+      k /= 10;
+      nSpaces++;
+    }
+
+    spaces = spaces + 12 - nSpaces;
+
+    sstr << indent << "[" << i << "] : is_leading=" << (int) get_is_leading(i) << "\n"
+        << indent << spaces << "depends_on=" << (int) get_depends_on(i) << "\n"
+        << indent << spaces << "is_depended_on=" << (int) get_is_depended_on(i) << "\n"
+        << indent << spaces << "has_redundancy=" << (int) get_has_redundancy(i) << "\n";
+  }
+
+  return sstr.str();
+}
+
+
+Error Box_sdtp::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  parse_full_box_header(range);
+
+  // We have no easy way to get the number of samples from 'saiz' or 'stz2' as specified
+  // in the standard. Instead, we read until the end of the box.
+  size_t nSamples = range.get_remaining_bytes();
+
+  m_sample_information.resize(nSamples);
+  range.read(m_sample_information.data(), nSamples);
+
+  return Error::Ok;
+}
+
+
+Error Box_tref::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  while (!range.eof()) {
+    BoxHeader header;
+    Error err = header.parse_header(range);
+    if (err != Error::Ok) {
+      return err;
+    }
+
+    if (header.get_box_size() < header.get_header_size()) {
+      return {heif_error_Invalid_input,
+              heif_suberror_Unspecified,
+              "Invalid box size (smaller than header)"};
+    }
+
+    uint64_t dataSize = (header.get_box_size() - header.get_header_size());
+
+    if (dataSize % 4 != 0 || dataSize < 4) {
+      return {heif_error_Invalid_input,
+              heif_suberror_Unspecified,
+              "Input file has a 'tref' TrackReferenceTypeBox with invalid size."};
+    }
+
+    uint64_t nRefs = dataSize / 4;
+
+    if (limits->max_items && nRefs > limits->max_items) {
+      std::stringstream sstr;
+      sstr << "Number of references in tref box (" << nRefs << ") exceeds the security limits of " << limits->max_items << " references.";
+
+      return {heif_error_Invalid_input,
+              heif_suberror_Security_limit_exceeded,
+              sstr.str()};
+    }
+
+    Reference ref;
+    ref.reference_type = header.get_short_type();
+
+    for (uint64_t i = 0; i < nRefs; i++) {
+      if (range.eof()) {
+        std::stringstream sstr;
+        sstr << "tref box should contain " << nRefs << " references, but we can only read " << i << " references.";
+
+        return {heif_error_Invalid_input,
+                heif_suberror_End_of_data,
+                sstr.str()};
+      }
+
+      ref.to_track_id.push_back(static_cast<uint32_t>(range.read32()));
+    }
+
+    m_references.push_back(ref);
+  }
+
+
+  // --- check for duplicate references
+
+  if (auto error = check_for_double_references()) {
+    return error;
+  }
+
+  return range.get_error();
+}
+
+
+Error Box_tref::check_for_double_references() const
+{
+  for (const auto& ref : m_references) {
+    std::set<uint32_t> to_ids;
+    for (const auto to_id : ref.to_track_id) {
+      if (to_ids.find(to_id) == to_ids.end()) {
+        to_ids.insert(to_id);
+      }
+      else {
+        return {heif_error_Invalid_input,
+                heif_suberror_Unspecified,
+                "'tref' has double references"};
+      }
+    }
+  }
+
+  return Error::Ok;
+}
+
+
+Error Box_tref::write(StreamWriter& writer) const
+{
+  if (auto error = check_for_double_references()) {
+    return error;
+  }
+
+  size_t box_start = reserve_box_header_space(writer);
+
+  for (const auto& ref : m_references) {
+    uint32_t box_size = 8 + uint32_t(ref.to_track_id.size() * 4);
+
+    // we write the BoxHeader ourselves since it is very simple
+    writer.write32(box_size);
+    writer.write32(ref.reference_type);
+
+    for (uint32_t r : ref.to_track_id) {
+      writer.write32(r);
+    }
+  }
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+
+std::string Box_tref::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
+
+  for (const auto& ref : m_references) {
+    sstr << indent << "reference with type '" << fourcc_to_string(ref.reference_type) << "'"
+         << " to track IDs: ";
+    for (uint32_t id : ref.to_track_id) {
+      sstr << id << " ";
+    }
+    sstr << "\n";
+  }
+
+  return sstr.str();
+}
+
+
+std::vector<uint32_t> Box_tref::get_references(uint32_t ref_type) const
+{
+  for (const Reference& ref : m_references) {
+    if (ref.reference_type == ref_type) {
+      return ref.to_track_id;
+    }
+  }
+
+  return {};
+}
+
+
+size_t Box_tref::get_number_of_references_of_type(uint32_t ref_type) const
+{
+  for (const Reference& ref : m_references) {
+    if (ref.reference_type == ref_type) {
+      return ref.to_track_id.size();
+    }
+  }
+
+  return 0;
+}
+
+
+std::vector<uint32_t> Box_tref::get_reference_types() const
+{
+  std::vector<uint32_t> types;
+  types.reserve(m_references.size());
+  for (const auto& ref : m_references) {
+    types.push_back(ref.reference_type);
+  }
+
+  return types;
+}
+
+
+void Box_tref::add_references(uint32_t to_track_id, uint32_t type)
+{
+  for (auto& ref : m_references) {
+    if (ref.reference_type == type) {
+      ref.to_track_id.push_back(to_track_id);
+      return;
+    }
+  }
+
+  Reference ref;
+  ref.reference_type = type;
+  ref.to_track_id = {to_track_id};
+
+  m_references.push_back(ref);
+}
+
+
+Error Box_elst::parse(BitstreamRange& range, const heif_security_limits* limits)
+{
+  Error err = parse_full_box_header(range);
+  if (err != Error::Ok) {
+    return err;
+  }
+
+  if (get_version() > 1) {
+    return unsupported_version_error("edts");
+  }
+
+  uint32_t nEntries = range.read32();
+  m_entries.clear();
+
+  for (uint64_t i = 0; i < nEntries; i++) {
+    if (range.eof()) {
+      std::stringstream sstr;
+      sstr << "edts box should contain " << nEntries << " entries, but we can only read " << i << " entries.";
+
+      return {heif_error_Invalid_input,
+              heif_suberror_End_of_data,
+              sstr.str()};
+    }
+
+    Entry entry{};
+    if (get_version() == 1) {
+      entry.segment_duration = range.read64();
+      entry.media_time = range.read64s();
+    }
+    else {
+      entry.segment_duration = range.read32();
+      entry.media_time = range.read32s();
+    }
+
+    entry.media_rate_integer = range.read16s();
+    entry.media_rate_fraction = range.read16s();
+
+    m_entries.push_back(entry);
+  }
+
+  return range.get_error();
+}
+
+
+Error Box_elst::write(StreamWriter& writer) const
+{
+  size_t box_start = reserve_box_header_space(writer);
+
+  if (m_entries.size() > std::numeric_limits<uint32_t>::max()) {
+    return {heif_error_Usage_error,
+            heif_suberror_Invalid_parameter_value,
+            "Too many entries in edit list"};
+  }
+
+  writer.write32(static_cast<uint32_t>(m_entries.size()));
+
+
+  for (const auto& entry : m_entries) {
+    if (get_version() == 1) {
+      writer.write64(entry.segment_duration);
+      writer.write64s(entry.media_time);
+    }
+    else {
+      // The cast is valid because we check in derive_box_version() whether everything
+      // fits into 32bit. If not, version 1 is used.
+
+      writer.write32(static_cast<uint32_t>(entry.segment_duration));
+      writer.write32s(static_cast<int32_t>(entry.media_time));
+    }
+
+    writer.write16s(entry.media_rate_integer);
+    writer.write16s(entry.media_rate_fraction);
+  }
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+
+std::string Box_elst::dump(Indent& indent) const
+{
+  std::ostringstream sstr;
+  sstr << FullBox::dump(indent);
+
+  sstr << indent << "repeat list: " << ((get_flags() & Flags::Repeat_EditList) ? "yes" : "no") << "\n";
+
+  for (const auto& entry : m_entries) {
+    sstr << indent << "segment duration: " << entry.segment_duration << "\n";
+    sstr << indent << "media time: " << entry.media_time << "\n";
+    sstr << indent << "media rate integer: " << entry.media_rate_integer << "\n";
+    sstr << indent << "media rate fraction: " << entry.media_rate_fraction << "\n";
+  }
+
+  return sstr.str();
+}
+
+void Box_elst::derive_box_version()
+{
+  // check whether we need 64bit values
+
+  bool need_64bit = std::any_of(m_entries.begin(),
+                                m_entries.end(),
+                                [](const Entry& entry) {
+                                  return (entry.segment_duration > std::numeric_limits<uint32_t>::max() ||
+                                          entry.media_time > std::numeric_limits<int32_t>::max());
+                                });
+
+  if (need_64bit) {
+    set_version(1);
+  }
+  else {
+    set_version(0);
+  }
+}
+
+
+void Box_elst::enable_repeat_mode(bool enable)
+{
+  uint32_t flags = get_flags();
+  if (enable) {
+    flags |= Flags::Repeat_EditList;
+  }
+  else {
+    flags &= ~Flags::Repeat_EditList;
+  }
+
+  set_flags(flags);
+}
+
+
+void Box_elst::add_entry(const Entry& entry)
+{
+  m_entries.push_back(entry);
+}
diff --git a/libheif/sequences/seq_boxes.h b/libheif/sequences/seq_boxes.h
new file mode 100644
index 0000000000..b12350dcd0
--- /dev/null
+++ b/libheif/sequences/seq_boxes.h
@@ -0,0 +1,1035 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef SEQ_BOXES_H
+#define SEQ_BOXES_H
+
+#include "box.h"
+#include "security_limits.h"
+
+#include <string>
+#include <memory>
+#include <vector>
+
+
+class Box_container : public Box {
+public:
+  Box_container(const char* type)
+  {
+    set_short_type(fourcc(type));
+  }
+
+  std::string dump(Indent&) const override;
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+};
+
+
+// Movie Box
+class Box_moov : public Box_container {
+public:
+  Box_moov() : Box_container("moov") {}
+
+  const char* debug_box_name() const override { return "Movie"; }
+};
+
+
+// Movie Header Box
+class Box_mvhd : public FullBox {
+public:
+  Box_mvhd()
+  {
+    set_short_type(fourcc("mvhd"));
+  }
+
+  std::string dump(Indent&) const override;
+
+  const char* debug_box_name() const override { return "Movie Header"; }
+
+  Error write(StreamWriter& writer) const override;
+
+  void derive_box_version() override;
+
+  double get_rate() const { return m_rate / double(0x10000); }
+
+  float get_volume() const { return float(m_volume) / float(0x100); }
+
+  double get_matrix_element(int idx) const;
+
+  uint32_t get_time_scale() const { return m_timescale; }
+
+  uint64_t get_duration() const { return m_duration; }
+
+  void set_duration(uint64_t duration) { m_duration = duration; }
+
+  void set_time_scale(uint32_t timescale) { m_timescale = timescale; }
+
+  void set_next_track_id(uint32_t next_id) { m_next_track_ID = next_id; }
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+
+private:
+  uint64_t m_creation_time = 0;
+  uint64_t m_modification_time = 0;
+  uint32_t m_timescale = 0;
+  uint64_t m_duration = 0;
+
+  uint32_t m_rate = 0x00010000; // typically 1.0
+  uint16_t m_volume = 0x0100; // typically, full volume
+
+  uint32_t m_matrix[9] = {0x00010000, 0, 0, 0, 0x00010000, 0, 0, 0, 0x40000000};
+  uint32_t m_next_track_ID = 0;
+};
+
+
+// Track Box
+class Box_trak : public Box_container {
+public:
+  Box_trak() : Box_container("trak") {}
+
+  const char* debug_box_name() const override { return "Track"; }
+};
+
+
+// Track Header Box
+class Box_tkhd : public FullBox {
+public:
+  Box_tkhd()
+  {
+    set_short_type(fourcc("tkhd"));
+
+    // set default flags according to ISO 14496-12
+    set_flags(Track_enabled | Track_in_movie | Track_in_preview);
+  }
+
+  enum Flags : uint32_t {
+    Track_enabled = 0x01,
+    Track_in_movie = 0x02,
+    Track_in_preview = 0x04,
+    Track_size_is_aspect_ratio = 0x08
+  };
+
+  std::string dump(Indent&) const override;
+
+  const char* debug_box_name() const override { return "Track Header"; }
+
+  Error write(StreamWriter& writer) const override;
+
+  void derive_box_version() override;
+
+  float get_volume() const { return float(m_volume) / float(0x100); }
+
+  double get_matrix_element(int idx) const;
+
+  double get_width() const { return float(m_width) / double(0x10000); }
+
+  double get_height() const { return float(m_height) / double(0x10000); }
+
+  uint32_t get_track_id() const { return m_track_id; }
+
+  void set_track_id(uint32_t track_id) { m_track_id = track_id; }
+
+  void set_resolution(double width, double height)
+  {
+    m_width = (uint32_t) (width * 0x10000);
+    m_height = (uint32_t) (height * 0x10000);
+  }
+
+  uint64_t get_duration() const { return m_duration; }
+
+  void set_duration(uint64_t duration) { m_duration = duration; }
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+
+private:
+  uint64_t m_creation_time = 0;
+  uint64_t m_modification_time = 0;
+  uint32_t m_track_id = 0;
+  uint64_t m_duration = 0;
+
+  uint16_t m_layer = 0;
+  uint16_t m_alternate_group = 0;
+  uint16_t m_volume = 0x0100; // typically, full volume
+
+  uint32_t m_matrix[9] = {0x00010000, 0, 0, 0, 0x00010000, 0, 0, 0, 0x40000000};
+
+  uint32_t m_width = 0;
+  uint32_t m_height = 0;
+};
+
+
+// Media Box
+class Box_mdia : public Box_container {
+public:
+  Box_mdia() : Box_container("mdia") {}
+
+  const char* debug_box_name() const override { return "Media"; }
+};
+
+
+// Media Header Box
+class Box_mdhd : public FullBox {
+public:
+  Box_mdhd()
+  {
+    set_short_type(fourcc("mdhd"));
+  }
+
+  std::string dump(Indent&) const override;
+
+  const char* debug_box_name() const override { return "Media Header"; }
+
+  Error write(StreamWriter& writer) const override;
+
+  void derive_box_version() override;
+
+  double get_matrix_element(int idx) const;
+
+  uint32_t get_timescale() const { return m_timescale; }
+
+  void set_timescale(uint32_t timescale) { m_timescale = timescale; }
+
+  uint64_t get_duration() const { return m_duration; }
+
+  void set_duration(uint64_t duration) { m_duration = duration; }
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+
+private:
+  uint64_t m_creation_time = 0;
+  uint64_t m_modification_time = 0;
+  uint32_t m_timescale = 0;
+  uint64_t m_duration = 0;
+
+  char m_language[4] = {'u', 'n', 'k', 0};
+};
+
+
+// Media Information Box (container)
+class Box_minf : public Box_container {
+public:
+  Box_minf() : Box_container("minf") {}
+
+  const char* debug_box_name() const override { return "Media Information"; }
+};
+
+
+// Video Media Header
+class Box_vmhd : public FullBox {
+public:
+  Box_vmhd()
+  {
+    set_short_type(fourcc("vmhd"));
+    set_flags(1);
+  }
+
+  std::string dump(Indent&) const override;
+
+  const char* debug_box_name() const override { return "Video Media Header"; }
+
+  Error write(StreamWriter& writer) const override;
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+
+private:
+  uint16_t m_graphics_mode = 0;
+  uint16_t m_op_color[3] = {0, 0, 0};
+};
+
+
+// Null Media Header
+class Box_nmhd : public FullBox {
+public:
+  Box_nmhd()
+  {
+    set_short_type(fourcc("nmhd"));
+    set_flags(1);
+  }
+
+  std::string dump(Indent&) const override;
+
+  const char* debug_box_name() const override { return "Null Media Header"; }
+
+  Error write(StreamWriter& writer) const override;
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+};
+
+
+// Sample Table Box (container)
+class Box_stbl : public Box_container {
+public:
+  Box_stbl() : Box_container("stbl") {}
+
+  const char* debug_box_name() const override { return "Sample Table"; }
+};
+
+
+// Sample Description Box
+class Box_stsd : public FullBox {
+public:
+  Box_stsd()
+  {
+    set_short_type(fourcc("stsd"));
+  }
+
+  std::string dump(Indent&) const override;
+
+  const char* debug_box_name() const override { return "Sample Description"; }
+
+  Error write(StreamWriter& writer) const override;
+
+  std::shared_ptr<const class Box> get_sample_entry(size_t idx) const
+  {
+    if (idx >= m_sample_entries.size()) {
+      return nullptr;
+    } else {
+      return m_sample_entries[idx];
+    }
+  }
+
+  void add_sample_entry(std::shared_ptr<class Box> entry)
+  {
+    m_sample_entries.push_back(entry);
+  }
+
+  size_t get_num_sample_entries() const { return m_sample_entries.size(); }
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+
+private:
+  std::vector<std::shared_ptr<class Box>> m_sample_entries;
+};
+
+
+// Decoding Time to Sample Box
+class Box_stts : public FullBox {
+public:
+  Box_stts()
+  {
+    set_short_type(fourcc("stts"));
+  }
+
+  std::string dump(Indent&) const override;
+
+  const char* debug_box_name() const override { return "Decoding Time to Sample"; }
+
+  Error write(StreamWriter& writer) const override;
+
+  struct TimeToSample {
+    uint32_t sample_count;
+    uint32_t sample_delta;
+  };
+
+  uint32_t get_sample_duration(uint32_t sample_idx);
+
+  void append_sample_duration(uint32_t duration);
+
+  uint64_t get_total_duration(bool include_last_frame_duration);
+
+  uint32_t get_number_of_samples() const;
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+
+private:
+  std::vector<TimeToSample> m_entries;
+  MemoryHandle m_memory_handle;
+};
+
+
+// Composition Time to Sample Box
+class Box_ctts : public FullBox {
+public:
+  Box_ctts()
+  {
+    set_short_type(fourcc("ctts"));
+  }
+
+  std::string dump(Indent&) const override;
+
+  const char* debug_box_name() const override { return "Composition Time to Sample"; }
+
+  Error write(StreamWriter& writer) const override;
+
+  struct OffsetToSample {
+    uint32_t sample_count;
+    int32_t sample_offset;   // either uint32_t or int32_t, we assume that all uint32_t values will also fit into int32_t
+  };
+
+  int32_t get_sample_offset(uint32_t sample_idx);
+
+  void append_sample_offset(int32_t offset);
+
+  bool is_constant_offset() const;
+
+  void derive_box_version() override;
+
+  int32_t compute_min_offset() const;
+
+  uint32_t get_number_of_samples() const;
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+
+private:
+  std::vector<OffsetToSample> m_entries;
+  MemoryHandle m_memory_handle;
+};
+
+
+// Sample to Chunk Box
+class Box_stsc : public FullBox {
+public:
+  Box_stsc()
+  {
+    set_short_type(fourcc("stsc"));
+  }
+
+  std::string dump(Indent&) const override;
+
+  const char* debug_box_name() const override { return "Sample to Chunk"; }
+
+  Error write(StreamWriter& writer) const override;
+
+  struct SampleToChunk {
+    uint32_t first_chunk;
+    uint32_t samples_per_chunk;
+    uint32_t sample_description_index;
+  };
+
+  const std::vector<SampleToChunk>& get_chunks() const { return m_entries; }
+
+  // idx counting starts at 1
+  const SampleToChunk* get_chunk(uint32_t idx) const;
+
+  void add_chunk(uint32_t description_index);
+
+  void increase_samples_in_chunk(uint32_t nFrames);
+
+  bool last_chunk_empty() const {
+    assert(!m_entries.empty());
+
+    return m_entries.back().samples_per_chunk == 0;
+  }
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+
+private:
+  std::vector<SampleToChunk> m_entries;
+  MemoryHandle m_memory_handle;
+};
+
+
+// Chunk Offset Box
+class Box_stco : public FullBox {
+public:
+  Box_stco()
+  {
+    set_short_type(fourcc("stco"));
+  }
+
+  std::string dump(Indent&) const override;
+
+  const char* debug_box_name() const override { return "Sample Offset"; }
+
+  Error write(StreamWriter& writer) const override;
+
+  void add_chunk_offset(uint32_t offset) { m_offsets.push_back(offset); }
+
+  const std::vector<uint32_t>& get_offsets() const { return m_offsets; }
+
+  size_t get_number_of_chunks() const { return m_offsets.size(); }
+
+  void patch_file_pointers(StreamWriter&, size_t offset) override;
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+
+private:
+  std::vector<uint32_t> m_offsets;
+  MemoryHandle m_memory_handle;
+
+  mutable size_t m_offset_start_pos = 0;
+};
+
+
+// Sample Size Box
+class Box_stsz : public FullBox {
+public:
+  Box_stsz()
+  {
+    set_short_type(fourcc("stsz"));
+  }
+
+  std::string dump(Indent&) const override;
+
+  const char* debug_box_name() const override { return "Sample Size"; }
+
+  Error write(StreamWriter& writer) const override;
+
+  bool has_fixed_sample_size() const { return m_fixed_sample_size != 0; }
+
+  uint32_t get_fixed_sample_size() const { return m_fixed_sample_size; }
+
+  uint32_t num_samples() const { return m_sample_count; }
+
+  const std::vector<uint32_t>& get_sample_sizes() const { return m_sample_sizes; }
+
+  void append_sample_size(uint32_t size);
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+
+private:
+  uint32_t m_fixed_sample_size = 0;
+  uint32_t m_sample_count = 0;
+  std::vector<uint32_t> m_sample_sizes;
+  MemoryHandle m_memory_handle;
+};
+
+
+// Sync Sample Box
+class Box_stss : public FullBox {
+public:
+  Box_stss()
+  {
+    set_short_type(fourcc("stss"));
+  }
+
+  std::string dump(Indent&) const override;
+
+  const char* debug_box_name() const override { return "Sync Sample"; }
+
+  Error write(StreamWriter& writer) const override;
+
+  void add_sync_sample(uint32_t sample_idx) { m_sync_samples.push_back(sample_idx); }
+
+  // when this is set, the Box will compute whether it can be skipped
+  void set_total_number_of_samples(uint32_t num_samples);
+
+  // bool skip_box() const override { return m_all_samples_are_sync_samples; }
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+
+private:
+  std::vector<uint32_t> m_sync_samples;
+  MemoryHandle m_memory_handle;
+
+  bool m_all_samples_are_sync_samples = false;
+};
+
+
+struct CodingConstraints {
+  bool all_ref_pics_intra = false;
+  bool intra_pred_used = false;
+  uint8_t max_ref_per_pic = 0; // 4 bit
+};
+
+
+// Coding Constraints Box
+class Box_ccst : public FullBox {
+public:
+  Box_ccst()
+  {
+    set_short_type(fourcc("ccst"));
+  }
+
+  std::string dump(Indent&) const override;
+
+  const char* debug_box_name() const override { return "Coding Constraints"; }
+
+  Error write(StreamWriter& writer) const override;
+
+  void set_coding_constraints(const CodingConstraints& c) { m_codingConstraints = c; }
+
+  const CodingConstraints& get_coding_constraints() const { return m_codingConstraints; }
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+
+private:
+  CodingConstraints m_codingConstraints;
+};
+
+
+class Box_auxi : public FullBox {
+public:
+  Box_auxi()
+  {
+    set_short_type(fourcc("auxi"));
+  }
+
+  std::string dump(Indent&) const override;
+
+  const char* debug_box_name() const override { return "Auxiliary Info Type"; }
+
+  Error write(StreamWriter& writer) const override;
+
+  void set_aux_track_type_urn(const std::string& t) { m_aux_track_type = t; }
+
+  std::string get_aux_track_type_urn() const { return m_aux_track_type; }
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+
+private:
+  std::string m_aux_track_type;
+};
+
+
+struct VisualSampleEntry {
+  // from SampleEntry
+  //const unsigned int(8)[6] reserved = 0;
+  uint16_t data_reference_index = 1;
+
+  // VisualSampleEntry
+
+  uint16_t pre_defined = 0;
+  //uint16_t reserved = 0;
+  uint32_t pre_defined2[3] = {0, 0, 0};
+  uint16_t width = 0;
+  uint16_t height = 0;
+  uint32_t horizresolution = 0x00480000; // 72 dpi
+  uint32_t vertresolution = 0x00480000; // 72 dpi
+  //uint32_t reserved = 0;
+  uint16_t frame_count = 1;
+  std::string compressorname; // max 32 characters
+  uint16_t depth = 0x0018;
+  int16_t pre_defined3 = -1;
+  // other boxes from derived specifications
+  //std::shared_ptr<Box_clap> clap; // optional
+  //std::shared_ptr<Box_pixi> pixi; // optional
+
+  double get_horizontal_resolution() const { return horizresolution / double(0x10000); }
+
+  double get_vertical_resolution() const { return vertresolution / double(0x10000); }
+
+  Error parse(BitstreamRange& range, const heif_security_limits*);
+
+  Error write(StreamWriter& writer) const;
+
+  std::string dump(Indent&) const;
+};
+
+
+class Box_VisualSampleEntry : public Box {
+public:
+  Error write(StreamWriter& writer) const override;
+
+  std::string dump(Indent&) const override;
+
+  const VisualSampleEntry& get_VisualSampleEntry_const() const { return m_visualSampleEntry; }
+
+  VisualSampleEntry& get_VisualSampleEntry() { return m_visualSampleEntry; }
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits* limits) override;
+
+private:
+  VisualSampleEntry m_visualSampleEntry;
+};
+
+
+class Box_URIMetaSampleEntry : public Box {
+public:
+  Box_URIMetaSampleEntry()
+  {
+    set_short_type(fourcc("urim"));
+  }
+
+  Error write(StreamWriter& writer) const override;
+
+  std::string dump(Indent&) const override;
+
+  const char* debug_box_name() const override { return "URI Meta Sample Entry"; }
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits* limits) override;
+
+private:
+  // from SampleEntry
+  //const unsigned int(8)[6] reserved = 0;
+  uint16_t data_reference_index;
+};
+
+
+class Box_uri : public FullBox {
+public:
+  Box_uri()
+  {
+    set_short_type(fourcc("uri "));
+  }
+
+  void set_uri(std::string uri) { m_uri = uri; }
+
+  std::string get_uri() const { return m_uri; }
+
+  Error write(StreamWriter& writer) const override;
+
+  std::string dump(Indent&) const override;
+
+  const char* debug_box_name() const override { return "URI"; }
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits* limits) override;
+
+private:
+  std::string m_uri;
+};
+
+
+// Sample to Group
+class Box_sbgp : public FullBox {
+public:
+  Box_sbgp()
+  {
+    set_short_type(fourcc("sbgp"));
+  }
+
+  void derive_box_version() override;
+
+  std::string dump(Indent&) const override;
+
+  const char* debug_box_name() const override { return "Sample to Group"; }
+
+  Error write(StreamWriter& writer) const override;
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+
+private:
+  uint32_t m_grouping_type = 0; // 4cc
+  std::optional<uint32_t> m_grouping_type_parameter;
+
+  struct Entry {
+    uint32_t sample_count;
+    uint32_t group_description_index;
+  };
+
+  std::vector<Entry> m_entries;
+  MemoryHandle m_memory_handle;
+};
+
+
+class SampleGroupEntry
+{
+public:
+  virtual ~SampleGroupEntry() = default;
+
+  virtual std::string dump() const = 0;
+
+  virtual Error write(StreamWriter& writer) const = 0;
+
+  virtual Error parse(BitstreamRange& range, const heif_security_limits*) = 0;
+};
+
+
+class SampleGroupEntry_refs : public SampleGroupEntry
+{
+public:
+  std::string dump() const override;
+
+  Error write(StreamWriter& writer) const override;
+
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+
+private:
+  uint32_t m_sample_id;
+  std::vector<uint32_t> m_direct_reference_sample_id;
+};
+
+
+// Sample Group Description
+class Box_sgpd : public FullBox {
+public:
+  Box_sgpd()
+  {
+    set_short_type(fourcc("sgpd"));
+  }
+
+  void derive_box_version() override;
+
+  std::string dump(Indent&) const override;
+
+  const char* debug_box_name() const override { return "Sample Group Description"; }
+
+  Error write(StreamWriter& writer) const override;
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+
+private:
+  uint32_t m_grouping_type = 0; // 4cc
+  std::optional<uint32_t> m_default_length; // version 1  (0 -> variable length)
+  std::optional<uint32_t> m_default_sample_description_index;; // version >= 2
+
+  struct Entry {
+    uint32_t description_length = 0; // if version==1 && m_default_length == 0
+    std::shared_ptr<SampleGroupEntry> sample_group_entry;
+  };
+
+  std::vector<Entry> m_entries;
+};
+
+// Bitrate
+class Box_btrt : public FullBox {
+public:
+  Box_btrt()
+  {
+    set_short_type(fourcc("btrt"));
+  }
+
+  std::string dump(Indent&) const override;
+
+  const char* debug_box_name() const override { return "Bitrate"; }
+
+  Error write(StreamWriter& writer) const override;
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+
+private:
+  uint32_t m_bufferSizeDB;
+  uint32_t m_maxBitrate;
+  uint32_t m_avgBitrate;
+};
+
+
+class Box_saiz : public FullBox {
+public:
+  Box_saiz()
+  {
+    set_short_type(fourcc("saiz"));
+  }
+
+  void set_aux_info_type(uint32_t aux_info_type, uint32_t aux_info_type_parameter = 0);
+
+  uint32_t get_aux_info_type() const { return m_aux_info_type; }
+
+  uint32_t get_aux_info_type_parameter() const { return m_aux_info_type_parameter; }
+
+  void add_sample_size(uint8_t s);
+
+  void add_nonpresent_sample() { add_sample_size(0); }
+
+  uint8_t get_sample_size(uint32_t idx);
+
+  bool have_samples_constant_size() const { return m_default_sample_info_size != 0; }
+
+  uint32_t get_num_samples() const { return m_num_samples; }
+
+  std::string dump(Indent&) const override;
+
+  const char* debug_box_name() const override { return "Sample Auxiliary Information Sizes"; }
+
+  Error write(StreamWriter& writer) const override;
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+
+private:
+  uint32_t m_aux_info_type = 0;
+  uint32_t m_aux_info_type_parameter = 0;
+  uint8_t  m_default_sample_info_size = 0;  // 0 -> variable length
+  uint32_t m_num_samples = 0; // needed in case we are using the default sample size
+
+  std::vector<uint8_t> m_sample_sizes;
+  MemoryHandle m_memory_handle;
+};
+
+
+class Box_saio : public FullBox {
+public:
+  Box_saio()
+  {
+    set_short_type(fourcc("saio"));
+  }
+
+  void set_aux_info_type(uint32_t aux_info_type, uint32_t aux_info_type_parameter = 0);
+
+  uint32_t get_aux_info_type() const { return m_aux_info_type; }
+
+  uint32_t get_aux_info_type_parameter() const { return m_aux_info_type_parameter; }
+
+  void add_chunk_offset(uint64_t offset);
+
+  // If this is 1, the SAI data of all samples is written contiguously in the file.
+  size_t get_num_chunks() const { return m_chunk_offset.size(); }
+
+  uint64_t get_chunk_offset(uint32_t idx) const;
+
+  std::string dump(Indent&) const override;
+
+  const char* debug_box_name() const override { return "Sample Auxiliary Information Offsets"; }
+
+  Error write(StreamWriter& writer) const override;
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+
+  void patch_file_pointers(StreamWriter& writer, size_t offset) override;
+
+private:
+  uint32_t m_aux_info_type = 0;
+  uint32_t m_aux_info_type_parameter = 0;
+
+  bool m_need_64bit = false;
+  mutable uint64_t m_offset_start_pos;
+
+  // If |chunk_offset|==1, the SAI data of all samples is stored contiguously in the file
+  std::vector<uint64_t> m_chunk_offset;
+
+  MemoryHandle m_memory_handle;
+};
+
+
+class Box_sdtp : public FullBox {
+public:
+  Box_sdtp()
+  {
+    set_short_type(fourcc("sdtp"));
+  }
+
+  std::string dump(Indent&) const override;
+
+  const char* debug_box_name() const override { return "Independent and Disposable Samples"; }
+
+  // Error write(StreamWriter& writer) const override;
+
+  uint8_t get_is_leading(uint32_t sampleIdx) const { return (m_sample_information[sampleIdx] >> 6) & 3; }
+
+  uint8_t get_depends_on(uint32_t sampleIdx) const { return (m_sample_information[sampleIdx] >> 4) & 3; }
+
+  uint8_t get_is_depended_on(uint32_t sampleIdx) const { return (m_sample_information[sampleIdx] >> 2) & 3; }
+
+  uint8_t get_has_redundancy(uint32_t sampleIdx) const { return (m_sample_information[sampleIdx]) & 3; }
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+
+private:
+  std::vector<uint8_t> m_sample_information;
+};
+
+
+class Box_tref : public Box
+{
+public:
+  Box_tref()
+  {
+    set_short_type(fourcc("tref"));
+  }
+
+  struct Reference {
+    uint32_t reference_type;
+    std::vector<uint32_t> to_track_id;
+  };
+
+  std::string dump(Indent&) const override;
+
+  const char* debug_box_name() const override { return "Track Reference"; }
+
+  std::vector<uint32_t> get_references(uint32_t ref_type) const;
+
+  size_t get_number_of_references_of_type(uint32_t ref_type) const;
+
+  size_t get_number_of_reference_types() const { return m_references.size(); }
+
+  std::vector<uint32_t> get_reference_types() const;
+
+  void add_references(uint32_t to_track_id, uint32_t type);
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+
+  Error write(StreamWriter& writer) const override;
+
+  Error check_for_double_references() const;
+
+private:
+  std::vector<Reference> m_references;
+};
+
+
+// Edit List container
+class Box_edts : public Box_container {
+public:
+  Box_edts() : Box_container("edts") {}
+
+  const char* debug_box_name() const override { return "Edit List Container"; }
+};
+
+
+class Box_elst : public FullBox
+{
+public:
+  Box_elst()
+  {
+    set_short_type(fourcc("elst"));
+  }
+
+  enum Flags {
+    Repeat_EditList = 0x01
+  };
+
+  std::string dump(Indent&) const override;
+
+  const char* debug_box_name() const override { return "Edit List"; }
+
+  void enable_repeat_mode(bool enable);
+
+  bool is_repeat_mode() const { return get_flags() & Flags::Repeat_EditList; }
+
+  struct Entry {
+    uint64_t segment_duration = 0;
+    int64_t media_time = 0;
+    int16_t media_rate_integer = 1;
+    int16_t media_rate_fraction = 0;
+  };
+
+  void add_entry(const Entry&);
+
+  size_t num_entries() const { return m_entries.size(); }
+
+  Entry get_entry(uint32_t entry) const { return m_entries[entry]; }
+
+protected:
+  Error parse(BitstreamRange& range, const heif_security_limits*) override;
+
+  Error write(StreamWriter& writer) const override;
+
+public:
+  void derive_box_version() override;
+
+private:
+  std::vector<Entry> m_entries;
+};
+
+#endif //SEQ_BOXES_H
diff --git a/libheif/sequences/track.cc b/libheif/sequences/track.cc
new file mode 100644
index 0000000000..40a98e64d4
--- /dev/null
+++ b/libheif/sequences/track.cc
@@ -0,0 +1,1151 @@
+/*
+ * HEIF image base codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <cstring>
+#include "track.h"
+#include "context.h"
+#include "sequences/seq_boxes.h"
+#include "sequences/chunk.h"
+#include "sequences/track_visual.h"
+#include "sequences/track_metadata.h"
+#include "api_structs.h"
+#include <limits>
+
+
+TrackOptions& TrackOptions::operator=(const TrackOptions& src)
+{
+  if (&src == this) {
+    return *this;
+  }
+
+  this->track_timescale = src.track_timescale;
+  this->write_sample_aux_infos_interleaved = src.write_sample_aux_infos_interleaved;
+  this->with_sample_tai_timestamps = src.with_sample_tai_timestamps;
+
+  if (src.tai_clock_info) {
+    this->tai_clock_info = heif_tai_clock_info_alloc();
+    heif_tai_clock_info_copy(this->tai_clock_info, src.tai_clock_info);
+  }
+  else {
+    this->tai_clock_info = nullptr;
+  }
+
+  this->with_sample_content_ids = src.with_sample_content_ids;
+  this->gimi_track_content_id = src.gimi_track_content_id;
+
+  return *this;
+}
+
+
+SampleAuxInfoHelper::SampleAuxInfoHelper(bool interleaved)
+  : m_interleaved(interleaved)
+{
+  m_saiz = std::make_shared<Box_saiz>();
+  m_saio = std::make_shared<Box_saio>();
+}
+
+
+void SampleAuxInfoHelper::set_aux_info_type(uint32_t aux_info_type, uint32_t aux_info_type_parameter)
+{
+  m_saiz->set_aux_info_type(aux_info_type, aux_info_type_parameter);
+  m_saio->set_aux_info_type(aux_info_type, aux_info_type_parameter);
+}
+
+Error SampleAuxInfoHelper::add_sample_info(const std::vector<uint8_t>& data)
+{
+  if (data.size() > 0xFF) {
+    return {
+      heif_error_Encoding_error,
+      heif_suberror_Unspecified,
+      "Encoded sample auxiliary information exceeds maximum size"
+    };
+  }
+
+  m_saiz->add_sample_size(static_cast<uint8_t>(data.size()));
+
+  m_data.insert(m_data.end(), data.begin(), data.end());
+
+  return Error::Ok;
+}
+
+void SampleAuxInfoHelper::add_nonpresent_sample()
+{
+  m_saiz->add_nonpresent_sample();
+}
+
+
+void SampleAuxInfoHelper::write_interleaved(const std::shared_ptr<HeifFile>& file)
+{
+  if (m_interleaved && !m_data.empty()) {
+    // TODO: I think this does not work because the image data does not know that there is SAI in-between
+    uint64_t pos = file->append_mdat_data(m_data);
+    m_saio->add_chunk_offset(pos);
+
+    m_data.clear();
+  }
+}
+
+void SampleAuxInfoHelper::write_all(const std::shared_ptr<Box>& parent, const std::shared_ptr<HeifFile>& file)
+{
+  parent->append_child_box(m_saiz);
+  parent->append_child_box(m_saio);
+
+  if (!m_data.empty()) {
+    uint64_t pos = file->append_mdat_data(m_data);
+    m_saio->add_chunk_offset(pos);
+  }
+}
+
+
+SampleAuxInfoReader::SampleAuxInfoReader(std::shared_ptr<Box_saiz> saiz,
+                                         std::shared_ptr<Box_saio> saio,
+                                         const std::vector<std::shared_ptr<Chunk>>& chunks)
+{
+  m_saiz = saiz;
+  m_saio = saio;
+
+  bool oneChunk = (saio->get_num_chunks() == 1);
+
+  uint32_t current_chunk = 0;
+  uint64_t offset = saio->get_chunk_offset(0);
+  uint32_t nSamples = saiz->get_num_samples();
+
+  m_contiguous_and_constant_size = (oneChunk && m_saiz->have_samples_constant_size());
+
+  if (m_contiguous_and_constant_size) {
+    m_singleChunk_offset = offset;
+  }
+  else {
+    m_sample_offsets.resize(nSamples);
+
+    for (uint32_t i = 0; i < nSamples; i++) {
+      if (!oneChunk && i > chunks[current_chunk]->last_sample_number()) {
+        current_chunk++;
+        assert(current_chunk < chunks.size());
+        offset = saio->get_chunk_offset(current_chunk);
+      }
+
+      m_sample_offsets[i] = offset;
+      offset += saiz->get_sample_size(i);
+    }
+  }
+}
+
+
+heif_sample_aux_info_type SampleAuxInfoReader::get_type() const
+{
+  heif_sample_aux_info_type type;
+  type.type = m_saiz->get_aux_info_type();
+  type.parameter = m_saiz->get_aux_info_type_parameter();
+  return type;
+}
+
+
+Result<std::vector<uint8_t> > SampleAuxInfoReader::get_sample_info(const HeifFile* file, uint32_t sample_idx)
+{
+  uint64_t offset;
+  uint8_t size;
+
+  if (m_contiguous_and_constant_size) {
+    size = m_saiz->get_sample_size(0);
+    offset = m_singleChunk_offset + sample_idx * size;
+  }
+  else {
+    size = m_saiz->get_sample_size(sample_idx);
+    if (size > 0) {
+      if (sample_idx >= m_sample_offsets.size()) {
+        return {};
+      }
+
+      offset = m_sample_offsets[sample_idx];
+    }
+  }
+
+  std::vector<uint8_t> data;
+
+  if (size > 0) {
+    Error err = file->append_data_from_file_range(data, offset, size);
+    if (err) {
+      return err;
+    }
+  }
+
+  return data;
+}
+
+
+std::shared_ptr<HeifFile> Track::get_file() const
+{
+  return m_heif_context->get_heif_file();
+}
+
+
+Track::Track(HeifContext* ctx)
+{
+  m_heif_context = ctx;
+}
+
+
+Error Track::load(const std::shared_ptr<Box_trak>& trak_box)
+{
+  m_trak = trak_box;
+
+  auto tkhd = trak_box->get_child_box<Box_tkhd>();
+  if (!tkhd) {
+    return {
+      heif_error_Invalid_input,
+      heif_suberror_Unspecified,
+      "Track has no 'tkhd' box."
+    };
+  }
+
+  m_tkhd = tkhd;
+
+  m_id = tkhd->get_track_id();
+
+  auto edts = trak_box->get_child_box<Box_edts>();
+  if (edts) {
+    m_elst = edts->get_child_box<Box_elst>();
+  }
+
+  auto mdia = trak_box->get_child_box<Box_mdia>();
+  if (!mdia) {
+    return {
+      heif_error_Invalid_input,
+      heif_suberror_Unspecified,
+      "Track has no 'mdia' box."
+    };
+  }
+
+  m_tref = trak_box->get_child_box<Box_tref>();
+
+  auto hdlr = mdia->get_child_box<Box_hdlr>();
+  if (!hdlr) {
+    return {
+      heif_error_Invalid_input,
+      heif_suberror_Unspecified,
+      "Track has no 'hdlr' box."
+    };
+  }
+
+  m_handler_type = hdlr->get_handler_type();
+
+  m_minf = mdia->get_child_box<Box_minf>();
+  if (!m_minf) {
+    return {
+      heif_error_Invalid_input,
+      heif_suberror_Unspecified,
+      "Track has no 'minf' box."
+    };
+  }
+
+  m_mdhd = mdia->get_child_box<Box_mdhd>();
+  if (!m_mdhd) {
+    return {
+      heif_error_Invalid_input,
+      heif_suberror_Unspecified,
+      "Track has no 'mdhd' box."
+    };
+  }
+
+  auto stbl = m_minf->get_child_box<Box_stbl>();
+  if (!stbl) {
+    return {
+      heif_error_Invalid_input,
+      heif_suberror_Unspecified,
+      "Track has no 'stbl' box."
+    };
+  }
+
+  m_stsd = stbl->get_child_box<Box_stsd>();
+  if (!m_stsd) {
+    return {
+      heif_error_Invalid_input,
+      heif_suberror_Unspecified,
+      "Track has no 'stsd' box."
+    };
+  }
+
+  m_stsc = stbl->get_child_box<Box_stsc>();
+  if (!m_stsc) {
+    return {
+      heif_error_Invalid_input,
+      heif_suberror_Unspecified,
+      "Track has no 'stsc' box."
+    };
+  }
+
+  m_stco = stbl->get_child_box<Box_stco>();
+  if (!m_stco) {
+    return {
+      heif_error_Invalid_input,
+      heif_suberror_Unspecified,
+      "Track has no 'stco' box."
+    };
+  }
+
+  m_stsz = stbl->get_child_box<Box_stsz>();
+  if (!m_stsz) {
+    return {
+      heif_error_Invalid_input,
+      heif_suberror_Unspecified,
+      "Track has no 'stsz' box."
+    };
+  }
+
+  m_stts = stbl->get_child_box<Box_stts>();
+  if (!m_stts) {
+    return {
+      heif_error_Invalid_input,
+      heif_suberror_Unspecified,
+      "Track has no 'stts' box."
+    };
+  }
+
+  // --- check that number of samples in various boxes are consistent
+
+  if (m_stts->get_number_of_samples() != m_stsz->num_samples()) {
+    return {
+      heif_error_Invalid_input,
+      heif_suberror_Unspecified,
+      "Number of samples in 'stts' and 'stsz' is inconsistent."
+    };
+  }
+
+  if (m_ctts && m_ctts->get_number_of_samples() != m_stsz->num_samples()) {
+    return {
+      heif_error_Invalid_input,
+      heif_suberror_Unspecified,
+      "Number of samples in 'ctts' and 'stsz' is inconsistent."
+    };
+  }
+
+  const std::vector<uint32_t>& chunk_offsets = m_stco->get_offsets();
+  assert(chunk_offsets.size() <= (size_t) std::numeric_limits<uint32_t>::max()); // There cannot be more than uint32_t chunks.
+
+  uint32_t current_sample_idx = 0;
+  int32_t previous_sample_description_index = -1;
+
+  for (size_t chunk_idx = 0; chunk_idx < chunk_offsets.size(); chunk_idx++) {
+    auto* s2c = m_stsc->get_chunk(static_cast<uint32_t>(chunk_idx + 1));
+    if (!s2c) {
+      return {
+        heif_error_Invalid_input,
+        heif_suberror_Unspecified,
+        "'stco' box references a non-existing chunk."
+      };
+    }
+
+    Box_stsc::SampleToChunk sampleToChunk = *s2c;
+
+    auto sample_description = m_stsd->get_sample_entry(sampleToChunk.sample_description_index - 1);
+    if (!sample_description) {
+      return {
+        heif_error_Invalid_input,
+        heif_suberror_Unspecified,
+        "Track references a non-existing sample description."
+      };
+    }
+
+    if (auto auxi = sample_description->get_child_box<Box_auxi>()) {
+      m_auxiliary_info_type = auxi->get_aux_track_type_urn();
+    }
+
+    if (m_first_taic == nullptr) {
+      auto taic = sample_description->get_child_box<Box_taic>();
+      if (taic) {
+        m_first_taic = taic;
+      }
+    }
+
+    if (current_sample_idx + sampleToChunk.samples_per_chunk > m_stsz->num_samples()) {
+      return {
+        heif_error_Invalid_input,
+        heif_suberror_Unspecified,
+        "Number of samples in 'stsc' box exceeds sample sizes in 'stsz' box."
+      };
+    }
+
+    auto chunk = std::make_shared<Chunk>(m_heif_context, m_id,
+                                         current_sample_idx, sampleToChunk.samples_per_chunk,
+                                         m_stco->get_offsets()[chunk_idx],
+                                         m_stsz);
+
+    if (auto visualSampleDescription = std::dynamic_pointer_cast<const Box_VisualSampleEntry>(sample_description)) {
+      if (chunk_idx > 0 && (int32_t) sampleToChunk.sample_description_index == previous_sample_description_index) {
+        // reuse decoder from previous chunk if it uses the sample sample_description_index
+        chunk->set_decoder(m_chunks[chunk_idx - 1]->get_decoder());
+      }
+      else {
+        // use a new decoder
+        chunk->set_decoder(Decoder::alloc_for_sequence_sample_description_box(visualSampleDescription));
+      }
+    }
+
+    m_chunks.push_back(chunk);
+
+    current_sample_idx += sampleToChunk.samples_per_chunk;
+    previous_sample_description_index = sampleToChunk.sample_description_index;
+  }
+
+  // --- read sample auxiliary information boxes
+
+  std::vector<std::shared_ptr<Box_saiz> > saiz_boxes = stbl->get_child_boxes<Box_saiz>();
+  std::vector<std::shared_ptr<Box_saio> > saio_boxes = stbl->get_child_boxes<Box_saio>();
+
+  if (saio_boxes.size() != saiz_boxes.size()) {
+    return Error{
+      heif_error_Invalid_input,
+      heif_suberror_Unspecified,
+      "Boxes 'saiz' and `saio` must come in pairs."
+    };
+  }
+
+  for (const auto& saiz : saiz_boxes) {
+    uint32_t aux_info_type = saiz->get_aux_info_type();
+    uint32_t aux_info_type_parameter = saiz->get_aux_info_type_parameter();
+
+    // find the corresponding saio box
+
+    std::shared_ptr<Box_saio> saio;
+    for (const auto& candidate : saio_boxes) {
+      if (candidate->get_aux_info_type() == aux_info_type &&
+          candidate->get_aux_info_type_parameter() == aux_info_type_parameter) {
+        saio = candidate;
+        break;
+      }
+    }
+
+    if (saio) {
+      if (saio->get_num_chunks() != 1 &&
+          saio->get_num_chunks() != m_stco->get_number_of_chunks()) {
+        return Error{
+          heif_error_Invalid_input,
+          heif_suberror_Unspecified,
+          "Invalid number of chunks in 'saio' box."
+        };
+      }
+
+      if (aux_info_type == fourcc("suid")) {
+        m_aux_reader_content_ids = std::make_unique<SampleAuxInfoReader>(saiz, saio, m_chunks);
+      }
+
+      if (aux_info_type == fourcc("stai")) {
+        m_aux_reader_tai_timestamps = std::make_unique<SampleAuxInfoReader>(saiz, saio, m_chunks);
+      }
+    }
+    else {
+      return Error{
+        heif_error_Invalid_input,
+        heif_suberror_Unspecified,
+        "'saiz' box without matching 'saio' box."
+      };
+    }
+  }
+
+  // --- read track properties
+
+  if (auto meta = trak_box->get_child_box<Box_meta>()) {
+    auto iloc = meta->get_child_box<Box_iloc>();
+    auto idat = meta->get_child_box<Box_idat>();
+
+    auto iinf = meta->get_child_box<Box_iinf>();
+    if (iinf) {
+      auto infe_boxes = iinf->get_child_boxes<Box_infe>();
+      for (const auto& box : infe_boxes) {
+        if (box->get_item_type_4cc() == fourcc("uri ") &&
+            box->get_item_uri_type() == "urn:uuid:15beb8e4-944d-5fc6-a3dd-cb5a7e655c73") {
+          heif_item_id id = box->get_item_ID();
+
+          std::vector<uint8_t> data;
+          Error err = iloc->read_data(id, m_heif_context->get_heif_file()->get_reader(), idat, &data, m_heif_context->get_security_limits());
+          if (err) {
+            // TODO
+          }
+
+          Result contentIdResult = vector_to_string(data);
+          if (!contentIdResult) {
+            // TODO
+          }
+
+          m_track_info.gimi_track_content_id = *contentIdResult;
+        }
+      }
+    }
+  }
+
+
+  // --- security checks
+
+  if (m_heif_context->get_security_limits()->max_sequence_frames > 0 &&
+      m_stsz->num_samples() > m_heif_context->get_security_limits()->max_sequence_frames) {
+    return {
+      heif_error_Memory_allocation_error,
+      heif_suberror_Security_limit_exceeded,
+      "Security limit for maximum number of sequence frames exceeded"
+    };
+  }
+
+
+  // --- initialize track tables
+
+  Error err = init_sample_timing_table();
+  if (err) {
+    return err;
+  }
+
+  return {};
+}
+
+
+Track::Track(HeifContext* ctx, uint32_t track_id, const TrackOptions* options, uint32_t handler_type)
+{
+  m_heif_context = ctx;
+
+  m_moov = ctx->get_heif_file()->get_moov_box();
+  assert(m_moov);
+
+  // --- find next free track ID
+
+  if (track_id == 0) {
+    auto idResult = ctx->get_id_creator().get_new_id(IDCreator::Namespace::track);
+    // Track constructor cannot return errors; assert on overflow (extremely unlikely).
+    assert(idResult);
+    track_id = *idResult;
+
+    auto mvhd = m_moov->get_child_box<Box_mvhd>();
+    mvhd->set_next_track_id(track_id + 1);
+
+    m_id = track_id;
+  }
+
+  m_trak = std::make_shared<Box_trak>();
+  m_moov->append_child_box(m_trak);
+
+  m_tkhd = std::make_shared<Box_tkhd>();
+  m_trak->append_child_box(m_tkhd);
+  m_tkhd->set_track_id(track_id);
+
+  auto mdia = std::make_shared<Box_mdia>();
+  m_trak->append_child_box(mdia);
+
+  m_mdhd = std::make_shared<Box_mdhd>();
+  m_mdhd->set_timescale(options ? options->track_timescale : 90000);
+  mdia->append_child_box(m_mdhd);
+
+  m_hdlr = std::make_shared<Box_hdlr>();
+  mdia->append_child_box(m_hdlr);
+  m_hdlr->set_handler_type(handler_type);
+
+  m_minf = std::make_shared<Box_minf>();
+  mdia->append_child_box(m_minf);
+
+  // add (unused) 'dinf'
+
+  auto dinf = std::make_shared<Box_dinf>();
+  auto dref = std::make_shared<Box_dref>();
+  auto url = std::make_shared<Box_url>();
+  m_minf->append_child_box(dinf);
+  dinf->append_child_box(dref);
+  dref->append_child_box(url);
+
+  // vmhd is added in Track_Visual
+
+  m_stbl = std::make_shared<Box_stbl>();
+  m_minf->append_child_box(m_stbl);
+
+  m_stsd = std::make_shared<Box_stsd>();
+  m_stbl->append_child_box(m_stsd);
+
+  m_stts = std::make_shared<Box_stts>();
+  m_stbl->append_child_box(m_stts);
+
+  m_ctts = std::make_shared<Box_ctts>();
+  // The ctts box will be added in finalize_track(), but only there is frame-reordering.
+
+  m_stsc = std::make_shared<Box_stsc>();
+  m_stbl->append_child_box(m_stsc);
+
+  m_stsz = std::make_shared<Box_stsz>();
+  m_stbl->append_child_box(m_stsz);
+
+  m_stco = std::make_shared<Box_stco>();
+  m_stbl->append_child_box(m_stco);
+
+  m_stss = std::make_shared<Box_stss>();
+  m_stbl->append_child_box(m_stss);
+
+  if (options) {
+    m_track_info = *options;
+
+    if (m_track_info.with_sample_tai_timestamps != heif_sample_aux_info_presence_none) {
+      m_aux_helper_tai_timestamps = std::make_unique<SampleAuxInfoHelper>(m_track_info.write_sample_aux_infos_interleaved);
+      m_aux_helper_tai_timestamps->set_aux_info_type(fourcc("stai"));
+    }
+
+    if (m_track_info.with_sample_content_ids != heif_sample_aux_info_presence_none) {
+      m_aux_helper_content_ids = std::make_unique<SampleAuxInfoHelper>(m_track_info.write_sample_aux_infos_interleaved);
+      m_aux_helper_content_ids->set_aux_info_type(fourcc("suid"));
+    }
+
+    if (!options->gimi_track_content_id.empty()) {
+      auto hdlr_box = std::make_shared<Box_hdlr>();
+      hdlr_box->set_handler_type(fourcc("meta"));
+
+      auto uuid_box = std::make_shared<Box_infe>();
+      uuid_box->set_item_type_4cc(fourcc("uri "));
+      uuid_box->set_item_uri_type("urn:uuid:15beb8e4-944d-5fc6-a3dd-cb5a7e655c73");
+      uuid_box->set_item_ID(1);
+
+      auto iinf_box = std::make_shared<Box_iinf>();
+      iinf_box->append_child_box(uuid_box);
+
+      std::vector<uint8_t> track_uuid_vector;
+      track_uuid_vector.insert(track_uuid_vector.begin(),
+                               options->gimi_track_content_id.c_str(),
+                               options->gimi_track_content_id.c_str() + options->gimi_track_content_id.length() + 1);
+
+      auto iloc_box = std::make_shared<Box_iloc>();
+      iloc_box->append_data(1, track_uuid_vector, 1);
+
+      auto meta_box = std::make_shared<Box_meta>();
+      meta_box->append_child_box(hdlr_box);
+      meta_box->append_child_box(iinf_box);
+      meta_box->append_child_box(iloc_box);
+
+      m_trak->append_child_box(meta_box);
+    }
+  }
+}
+
+
+Result<std::shared_ptr<Track> > Track::alloc_track(HeifContext* ctx, const std::shared_ptr<Box_trak>& trak)
+{
+  auto mdia = trak->get_child_box<Box_mdia>();
+  if (!mdia) {
+    return Error{
+      heif_error_Invalid_input,
+      heif_suberror_Unspecified,
+      "Track has no 'mdia' box."
+    };
+  }
+
+  auto hdlr = mdia->get_child_box<Box_hdlr>();
+  if (!hdlr) {
+    return Error{
+      heif_error_Invalid_input,
+      heif_suberror_Unspecified,
+      "Track has no 'hdlr' box."
+    };
+  }
+
+  std::shared_ptr<Track> track;
+
+  switch (hdlr->get_handler_type()) {
+    case fourcc("pict"):
+    case fourcc("vide"):
+    case fourcc("auxv"):
+      track = std::make_shared<Track_Visual>(ctx);
+      break;
+    case fourcc("meta"):
+      track = std::make_shared<Track_Metadata>(ctx);
+      break;
+    default: {
+      std::stringstream sstr;
+      sstr << "Track with unsupported handler type '" << fourcc_to_string(hdlr->get_handler_type()) << "'.";
+      return Error{
+        heif_error_Unsupported_feature,
+        heif_suberror_Unsupported_track_type,
+        sstr.str()
+      };
+    }
+  }
+
+  assert(track);
+  Error loadError = track->load(trak);
+  if (loadError) {
+    return loadError;
+  }
+
+  return {track};
+}
+
+
+bool Track::is_visual_track() const
+{
+  return (m_handler_type == fourcc("pict") ||
+          m_handler_type == fourcc("vide"));
+}
+
+
+static const char* cAuxType_alpha_miaf = "urn:mpeg:mpegB:cicp:systems:auxiliary:alpha";
+static const char* cAuxType_alpha_hevc = "urn:mpeg:hevc:2015:auxid:1";
+static const char* cAuxType_alpha_avc = "urn:mpeg:avc:2015:auxid:1";
+
+heif_auxiliary_track_info_type Track::get_auxiliary_info_type() const
+{
+  if (m_auxiliary_info_type == cAuxType_alpha_miaf ||
+      m_auxiliary_info_type == cAuxType_alpha_hevc ||
+      m_auxiliary_info_type == cAuxType_alpha_avc) {
+    return heif_auxiliary_track_info_type_alpha;
+  }
+  else {
+    return heif_auxiliary_track_info_type_unknown;
+  }
+}
+
+const char* get_track_auxiliary_info_type(heif_compression_format format)
+{
+  switch (format) {
+    case heif_compression_HEVC:
+      return cAuxType_alpha_hevc;
+    case heif_compression_AVC:
+      return cAuxType_alpha_avc;
+    case heif_compression_AV1:
+      return cAuxType_alpha_miaf;
+    default:
+      return cAuxType_alpha_miaf; // TODO: is this correct for all remaining compression types ?
+  }
+}
+
+// TODO: is this correct or should we set the aux_info_type depending on the compression format?
+void Track::set_auxiliary_info_type(heif_auxiliary_track_info_type type)
+{
+  switch (type) {
+    case heif_auxiliary_track_info_type_alpha:
+      m_auxiliary_info_type = cAuxType_alpha_miaf;
+      break;
+    default:
+      m_auxiliary_info_type.clear();
+      break;
+  }
+}
+
+
+uint32_t Track::get_first_cluster_sample_entry_type() const
+{
+  if (m_stsd->get_num_sample_entries() == 0) {
+    return 0; // TODO: error ? Or can we assume at this point that there is at least one sample entry?
+  }
+
+  return m_stsd->get_sample_entry(0)->get_short_type();
+}
+
+
+Result<std::string> Track::get_first_cluster_urim_uri() const
+{
+  if (m_stsd->get_num_sample_entries() == 0) {
+    return Error{
+      heif_error_Invalid_input,
+      heif_suberror_Unspecified,
+      "This track has no sample entries."
+    };
+  }
+
+  std::shared_ptr<const Box> sampleEntry = m_stsd->get_sample_entry(0);
+  auto urim = std::dynamic_pointer_cast<const Box_URIMetaSampleEntry>(sampleEntry);
+  if (!urim) {
+    return Error{
+      heif_error_Usage_error,
+      heif_suberror_Unspecified,
+      "This cluster is no 'urim' sample entry."
+    };
+  }
+
+  std::shared_ptr<const Box_uri> uri = urim->get_child_box<const Box_uri>();
+  if (!uri) {
+    return Error{
+      heif_error_Invalid_input,
+      heif_suberror_Unspecified,
+      "The 'urim' box has no 'uri' child box."
+    };
+  }
+
+  return uri->get_uri();
+}
+
+
+bool Track::end_of_sequence_reached() const
+{
+  //return (m_next_sample_to_be_processed > m_chunks.back()->last_sample_number());
+  return m_next_sample_to_be_output >= m_num_output_samples;
+}
+
+
+Error Track::finalize_track()
+{
+  // --- write active chunk data
+
+  size_t data_start = m_heif_context->get_heif_file()->append_mdat_data(m_chunk_data);
+  m_chunk_data.clear();
+
+  // first sample in chunk? -> write chunk offset
+
+  if (true) {
+    // m_stsc->last_chunk_empty()) {
+    // TODO: we will have to call this at the end of a chunk to dump the current SAI queue
+
+    // if auxiliary data is interleaved, write it between the chunks
+    if (m_aux_helper_tai_timestamps) m_aux_helper_tai_timestamps->write_interleaved(get_file());
+    if (m_aux_helper_content_ids) m_aux_helper_content_ids->write_interleaved(get_file());
+
+    // TODO
+    assert(data_start < 0xFF000000); // add some headroom for header data
+    m_stco->add_chunk_offset(static_cast<uint32_t>(data_start));
+  }
+
+
+  // --- write rest of data
+
+  if (m_aux_helper_tai_timestamps) m_aux_helper_tai_timestamps->write_all(m_stbl, get_file());
+  if (m_aux_helper_content_ids) m_aux_helper_content_ids->write_all(m_stbl, get_file());
+
+  uint64_t duration = m_stts->get_total_duration(true);
+  m_mdhd->set_duration(duration);
+
+  m_stss->set_total_number_of_samples(m_stsz->num_samples());
+
+  // only add ctts box if we use frame-reordering
+  if (!m_ctts->is_constant_offset()) {
+    m_stbl->append_child_box(m_ctts);
+  }
+
+  return {};
+}
+
+
+uint64_t Track::get_duration_in_media_units() const
+{
+  return m_mdhd->get_duration();
+}
+
+
+uint32_t Track::get_timescale() const
+{
+  return m_mdhd->get_timescale();
+}
+
+
+void Track::set_track_duration_in_movie_units(uint64_t total_duration, uint64_t segment_duration)
+{
+  m_tkhd->set_duration(total_duration);
+
+  if (m_elst) {
+    Box_elst::Entry entry;
+    entry.segment_duration = segment_duration;
+
+    m_elst->add_entry(entry);
+  }
+}
+
+
+void Track::enable_edit_list_repeat_mode(bool enable)
+{
+  if (!m_elst) {
+    if (!enable) {
+      return;
+    }
+
+    auto edts = std::make_shared<Box_edts>();
+    m_trak->append_child_box(edts);
+
+    m_elst = std::make_shared<Box_elst>();
+    edts->append_child_box(m_elst);
+
+    m_elst->enable_repeat_mode(enable);
+  }
+}
+
+
+void Track::add_chunk(heif_compression_format format)
+{
+  auto chunk = std::make_shared<Chunk>(m_heif_context, m_id, format);
+  m_chunks.push_back(chunk);
+
+  int chunkIdx = (uint32_t) m_chunks.size();
+  m_stsc->add_chunk(chunkIdx);
+}
+
+void Track::set_sample_description_box(std::shared_ptr<Box> sample_description_box)
+{
+  // --- add 'taic' when we store timestamps as sample auxiliary information
+
+  if (m_track_info.with_sample_tai_timestamps != heif_sample_aux_info_presence_none) {
+    auto taic = std::make_shared<Box_taic>();
+    taic->set_from_tai_clock_info(m_track_info.tai_clock_info);
+    sample_description_box->append_child_box(taic);
+  }
+
+  m_stsd->add_sample_entry(sample_description_box);
+}
+
+
+Error Track::write_sample_data(const std::vector<uint8_t>& raw_data, uint32_t sample_duration,
+                               int32_t composition_time_offset,
+                               bool is_sync_sample,
+                               const heif_tai_timestamp_packet* tai, const std::optional<std::string>& gimi_contentID)
+{
+  m_chunk_data.insert(m_chunk_data.end(), raw_data.begin(), raw_data.end());
+
+  m_stsc->increase_samples_in_chunk(1);
+
+  m_stsz->append_sample_size((uint32_t) raw_data.size());
+
+  if (is_sync_sample) {
+    m_stss->add_sync_sample(m_next_sample_to_be_output + 1);
+  }
+
+  if (sample_duration == 0) {
+    return {
+      heif_error_Usage_error,
+      heif_suberror_Unspecified,
+      "Sample duration may not be 0"
+    };
+  }
+
+  m_stts->append_sample_duration(sample_duration);
+  m_ctts->append_sample_offset(composition_time_offset);
+
+
+  // --- sample timestamp
+
+  if (m_track_info.with_sample_tai_timestamps != heif_sample_aux_info_presence_none) {
+    if (tai) {
+      std::vector<uint8_t> tai_data = Box_itai::encode_tai_to_bitstream(tai);
+      auto err = m_aux_helper_tai_timestamps->add_sample_info(tai_data);
+      if (err) {
+        return err;
+      }
+    }
+    else if (m_track_info.with_sample_tai_timestamps == heif_sample_aux_info_presence_optional) {
+      m_aux_helper_tai_timestamps->add_nonpresent_sample();
+    }
+    else {
+      return {
+        heif_error_Encoding_error,
+        heif_suberror_Unspecified,
+        "Mandatory TAI timestamp missing"
+      };
+    }
+  }
+
+  // --- sample content id
+
+  if (m_track_info.with_sample_content_ids != heif_sample_aux_info_presence_none) {
+    if (gimi_contentID) {
+      auto id = *gimi_contentID;
+      const char* id_str = id.c_str();
+      std::vector<uint8_t> id_vector;
+      id_vector.insert(id_vector.begin(), id_str, id_str + id.length() + 1);
+      auto err = m_aux_helper_content_ids->add_sample_info(id_vector);
+      if (err) {
+        return err;
+      }
+    }
+    else if (m_track_info.with_sample_content_ids == heif_sample_aux_info_presence_optional) {
+      m_aux_helper_content_ids->add_nonpresent_sample();
+    }
+    else {
+      return {
+        heif_error_Encoding_error,
+        heif_suberror_Unspecified,
+        "Mandatory ContentID missing"
+      };
+    }
+  }
+
+  m_next_sample_to_be_output++;
+
+  return Error::Ok;
+}
+
+
+void Track::add_reference_to_track(uint32_t referenceType, uint32_t to_track_id)
+{
+  if (!m_tref) {
+    m_tref = std::make_shared<Box_tref>();
+    m_trak->append_child_box(m_tref);
+  }
+
+  m_tref->add_references(to_track_id, referenceType);
+}
+
+
+Error Track::init_sample_timing_table()
+{
+  m_num_samples = m_stsz->num_samples();
+
+  // --- build media timeline
+
+  std::vector<SampleTiming> media_timeline;
+
+  uint64_t current_decoding_time = 0;
+  uint32_t current_chunk = 0;
+  uint32_t current_sample_in_chunk_idx = 0;
+
+  for (uint32_t i = 0; i < m_num_samples; i++) {
+    SampleTiming timing;
+    timing.sampleIdx = i;
+    timing.sampleInChunkIdx = current_sample_in_chunk_idx;
+    timing.media_decoding_time = current_decoding_time;
+    timing.sample_duration_media_time = m_stts->get_sample_duration(i);
+    current_decoding_time += timing.sample_duration_media_time;
+    current_sample_in_chunk_idx++;
+
+    while (current_chunk < m_chunks.size() &&
+           i > m_chunks[current_chunk]->last_sample_number()) {
+      current_chunk++;
+      current_sample_in_chunk_idx=0;
+
+      if (current_chunk > m_chunks.size()) {
+        timing.chunkIdx = 0; // TODO: error
+      }
+    }
+
+    timing.chunkIdx = current_chunk;
+
+    media_timeline.push_back(timing);
+  }
+
+  // --- build presentation timeline from editlist
+
+  bool fallback = false;
+
+  if (m_heif_context->get_sequence_timescale() != get_timescale()) {
+    fallback = true;
+  }
+  else if (m_elst &&
+           m_elst->num_entries() == 1 &&
+           m_elst->get_entry(0).media_time == 0 &&
+           m_elst->get_entry(0).segment_duration == m_mdhd->get_duration() &&
+           m_elst->is_repeat_mode()) {
+    m_presentation_timeline = media_timeline;
+
+    uint64_t duration_media_units = get_duration_in_media_units();
+    if (duration_media_units == 0) {
+      return {
+        heif_error_Invalid_input,
+        heif_suberror_Unspecified,
+        "Track duration is zero."
+      };
+    }
+
+    m_num_output_samples = m_heif_context->get_sequence_duration() / get_duration_in_media_units() * media_timeline.size();
+  }
+  else {
+    fallback = true;
+  }
+
+  // Fallback: just play the media timeline
+  if (fallback) {
+    m_presentation_timeline = media_timeline;
+    m_num_output_samples = media_timeline.size();
+  }
+
+  return {};
+}
+
+
+Result<heif_raw_sequence_sample*> Track::get_next_sample_raw_data(const heif_decoding_options* options)
+{
+  uint64_t num_output_samples = m_num_output_samples;
+  if (options && options->ignore_sequence_editlist) {
+    num_output_samples = m_num_samples;
+  }
+
+  if (m_next_sample_to_be_output >= num_output_samples) {
+    return Error{
+      heif_error_End_of_sequence,
+      heif_suberror_Unspecified,
+      "End of sequence"
+    };
+  }
+
+  const auto& sampleTiming = m_presentation_timeline[m_next_sample_to_be_output % m_presentation_timeline.size()];
+  uint32_t sample_idx = sampleTiming.sampleIdx;
+  uint32_t chunk_idx = sampleTiming.chunkIdx;
+
+  const std::shared_ptr<Chunk>& chunk = m_chunks[chunk_idx];
+
+  DataExtent extent = chunk->get_data_extent_for_sample(sample_idx);
+  auto readResult = extent.read_data();
+  if (!readResult) {
+    return readResult.error();
+  }
+
+  heif_raw_sequence_sample* sample = new heif_raw_sequence_sample();
+  sample->data = **readResult;
+
+  // read sample duration
+
+  if (m_stts) {
+    sample->duration = m_stts->get_sample_duration(sample_idx);
+  }
+
+  // --- read sample auxiliary data
+
+  if (m_aux_reader_content_ids) {
+    auto readResult = m_aux_reader_content_ids->get_sample_info(get_file().get(), sample_idx);
+    if (!readResult) {
+      return readResult.error();
+    }
+
+    if (!readResult->empty()) {
+      Result<std::string> convResult = vector_to_string(*readResult);
+      if (!convResult) {
+        return convResult.error();
+      }
+
+      sample->gimi_sample_content_id = *convResult;
+    }
+  }
+
+  if (m_aux_reader_tai_timestamps) {
+    auto readResult = m_aux_reader_tai_timestamps->get_sample_info(get_file().get(), sample_idx);
+    if (!readResult) {
+      return readResult.error();
+    }
+
+    if (!readResult->empty()) {
+      auto resultTai = Box_itai::decode_tai_from_vector(*readResult);
+      if (!resultTai) {
+        return resultTai.error();
+      }
+
+      sample->timestamp = heif_tai_timestamp_packet_alloc();
+      heif_tai_timestamp_packet_copy(sample->timestamp, &*resultTai);
+    }
+  }
+
+  m_next_sample_to_be_output++;
+
+  return sample;
+}
+
+
+std::vector<heif_sample_aux_info_type> Track::get_sample_aux_info_types() const
+{
+  std::vector<heif_sample_aux_info_type> types;
+
+  if (m_aux_reader_tai_timestamps) types.emplace_back(m_aux_reader_tai_timestamps->get_type());
+  if (m_aux_reader_content_ids) types.emplace_back(m_aux_reader_content_ids->get_type());
+
+  return types;
+}
diff --git a/libheif/sequences/track.h b/libheif/sequences/track.h
new file mode 100644
index 0000000000..31fd3f5a49
--- /dev/null
+++ b/libheif/sequences/track.h
@@ -0,0 +1,289 @@
+/*
+ * HEIF image base codec.
+ * Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_TRACK_H
+#define LIBHEIF_TRACK_H
+
+#include "error.h"
+#include "api_structs.h"
+#include "libheif/heif_plugin.h"
+#include "libheif/heif_sequences.h"
+#include <string>
+#include <memory>
+#include <vector>
+
+class HeifContext;
+
+class HeifPixelImage;
+
+class Chunk;
+
+class Box_trak;
+
+
+class SampleAuxInfoHelper
+{
+public:
+  SampleAuxInfoHelper(bool interleaved = false);
+
+  void set_aux_info_type(uint32_t aux_info_type, uint32_t aux_info_type_parameter = 0);
+
+  Error add_sample_info(const std::vector<uint8_t>& data);
+
+  void add_nonpresent_sample();
+
+  void write_interleaved(const std::shared_ptr<HeifFile>& file);
+
+  void write_all(const std::shared_ptr<Box>& parent, const std::shared_ptr<HeifFile>& file);
+
+private:
+  std::shared_ptr<Box_saiz> m_saiz;
+  std::shared_ptr<Box_saio> m_saio;
+
+  std::vector<uint8_t> m_data;
+
+  bool m_interleaved;
+};
+
+
+class SampleAuxInfoReader
+{
+public:
+  SampleAuxInfoReader(std::shared_ptr<Box_saiz>,
+                      std::shared_ptr<Box_saio>,
+                      const std::vector<std::shared_ptr<Chunk>>& chunks);
+
+  heif_sample_aux_info_type get_type() const;
+
+  Result<std::vector<uint8_t>> get_sample_info(const HeifFile* file, uint32_t sample_idx);
+
+private:
+  std::shared_ptr<Box_saiz> m_saiz;
+  std::shared_ptr<Box_saio> m_saio;
+
+  // If there is only one chunk and the SAI data sizes are constant, we do not need an offset table.
+  // We just store the base offset and can directly calculate the sample offset from that.
+  bool m_contiguous_and_constant_size=false;
+  uint64_t m_singleChunk_offset=0;
+
+  // For chunked data or non-constant sample sizes, we use a table with the offsets for all SAI samples.
+  std::vector<uint64_t> m_sample_offsets;
+};
+
+
+/**
+ * This structure specifies what will be written in a track and how it will be laid out in the file.
+ */
+struct TrackOptions
+{
+  ~TrackOptions()
+  {
+    heif_tai_clock_info_release(tai_clock_info);
+  }
+
+  // Timescale (clock ticks per second) for this track.
+  uint32_t track_timescale = 90000;
+
+  // If 'true', the aux_info data blocks will be interleaved with the compressed image.
+  // This has the advantage that the aux_info is localized near the image data.
+  //
+  // If 'false', all aux_info will be written as one block after the compressed image data.
+  // This has the advantage that no aux_info offsets have to be written.
+  bool write_sample_aux_infos_interleaved = false;
+
+
+  // --- TAI timestamps for samples
+  heif_sample_aux_info_presence with_sample_tai_timestamps = heif_sample_aux_info_presence_none;
+  heif_tai_clock_info* tai_clock_info = nullptr;
+
+  // --- GIMI content IDs for samples
+
+  heif_sample_aux_info_presence with_sample_content_ids = heif_sample_aux_info_presence_none;
+
+  // --- GIMI content ID for the track
+
+  std::string gimi_track_content_id;
+
+  TrackOptions& operator=(const TrackOptions&);
+};
+
+
+const char* get_track_auxiliary_info_type(heif_compression_format format);
+
+
+class Track : public ErrorBuffer {
+public:
+  //Track(HeifContext* ctx);
+
+  Track(HeifContext* ctx, uint32_t track_id, const TrackOptions* info, uint32_t handler_type);
+
+  Track(HeifContext* ctx);
+
+  virtual ~Track() = default;
+
+  // Allocate a Track of the correct sub-class (visual or metadata).
+  // For tracks with an unsupported handler type, heif_error_Unsupported_feature/heif_suberror_Unsupported_track_type is returned.
+  static Result<std::shared_ptr<Track>> alloc_track(HeifContext*, const std::shared_ptr<Box_trak>&);
+
+  // load track from file
+  virtual Error load(const std::shared_ptr<Box_trak>&);
+
+  // This is called after creating all Track objects when reading a HEIF file.
+  // We can now do initializations that require access to all tracks.
+  [[nodiscard]] virtual Error initialize_after_parsing(HeifContext*, const std::vector<std::shared_ptr<Track>>& all_tracks) { return {}; }
+
+  heif_item_id get_id() const { return m_id; }
+
+  std::shared_ptr<HeifFile> get_file() const;
+
+  uint32_t get_handler() const { return m_handler_type; }
+
+  heif_auxiliary_track_info_type get_auxiliary_info_type() const;
+
+  std::string get_auxiliary_info_type_urn() const { return m_auxiliary_info_type; }
+
+  void set_auxiliary_info_type(heif_auxiliary_track_info_type);
+
+  void set_auxiliary_info_type_urn(std::string t) { m_auxiliary_info_type = t; }
+
+  bool is_visual_track() const;
+
+  virtual bool has_alpha_channel() const { return false; }
+
+  uint32_t get_first_cluster_sample_entry_type() const;
+
+  Result<std::string> get_first_cluster_urim_uri() const;
+
+  uint64_t get_duration_in_media_units() const;
+
+  uint32_t get_timescale() const;
+
+  // The context will compute the duration in global movie units and set this.
+  void set_track_duration_in_movie_units(uint64_t total_duration, uint64_t segment_duration);
+
+  void enable_edit_list_repeat_mode(bool enable);
+
+  std::shared_ptr<Box_taic> get_first_cluster_taic() { return m_first_taic; }
+
+  bool end_of_sequence_reached() const;
+
+  // Compute some parameters after all frames have been encoded (for example: track duration).
+  virtual Error finalize_track();
+
+  const TrackOptions& get_track_info() const { return m_track_info; }
+
+  void add_reference_to_track(uint32_t referenceType, uint32_t to_track_id);
+
+  std::shared_ptr<const Box_tref> get_tref_box() const { return m_tref; }
+
+  Result<heif_raw_sequence_sample*> get_next_sample_raw_data(const heif_decoding_options* options);
+
+  std::vector<heif_sample_aux_info_type> get_sample_aux_info_types() const;
+
+protected:
+  HeifContext* m_heif_context = nullptr;
+  uint32_t m_id = 0;
+  uint32_t m_handler_type = 0;
+
+  TrackOptions m_track_info;
+
+  uint32_t m_num_samples = 0;
+
+  struct SampleTiming {
+    uint32_t sampleIdx = 0;
+    uint32_t sampleInChunkIdx = 0;
+    uint32_t chunkIdx = 0;
+    uint64_t presentation_time = 0; // TODO
+    uint64_t media_composition_time = 0; // TODO
+    uint64_t media_decoding_time = 0;
+    uint32_t sample_duration_media_time = 0;
+    uint32_t sample_duration_presentation_time = 0; // TODO
+  };
+  std::vector<SampleTiming> m_presentation_timeline;
+  uint64_t m_num_output_samples = 0; // Can be larger than the vector. It then repeats the playback.
+
+  // Continuous counting through all repetitions. You have to take the modulo operation to get the
+  // index into m_presentation_timeline SampleTiming table.
+  // (At 30 fps, this 32 bit integer will overflow in >4 years. I think this is acceptable.)
+  uint32_t m_next_sample_to_be_decoded = 0;
+
+  // Total sequence output index.
+  uint32_t m_next_sample_to_be_output = 0;
+  bool     m_decoder_is_flushed = false;
+
+  Error init_sample_timing_table();
+
+  std::vector<std::shared_ptr<Chunk>> m_chunks;
+  std::vector<uint8_t> m_chunk_data;
+
+  std::shared_ptr<Box_moov> m_moov;
+  std::shared_ptr<Box_trak> m_trak;
+  std::shared_ptr<Box_tkhd> m_tkhd;
+  std::shared_ptr<Box_minf> m_minf;
+  std::shared_ptr<Box_mdhd> m_mdhd;
+  std::shared_ptr<Box_hdlr> m_hdlr;
+  std::shared_ptr<Box_stbl> m_stbl;
+  std::shared_ptr<Box_stsd> m_stsd;
+  std::shared_ptr<Box_stsc> m_stsc;
+  std::shared_ptr<Box_stco> m_stco;
+  std::shared_ptr<Box_stts> m_stts;
+  std::shared_ptr<Box_ctts> m_ctts; // optional box, TODO: add only if needed
+  std::shared_ptr<Box_stss> m_stss;
+  std::shared_ptr<Box_stsz> m_stsz;
+  std::shared_ptr<Box_elst> m_elst;
+
+  std::shared_ptr<class Box_tref> m_tref; // optional
+
+  std::string m_auxiliary_info_type; // only for auxiliary tracks
+
+  // --- sample auxiliary information
+
+  std::unique_ptr<SampleAuxInfoHelper> m_aux_helper_tai_timestamps;
+  std::unique_ptr<SampleAuxInfoHelper> m_aux_helper_content_ids;
+
+  std::unique_ptr<SampleAuxInfoReader> m_aux_reader_tai_timestamps;
+  std::unique_ptr<SampleAuxInfoReader> m_aux_reader_content_ids;
+
+  std::shared_ptr<class Box_taic> m_first_taic; // the TAIC of the first chunk
+
+
+  // --- Helper functions for writing samples.
+
+  // Call when we begin a new chunk of samples, e.g. because the compression format changed
+  void add_chunk(heif_compression_format format);
+
+  // Call to set the sample_description_box for the last added chunk.
+  // Has to be called when we call add_chunk().
+  // It is not merged with add_chunk() because the sample_description_box may need information from the
+  // first encoded frame.
+  void set_sample_description_box(std::shared_ptr<Box> sample_description_box);
+
+  // Write the actual sample data. `tai` may be null and `gimi_contentID` may be empty.
+  // In these cases, no timestamp or no contentID will be written, respectively.
+  Error write_sample_data(const std::vector<uint8_t>& raw_data,
+                          uint32_t sample_duration,
+                          int32_t composition_time_offset,
+                          bool is_sync_sample,
+                          const heif_tai_timestamp_packet* tai,
+                          const std::optional<std::string>& gimi_contentID);
+};
+
+
+#endif //LIBHEIF_TRACK_H
diff --git a/libheif/sequences/track_metadata.cc b/libheif/sequences/track_metadata.cc
new file mode 100644
index 0000000000..3d11bebdb1
--- /dev/null
+++ b/libheif/sequences/track_metadata.cc
@@ -0,0 +1,189 @@
+/*
+ * HEIF image base codec.
+ * Copyright (c) 2025 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "track_metadata.h"
+#include "chunk.h"
+#include "context.h"
+#include "api_structs.h"
+#include <utility>
+
+
+Track_Metadata::Track_Metadata(HeifContext* ctx)
+    : Track(ctx)
+{
+}
+
+Error Track_Metadata::load(const std::shared_ptr<Box_trak>& trak)
+{
+  Error parentLoadError = Track::load(trak);
+  if (parentLoadError) {
+    return parentLoadError;
+  }
+
+  const std::vector<uint32_t>& chunk_offsets = m_stco->get_offsets();
+
+  // Metadata tracks are not meant for display
+
+  m_tkhd->set_flags(m_tkhd->get_flags() & ~(Box_tkhd::Flags::Track_in_movie |
+                                            Box_tkhd::Flags::Track_in_preview));
+
+  // Find sequence resolution
+
+  if (!chunk_offsets.empty())  {
+    auto* s2c = m_stsc->get_chunk(static_cast<uint32_t>(1));
+    if (!s2c) {
+      return {
+        heif_error_Invalid_input,
+        heif_suberror_Unspecified,
+        "Metadata track has no chunk 1"
+      };
+    }
+
+    Box_stsc::SampleToChunk sampleToChunk = *s2c;
+
+    auto sample_description = m_stsd->get_sample_entry(sampleToChunk.sample_description_index - 1);
+    if (!sample_description) {
+      return {
+        heif_error_Invalid_input,
+        heif_suberror_Unspecified,
+        "Metadata track has no sample description"
+      };
+    }
+
+    // TODO: read URI
+  }
+
+  return {};
+}
+
+
+Track_Metadata::Track_Metadata(HeifContext* ctx, uint32_t track_id, std::string uri, const TrackOptions* options)
+    : Track(ctx, track_id, options, fourcc("meta")),
+      m_uri(std::move(uri))
+{
+  auto nmhd = std::make_shared<Box_nmhd>();
+  m_minf->append_child_box(nmhd);
+}
+
+
+#if 0
+Result<std::shared_ptr<const Track_Metadata::Metadata>> Track_Metadata::read_next_metadata_sample()
+{
+  if (m_current_chunk > m_chunks.size()) {
+    return Error{heif_error_End_of_sequence,
+                 heif_suberror_Unspecified,
+                 "End of sequence"};
+  }
+
+  while (m_next_sample_to_be_decoded > m_chunks[m_current_chunk]->last_sample_number()) {
+    m_current_chunk++;
+
+    if (m_current_chunk > m_chunks.size()) {
+      return Error{heif_error_End_of_sequence,
+                   heif_suberror_Unspecified,
+                   "End of sequence"};
+    }
+  }
+
+  const std::shared_ptr<Chunk>& chunk = m_chunks[m_current_chunk];
+
+  auto decoder = chunk->get_decoder();
+  assert(decoder);
+
+  decoder->set_data_extent(chunk->get_data_extent_for_sample(m_next_sample_to_be_decoded));
+
+  Result<std::shared_ptr<HeifPixelImage>> decodingResult = decoder->decode_single_frame_from_compressed_data(options);
+  if (decodingResult.error) {
+    m_next_sample_to_be_decoded++;
+    return decodingResult.error;
+  }
+
+  auto image = decodingResult.value;
+
+  if (m_stts) {
+    image->set_sample_duration(m_stts->get_sample_duration(m_next_sample_to_be_decoded));
+  }
+
+  // --- read sample auxiliary data
+
+  if (m_aux_reader_content_ids) {
+    auto readResult = m_aux_reader_content_ids->get_sample_info(get_file().get(), m_next_sample_to_be_decoded);
+    if (readResult.error) {
+      return readResult.error;
+    }
+
+    Result<std::string> convResult = vector_to_string(readResult.value);
+    if (convResult.error) {
+      return convResult.error;
+    }
+
+    image->set_gimi_content_id(convResult.value);
+  }
+
+  if (m_aux_reader_tai_timestamps) {
+    auto readResult = m_aux_reader_tai_timestamps->get_sample_info(get_file().get(), m_next_sample_to_be_decoded);
+    if (readResult.error) {
+      return readResult.error;
+    }
+
+    auto resultTai = Box_itai::decode_tai_from_vector(readResult.value);
+    if (resultTai.error) {
+      return resultTai.error;
+    }
+
+    image->set_tai_timestamp(&resultTai.value);
+  }
+
+  m_next_sample_to_be_decoded++;
+
+  return image;
+}
+#endif
+
+
+Error Track_Metadata::write_raw_metadata(const heif_raw_sequence_sample* raw_sample)
+{
+  // generate new chunk for first metadata packet
+
+  if (m_chunks.empty()) {
+
+    // --- write URIMetaSampleEntry ('urim')
+
+    auto sample_description_box = std::make_shared<Box_URIMetaSampleEntry>();
+    auto uri = std::make_shared<Box_uri>();
+    uri->set_uri(m_uri);
+    sample_description_box->append_child_box(uri);
+
+    add_chunk(heif_compression_undefined);
+    set_sample_description_box(sample_description_box);
+  }
+
+  Error err = write_sample_data(raw_sample->data,
+                                raw_sample->duration,
+                                0,
+                                true,
+                                raw_sample->timestamp,
+                                raw_sample->gimi_sample_content_id);
+  if (err) {
+    return err;
+  }
+
+  return Error::Ok;
+}
diff --git a/libheif/sequences/track_metadata.h b/libheif/sequences/track_metadata.h
new file mode 100644
index 0000000000..2dc986d417
--- /dev/null
+++ b/libheif/sequences/track_metadata.h
@@ -0,0 +1,49 @@
+/*
+ * HEIF image base codec.
+ * Copyright (c) 2025 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_TRACK_METADATA_H
+#define LIBHEIF_TRACK_METADATA_H
+
+#include "track.h"
+#include <string>
+#include <memory>
+#include <vector>
+
+
+class Track_Metadata : public Track {
+public:
+  //Track(HeifContext* ctx);
+
+  Track_Metadata(HeifContext* ctx, uint32_t track_id, std::string uri, const TrackOptions* options);
+
+  Track_Metadata(HeifContext* ctx);
+
+  ~Track_Metadata() override = default;
+
+  // load track from file
+  Error load(const std::shared_ptr<Box_trak>&) override;
+
+  Error write_raw_metadata(const heif_raw_sequence_sample*);
+
+private:
+  std::string m_uri;
+};
+
+#endif //LIBHEIF_TRACK_METADATA_H
diff --git a/libheif/sequences/track_visual.cc b/libheif/sequences/track_visual.cc
new file mode 100644
index 0000000000..ee982a2624
--- /dev/null
+++ b/libheif/sequences/track_visual.cc
@@ -0,0 +1,719 @@
+/*
+ * HEIF image base codec.
+ * Copyright (c) 2025 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "track_visual.h"
+
+#include <memory>
+#include "codecs/decoder.h"
+#include "codecs/encoder.h"
+#include "chunk.h"
+#include "pixelimage.h"
+#include "context.h"
+#include "api_structs.h"
+#include "codecs/hevc_boxes.h"
+#include "codecs/uncompressed/unc_boxes.h"
+
+
+Track_Visual::Track_Visual(HeifContext* ctx)
+  : Track(ctx)
+{
+}
+
+
+Track_Visual::~Track_Visual()
+{
+  for (auto& user_data : m_frame_user_data) {
+    user_data.second.release();
+  }
+}
+
+
+Error Track_Visual::load(const std::shared_ptr<Box_trak>& trak)
+{
+  Error parentLoadError = Track::load(trak);
+  if (parentLoadError) {
+    return parentLoadError;
+  }
+
+  const std::vector<uint32_t>& chunk_offsets = m_stco->get_offsets();
+
+  // Find sequence resolution
+
+  if (!chunk_offsets.empty()) {
+    auto* s2c = m_stsc->get_chunk(1);
+    if (!s2c) {
+      return {
+        heif_error_Invalid_input,
+        heif_suberror_Unspecified,
+        "Visual track has no chunk 1"
+      };
+    }
+
+    Box_stsc::SampleToChunk sampleToChunk = *s2c;
+
+    auto sample_description = m_stsd->get_sample_entry(sampleToChunk.sample_description_index - 1);
+    if (!sample_description) {
+      return {
+        heif_error_Invalid_input,
+        heif_suberror_Unspecified,
+        "Visual track has sample description"
+      };
+    }
+
+    auto visual_sample_description = std::dynamic_pointer_cast<const Box_VisualSampleEntry>(sample_description);
+    if (!visual_sample_description) {
+      return {
+        heif_error_Invalid_input,
+        heif_suberror_Unspecified,
+        "Visual track sample description does not match visual track."
+      };
+    }
+
+    m_width = visual_sample_description->get_VisualSampleEntry_const().width;
+    m_height = visual_sample_description->get_VisualSampleEntry_const().height;
+  }
+
+  return {};
+}
+
+
+Error Track_Visual::initialize_after_parsing(HeifContext* ctx, const std::vector<std::shared_ptr<Track> >& all_tracks)
+{
+  // --- check whether there is an auxiliary alpha track assigned to this track
+
+  // Only assign to image-sequence tracks (TODO: are there also alpha tracks allowed for video tracks 'heif_track_type_video'?)
+
+  if (get_handler() == heif_track_type_image_sequence) {
+    for (auto track : all_tracks) {
+      // skip ourselves
+      if (track->get_id() != get_id()) {
+        // Is this an aux alpha track?
+        auto h = fourcc_to_string(track->get_handler());
+        if (track->get_handler() == heif_track_type_auxiliary &&
+            track->get_auxiliary_info_type() == heif_auxiliary_track_info_type_alpha) {
+          // Is it assigned to the current track
+          auto tref = track->get_tref_box();
+          if (!tref) {
+            return {
+              heif_error_Invalid_input,
+              heif_suberror_Unspecified,
+              "Auxiliary track without 'tref'"
+            };
+          }
+
+          auto references = tref->get_references(fourcc("auxl"));
+          if (std::any_of(references.begin(), references.end(), [this](uint32_t id) { return id == get_id(); })) {
+            // Assign it
+
+            m_aux_alpha_track = std::dynamic_pointer_cast<Track_Visual>(track);
+          }
+        }
+      }
+    }
+  }
+
+  return {};
+}
+
+
+Track_Visual::Track_Visual(HeifContext* ctx, uint32_t track_id, uint16_t width, uint16_t height,
+                           const TrackOptions* options, uint32_t handler_type)
+  : Track(ctx, track_id, options, handler_type)
+{
+  m_tkhd->set_resolution(width, height);
+  //m_hdlr->set_handler_type(handler_type);  already done in Track()
+
+  auto vmhd = std::make_shared<Box_vmhd>();
+  m_minf->append_child_box(vmhd);
+}
+
+
+bool Track_Visual::has_alpha_channel() const
+{
+  if (m_aux_alpha_track != nullptr) {
+    return true;
+  }
+
+  // --- special case: 'uncv' with alpha component
+#if WITH_UNCOMPRESSED_CODEC
+  if (m_stsd) {
+    auto sampleEntry = m_stsd->get_sample_entry(0);
+    if (sampleEntry) {
+      if (auto box_uncv = std::dynamic_pointer_cast<const Box_uncv>(sampleEntry)) {
+        if (auto cmpd = box_uncv->get_child_box<const Box_cmpd>()) {
+          if (cmpd->has_component(heif_uncompressed_component_type_alpha)) {
+            return true;
+          }
+        }
+      }
+    }
+  }
+#endif
+
+  return false;
+}
+
+
+Result<std::shared_ptr<HeifPixelImage> > Track_Visual::decode_next_image_sample(const heif_decoding_options& options)
+{
+  // --- If we ignore the editlist, we stop when we reached the end of the original samples.
+
+  uint64_t num_output_samples = m_num_output_samples;
+  if (options.ignore_sequence_editlist) {
+    num_output_samples = m_num_samples;
+  }
+
+  // --- Did we reach the end of the sequence?
+
+  if (m_next_sample_to_be_output >= num_output_samples) {
+    return Error{
+      heif_error_End_of_sequence,
+      heif_suberror_Unspecified,
+      "End of sequence"
+    };
+  }
+
+
+  std::shared_ptr<HeifPixelImage> image;
+
+  uint32_t sample_idx_in_chunk;
+  uintptr_t decoded_sample_idx = 0; // TODO: map this to sample idx + chunk
+
+  for (;;) {
+    const SampleTiming& sampleTiming = m_presentation_timeline[m_next_sample_to_be_decoded % m_presentation_timeline.size()];
+    sample_idx_in_chunk = sampleTiming.sampleIdx;
+    uint32_t chunk_idx = sampleTiming.chunkIdx;
+
+    const std::shared_ptr<Chunk>& chunk = m_chunks[chunk_idx];
+
+    auto decoder = chunk->get_decoder();
+    assert(decoder);
+
+    // avoid calling get_decoded_frame() before starting the decoder.
+    if (m_next_sample_to_be_decoded != 0) {
+      Result<std::shared_ptr<HeifPixelImage> > getFrameResult = decoder->get_decoded_frame(options,
+                                                                                           &decoded_sample_idx,
+                                                                                           m_heif_context->get_security_limits());
+      if (getFrameResult.error()) {
+        return getFrameResult.error();
+      }
+
+
+      // We received a decoded frame. Exit "push data" / "decode" loop.
+
+      if (*getFrameResult != nullptr) {
+        image = *getFrameResult;
+
+        // If this was the last frame in the EditList segment, reset the 'flushed' flag
+        // in case we have to restart the decoder for another repetition of the segment.
+        if ((m_next_sample_to_be_output + 1) % m_presentation_timeline.size() == 0) {
+          m_decoder_is_flushed = false;
+        }
+
+        break;
+      }
+
+      // If the sequence has ended and the decoder was flushed, but we still did not receive
+      // the image, we are waiting for, this is an error.
+      if (m_decoder_is_flushed) {
+        return Error(heif_error_Decoder_plugin_error,
+                     heif_suberror_Unspecified,
+                     "Did not decode all frames");
+      }
+    }
+
+
+    // --- Push more data into the decoder (or send end-of-sequence).
+
+    if (m_next_sample_to_be_decoded < m_num_output_samples) {
+
+      // --- Find the data extent that stores the compressed frame data.
+
+      DataExtent extent = chunk->get_data_extent_for_sample(sample_idx_in_chunk);
+      decoder->set_data_extent(extent);
+
+      // std::cout << "PUSH chunk " << chunk_idx << " sample " << sample_idx << " (" << extent.m_size << " bytes)\n";
+
+      // advance decoding index to next in segment
+      m_next_sample_to_be_decoded++;
+
+      // Send the decoder configuration when we send the first sample of the chunk.
+      // The configuration NALs might change for each chunk.
+      const bool is_first_sample = (sample_idx_in_chunk == 0);
+
+      // --- Push data into the decoder.
+      Error decodingError = decoder->decode_sequence_frame_from_compressed_data(is_first_sample,
+                                                                                options,
+                                                                                sample_idx_in_chunk, // user data
+                                                                                m_heif_context->get_security_limits());
+      if (decodingError) {
+        return decodingError;
+      }
+    }
+    else {
+      // --- End of sequence (Editlist segment) reached.
+
+      // std::cout << "FLUSH\n";
+      Error flushError = decoder->flush_decoder();
+      if (flushError) {
+        return flushError;
+      }
+
+      m_decoder_is_flushed = true;
+    }
+  }
+
+
+  // --- We have received a new decoded image.
+  //     Postprocess decoded image, attach metadata.
+
+  if (m_stts) {
+    image->set_sample_duration(m_stts->get_sample_duration(sample_idx_in_chunk));
+  }
+
+  // --- assign alpha if we have an assigned alpha track
+
+  if (m_aux_alpha_track) {
+    auto alphaResult = m_aux_alpha_track->decode_next_image_sample(options);
+    if (!alphaResult) {
+      return alphaResult.error();
+    }
+
+    auto alphaImage = *alphaResult;
+    image->transfer_plane_from_image_as(alphaImage, heif_channel_Y, heif_channel_Alpha);
+  }
+
+
+  // --- read sample auxiliary data
+
+  if (m_aux_reader_content_ids) {
+    auto readResult = m_aux_reader_content_ids->get_sample_info(get_file().get(), (uint32_t)decoded_sample_idx);
+    if (!readResult) {
+      return readResult.error();
+    }
+
+    Result<std::string> convResult = vector_to_string(*readResult);
+    if (!convResult) {
+      return convResult.error();
+    }
+
+    image->set_gimi_sample_content_id(*convResult);
+  }
+
+  if (m_aux_reader_tai_timestamps) {
+    auto readResult = m_aux_reader_tai_timestamps->get_sample_info(get_file().get(), (uint32_t)decoded_sample_idx);
+    if (!readResult) {
+      return readResult.error();
+    }
+
+    std::vector<uint8_t>& tai_data = *readResult;
+    if (!tai_data.empty()) {
+      auto resultTai = Box_itai::decode_tai_from_vector(tai_data);
+      if (!resultTai) {
+        return resultTai.error();
+      }
+
+      image->set_tai_timestamp(&*resultTai);
+    }
+  }
+
+  m_next_sample_to_be_output++;
+
+  return image;
+}
+
+
+Error Track_Visual::encode_end_of_sequence(heif_encoder* h_encoder)
+{
+  auto encoder = m_chunks.back()->get_encoder();
+
+  for (;;) {
+    Error err = encoder->encode_sequence_flush(h_encoder);
+    if (err) {
+      return err;
+    }
+
+    Result<bool> processingResult = process_encoded_data(h_encoder);
+    if (processingResult.is_error()) {
+      return processingResult.error();
+    }
+
+    if (!*processingResult) {
+      break;
+    }
+  }
+
+
+  // --- also end alpha track
+
+  if (m_aux_alpha_track) {
+    auto err = m_aux_alpha_track->encode_end_of_sequence(m_alpha_track_encoder.get());
+    if (err) {
+      return err;
+    }
+  }
+
+  return {};
+}
+
+
+Error Track_Visual::encode_image(std::shared_ptr<HeifPixelImage> image,
+                                 heif_encoder* h_encoder,
+                                 const heif_sequence_encoding_options* in_options,
+                                 heif_image_input_class input_class)
+{
+  if (image->get_width() > 0xFFFF ||
+      image->get_height() > 0xFFFF) {
+    return {
+      heif_error_Invalid_input,
+      heif_suberror_Unspecified,
+      "Input image resolution too high"
+    };
+  }
+
+  m_image_class = input_class;
+
+
+  // --- If input has an alpha channel, add an alpha auxiliary track.
+
+  if (in_options->save_alpha_channel && image->has_alpha() && !m_aux_alpha_track &&
+      h_encoder->plugin->compression_format != heif_compression_uncompressed) { // TODO: ask plugin
+    if (m_active_encoder) {
+      return {
+        heif_error_Usage_error,
+        heif_suberror_Unspecified,
+        "Input images must all either have an alpha channel or none of them."
+      };
+    }
+    else {
+      // alpha track uses default options, same timescale as color track
+
+      TrackOptions alphaOptions;
+      alphaOptions.track_timescale = m_track_info.track_timescale;
+
+      auto newAlphaTrackResult = m_heif_context->add_visual_sequence_track(&alphaOptions,
+                                                                           heif_track_type_auxiliary,
+                                                                           static_cast<uint16_t>(image->get_width()),
+                                                                           static_cast<uint16_t>(image->get_height()));
+
+      if (auto err = newAlphaTrackResult.error()) {
+        return err;
+      }
+
+      // add a reference to the color track
+
+      m_aux_alpha_track = *newAlphaTrackResult;
+      m_aux_alpha_track->add_reference_to_track(fourcc("auxl"), m_id);
+
+      // make a copy of the encoder from the color track for encoding the alpha track
+
+      m_alpha_track_encoder = std::make_unique<heif_encoder>(h_encoder->plugin);
+      heif_error err = m_alpha_track_encoder->alloc();
+      if (err.code) {
+        return {err.code, err.subcode, err.message};
+      }
+    }
+  }
+
+
+  if (!m_active_encoder) {
+    m_active_encoder = h_encoder;
+  }
+  else if (m_active_encoder != h_encoder) {
+    return {
+      heif_error_Usage_error,
+      heif_suberror_Unspecified,
+      "You may not switch the heif_encoder while encoding a sequence."
+    };
+  }
+
+  if (h_encoder->plugin->plugin_api_version < 4) {
+    return Error{
+      heif_error_Plugin_loading_error, heif_suberror_No_matching_decoder_installed,
+      "Encoder plugin needs to be at least version 4."
+    };
+  }
+
+  // === generate compressed image bitstream
+
+  // generate new chunk for first image or when compression formats don't match
+
+  if (m_chunks.empty() || m_chunks.back()->get_compression_format() != h_encoder->plugin->compression_format) {
+    add_chunk(h_encoder->plugin->compression_format);
+  }
+
+  // --- check whether we have to convert the image color space
+
+  // The reason for doing the color conversion here is that the input might be an RGBA image and the color conversion
+  // will extract the alpha plane anyway. We can reuse that plane below instead of having to do a new conversion.
+
+  auto encoder = m_chunks.back()->get_encoder();
+
+  const heif_color_profile_nclx* output_nclx;
+  heif_color_profile_nclx nclx;
+
+  if (const auto* image_nclx = encoder->get_forced_output_nclx()) {
+    output_nclx = const_cast<heif_color_profile_nclx*>(image_nclx);
+  }
+  else if (in_options) {
+    output_nclx = in_options->output_nclx_profile;
+  }
+  else {
+    if (image->has_nclx_color_profile()) {
+      nclx_profile input_nclx = image->get_color_profile_nclx();
+
+      nclx.version = 1;
+      nclx.color_primaries = (enum heif_color_primaries) input_nclx.get_colour_primaries();
+      nclx.transfer_characteristics = (enum heif_transfer_characteristics) input_nclx.get_transfer_characteristics();
+      nclx.matrix_coefficients = (enum heif_matrix_coefficients) input_nclx.get_matrix_coefficients();
+      nclx.full_range_flag = input_nclx.get_full_range_flag();
+
+      output_nclx = &nclx;
+    }
+    else {
+      nclx_profile undefined_nclx;
+      undefined_nclx.copy_to_heif_color_profile_nclx(&nclx);
+
+      output_nclx = &nclx;
+    }
+  }
+
+  Result<std::shared_ptr<HeifPixelImage> > srcImageResult = encoder->convert_colorspace_for_encoding(image,
+                                                                                                     h_encoder,
+                                                                                                     output_nclx,
+                                                                                                     in_options ? &in_options->color_conversion_options : nullptr,
+                                                                                                     m_heif_context->get_security_limits());
+  if (!srcImageResult) {
+    return srcImageResult.error();
+  }
+
+  std::shared_ptr<HeifPixelImage> colorConvertedImage = *srcImageResult;
+
+  // integer range is checked at beginning of function.
+  assert(colorConvertedImage->get_width() == image->get_width());
+  assert(colorConvertedImage->get_height() == image->get_height());
+  m_width = static_cast<uint16_t>(colorConvertedImage->get_width());
+  m_height = static_cast<uint16_t>(colorConvertedImage->get_height());
+
+  // --- encode image
+
+  heif_sequence_encoding_options* local_dummy_options = nullptr;
+  if (!in_options) {
+    local_dummy_options = heif_sequence_encoding_options_alloc();
+  }
+
+  Error encodeError = encoder->encode_sequence_frame(colorConvertedImage, h_encoder,
+                                                     in_options ? *in_options : *local_dummy_options,
+                                                     input_class,
+                                                     colorConvertedImage->get_sample_duration(), get_timescale(),
+                                                     m_current_frame_nr);
+  if (local_dummy_options) {
+    heif_sequence_encoding_options_release(local_dummy_options);
+  }
+
+  if (encodeError) {
+    return encodeError;
+  }
+
+  m_sample_duration = colorConvertedImage->get_sample_duration();
+  // TODO heif_tai_timestamp_packet* tai = image->get_tai_timestamp();
+  // TODO image->has_gimi_sample_content_id() ? image->get_gimi_sample_content_id() : std::string{});
+
+
+  // store frame user data
+
+  FrameUserData userData;
+  userData.sample_duration = colorConvertedImage->get_sample_duration();
+  if (image->has_gimi_sample_content_id()) {
+    userData.gimi_content_id = image->get_gimi_sample_content_id();
+  }
+
+  if (const auto* tai = image->get_tai_timestamp()) {
+    userData.tai_timestamp = heif_tai_timestamp_packet_alloc();
+    heif_tai_timestamp_packet_copy(userData.tai_timestamp, tai);
+  }
+
+  m_frame_user_data[m_current_frame_nr] = userData;
+
+  m_current_frame_nr++;
+
+  // --- get compressed data from encoder
+
+  Result<bool> processingResult = process_encoded_data(h_encoder);
+  if (auto err = processingResult.error()) {
+    return err;
+  }
+
+
+  // --- encode alpha channel into auxiliary track
+
+  if (m_aux_alpha_track) {
+    auto alphaImageResult = create_alpha_image_from_image_alpha_channel(colorConvertedImage,
+                                                                        m_heif_context->get_security_limits());
+    if (auto err = alphaImageResult.error()) {
+      return err;
+    }
+
+    (*alphaImageResult)->set_sample_duration(colorConvertedImage->get_sample_duration());
+
+    auto err = m_aux_alpha_track->encode_image(*alphaImageResult,
+                                               m_alpha_track_encoder.get(),
+                                               in_options,
+                                               heif_image_input_class_alpha);
+    if (err) {
+      return err;
+    }
+  }
+
+  return {};
+}
+
+
+Result<bool> Track_Visual::process_encoded_data(heif_encoder* h_encoder)
+{
+  auto encoder = m_chunks.back()->get_encoder();
+
+  std::optional<Encoder::CodedImageData> encodingResult = encoder->encode_sequence_get_data();
+  if (!encodingResult) {
+    return {};
+  }
+
+  const Encoder::CodedImageData& data = *encodingResult;
+
+
+  if (data.bitstream.empty() &&
+      data.properties.empty()) {
+    return {false};
+  }
+
+  // --- generate SampleDescriptionBox
+
+  if (!m_generated_sample_description_box) {
+    auto sample_description_box = encoder->get_sample_description_box(data);
+    if (sample_description_box) {
+      VisualSampleEntry& visualSampleEntry = sample_description_box->get_VisualSampleEntry();
+      visualSampleEntry.width = m_width;
+      visualSampleEntry.height = m_height;
+
+      // add Coding-Constraints box (ccst) only if we are generating an image sequence
+
+      // TODO: does the alpha track also need a ccst box?
+      //       ComplianceWarden says so (and it makes sense), but HEIF says that 'ccst' shall be present
+      //       if the handler is 'pict'. However, the alpha track is 'auxv'.
+      if (true) { // m_hdlr->get_handler_type() == heif_track_type_image_sequence) {
+        auto ccst = std::make_shared<Box_ccst>();
+        ccst->set_coding_constraints(data.codingConstraints);
+        sample_description_box->append_child_box(ccst);
+      }
+
+      if (m_image_class == heif_image_input_class_alpha) {
+        auto auxi_box = std::make_shared<Box_auxi>();
+        auxi_box->set_aux_track_type_urn(get_track_auxiliary_info_type(h_encoder->plugin->compression_format));
+        sample_description_box->append_child_box(auxi_box);
+      }
+
+      set_sample_description_box(sample_description_box);
+      m_generated_sample_description_box = true;
+    }
+  }
+
+  if (!data.bitstream.empty()) {
+    uintptr_t frame_number = data.frame_nr;
+
+    auto& user_data = m_frame_user_data[frame_number];
+
+    int32_t decoding_time = static_cast<int32_t>(m_stsz->num_samples()) * m_sample_duration;
+    int32_t composition_time = static_cast<int32_t>(frame_number) * m_sample_duration;
+
+    Error err = write_sample_data(data.bitstream,
+                                  user_data.sample_duration,
+                                  composition_time - decoding_time,
+                                  data.is_sync_frame,
+                                  user_data.tai_timestamp,
+                                  user_data.gimi_content_id);
+
+    user_data.release();
+    m_frame_user_data.erase(frame_number);
+
+    if (err) {
+      return err;
+    }
+  }
+
+  return {true};
+}
+
+
+Error Track_Visual::finalize_track()
+{
+  if (m_active_encoder) {
+    Error err = encode_end_of_sequence(m_active_encoder);
+    if (err) {
+      return err;
+    }
+  }
+
+  return Track::finalize_track();
+}
+
+
+heif_brand2 Track_Visual::get_compatible_brand() const
+{
+  if (m_stsd->get_num_sample_entries() == 0) {
+    return 0; // TODO: error ? Or can we assume at this point that there is at least one sample entry?
+  }
+
+  auto sampleEntry = m_stsd->get_sample_entry(0);
+
+  uint32_t sample_entry_type = sampleEntry->get_short_type();
+  switch (sample_entry_type) {
+    case fourcc("hvc1"): {
+      auto hvcC = sampleEntry->get_child_box<Box_hvcC>();
+      if (!hvcC) { return 0; }
+
+      const auto& config = hvcC->get_configuration();
+      if (config.is_profile_compatibile(HEVCDecoderConfigurationRecord::Profile_Main) ||
+          config.is_profile_compatibile(HEVCDecoderConfigurationRecord::Profile_MainStillPicture)) {
+        return heif_brand2_hevc;
+      }
+      else {
+        return heif_brand2_hevx;
+      }
+    }
+
+    case fourcc("avc1"):
+      return heif_brand2_avcs;
+
+    case fourcc("av01"):
+      return heif_brand2_avis;
+
+    case fourcc("j2ki"):
+      return heif_brand2_j2is;
+
+    case fourcc("mjpg"):
+      return heif_brand2_jpgs;
+
+    case fourcc("vvc1"):
+      return heif_brand2_vvis;
+
+    default:
+      return 0;
+  }
+}
diff --git a/libheif/sequences/track_visual.h b/libheif/sequences/track_visual.h
new file mode 100644
index 0000000000..94890d4c8f
--- /dev/null
+++ b/libheif/sequences/track_visual.h
@@ -0,0 +1,104 @@
+/*
+ * HEIF image base codec.
+ * Copyright (c) 2025 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_TRACK_VISUAL_H
+#define LIBHEIF_TRACK_VISUAL_H
+
+#include "track.h"
+#include <string>
+#include <memory>
+#include <vector>
+#include <map>
+
+
+class Track_Visual : public Track {
+public:
+  //Track(HeifContext* ctx);
+
+  Track_Visual(HeifContext* ctx, uint32_t track_id, uint16_t width, uint16_t height,
+               const TrackOptions* options, uint32_t handler_type);
+
+  Track_Visual(HeifContext* ctx);
+
+  ~Track_Visual() override;
+
+  // load track from file
+  Error load(const std::shared_ptr<Box_trak>&) override;
+
+  [[nodiscard]] Error initialize_after_parsing(HeifContext* ctx, const std::vector<std::shared_ptr<Track>>& all_tracks) override;
+
+  uint16_t get_width() const { return m_width; }
+
+  uint16_t get_height() const { return m_height; }
+
+  bool has_alpha_channel() const override;
+
+  Result<std::shared_ptr<HeifPixelImage>> decode_next_image_sample(const heif_decoding_options& options);
+
+  Error encode_image(std::shared_ptr<HeifPixelImage> image,
+                     heif_encoder* encoder,
+                     const heif_sequence_encoding_options* options,
+                     heif_image_input_class image_class);
+
+  Error encode_end_of_sequence(heif_encoder* encoder);
+
+  Error finalize_track() override;
+
+  heif_brand2 get_compatible_brand() const;
+
+private:
+  uint16_t m_width = 0;
+  uint16_t m_height = 0;
+  heif_image_input_class m_image_class;
+
+  uintptr_t m_current_frame_nr = 0;
+  bool m_generated_sample_description_box = false;
+
+  struct FrameUserData
+  {
+    int sample_duration = 0;
+
+    std::optional<std::string> gimi_content_id;
+    heif_tai_timestamp_packet* tai_timestamp = nullptr;
+
+    void release()
+    {
+      heif_tai_timestamp_packet_release(tai_timestamp);
+      tai_timestamp = nullptr;
+    }
+  };
+
+  // map frame number to user data
+  std::map<uintptr_t, FrameUserData> m_frame_user_data;
+
+  int m_sample_duration = 0; // TODO: pass this through encoder or handle it correctly with frame reordering
+
+  // If there is an alpha-channel track associated with this color track, we reference it from here
+  std::shared_ptr<Track_Visual> m_aux_alpha_track;
+
+  heif_encoder* m_active_encoder = nullptr;
+  std::unique_ptr<heif_encoder> m_alpha_track_encoder;
+
+  Result<bool> process_encoded_data(heif_encoder* encoder);
+};
+
+
+
+#endif //LIBHEIF_TRACK_VISUAL_H
diff --git a/libheif/text.cc b/libheif/text.cc
new file mode 100644
index 0000000000..d996a20bc6
--- /dev/null
+++ b/libheif/text.cc
@@ -0,0 +1,39 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ * Copyright (c) 2025 Brad Hards <bradh@frogmouth.net>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <string>
+#include "text.h"
+#include "error.h"
+#include <iostream>
+
+
+Result<std::vector<uint8_t>> TextItem::encode() const
+{
+  std::vector<uint8_t> data;
+  data.assign(m_text.begin(), m_text.end());
+  return data;
+}
+
+Error TextItem::parse(const std::vector<uint8_t> &data)
+{
+  m_text.assign(data.begin(), data.end());
+  return Error::Ok;
+}
\ No newline at end of file
diff --git a/libheif/text.h b/libheif/text.h
new file mode 100644
index 0000000000..0a85f4af4d
--- /dev/null
+++ b/libheif/text.h
@@ -0,0 +1,57 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ * Copyright (c) 2025 Brad Hards <bradh@frogmouth.net>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_TEXT_H
+#define LIBHEIF_TEXT_H
+
+#include <cstring>
+#include <string>
+#include <vector>
+#include "error.h"
+#include "libheif/heif_text.h"
+
+class TextItem
+{
+public:
+  TextItem() = default;
+
+  TextItem(heif_item_id itemId, const char *text) : m_item_id(itemId), m_text(text) {}
+
+  Error parse(const std::vector<uint8_t> &data);
+
+  Result<std::vector<uint8_t>> encode() const;
+
+  heif_item_id get_item_id() const {
+    return m_item_id;
+  }
+
+  void set_item_id(heif_item_id id) {
+    m_item_id = id;
+  }
+
+  std::string get_item_text() const { return m_text; }
+
+private:
+  heif_item_id m_item_id = 0;
+  std::string m_text;
+};
+
+#endif // LIBHEIF_TEXT_H
diff --git a/logos/sponsors/shopify.svg b/logos/sponsors/shopify.svg
new file mode 100755
index 0000000000..de6ba753cd
--- /dev/null
+++ b/logos/sponsors/shopify.svg
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 23.0.2, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 viewBox="0 0 109.5 124.5" style="enable-background:new 0 0 109.5 124.5;" xml:space="preserve">
+<style type="text/css">
+	.st0{fill:#95BF47;}
+	.st1{fill:#5E8E3E;}
+	.st2{fill:#FFFFFF;}
+</style>
+<g>
+	<path class="st0" d="M95.9,23.9c-0.1-0.6-0.6-1-1.1-1c-0.5,0-9.3-0.2-9.3-0.2s-7.4-7.2-8.1-7.9c-0.7-0.7-2.2-0.5-2.7-0.3
+		c0,0-1.4,0.4-3.7,1.1c-0.4-1.3-1-2.8-1.8-4.4c-2.6-5-6.5-7.7-11.1-7.7c0,0,0,0,0,0c-0.3,0-0.6,0-1,0.1c-0.1-0.2-0.3-0.3-0.4-0.5
+		c-2-2.2-4.6-3.2-7.7-3.1c-6,0.2-12,4.5-16.8,12.2c-3.4,5.4-6,12.2-6.8,17.5c-6.9,2.1-11.7,3.6-11.8,3.7c-3.5,1.1-3.6,1.2-4,4.5
+		c-0.3,2.5-9.5,73-9.5,73l76.4,13.2l33.1-8.2C109.5,115.8,96,24.5,95.9,23.9z M67.2,16.8c-1.8,0.5-3.8,1.2-5.9,1.8
+		c0-3-0.4-7.3-1.8-10.9C64,8.6,66.2,13.7,67.2,16.8z M57.2,19.9c-4,1.2-8.4,2.6-12.8,3.9c1.2-4.7,3.6-9.4,6.4-12.5
+		c1.1-1.1,2.6-2.4,4.3-3.2C56.9,11.6,57.3,16.5,57.2,19.9z M49.1,4c1.4,0,2.6,0.3,3.6,0.9C51.1,5.8,49.5,7,48,8.6
+		c-3.8,4.1-6.7,10.5-7.9,16.6c-3.6,1.1-7.2,2.2-10.5,3.2C31.7,18.8,39.8,4.3,49.1,4z"/>
+	<g>
+		<path class="st1" d="M94.8,22.9c-0.5,0-9.3-0.2-9.3-0.2s-7.4-7.2-8.1-7.9c-0.3-0.3-0.6-0.4-1-0.5l0,109.7l33.1-8.2
+			c0,0-13.5-91.3-13.6-92C95.8,23.3,95.3,22.9,94.8,22.9z"/>
+		<path class="st2" d="M58,39.9l-3.8,14.4c0,0-4.3-2-9.4-1.6c-7.5,0.5-7.5,5.2-7.5,6.4c0.4,6.4,17.3,7.8,18.3,22.9
+			c0.7,11.9-6.3,20-16.4,20.6c-12.2,0.8-18.9-6.4-18.9-6.4l2.6-11c0,0,6.7,5.1,12.1,4.7c3.5-0.2,4.8-3.1,4.7-5.1
+			c-0.5-8.4-14.3-7.9-15.2-21.7c-0.7-11.6,6.9-23.4,23.7-24.4C54.7,38.2,58,39.9,58,39.9z"/>
+	</g>
+</g>
+</svg>
diff --git a/m4/ac_c_cxx_compile_flags.m4 b/m4/ac_c_cxx_compile_flags.m4
deleted file mode 100644
index dd40070d6a..0000000000
--- a/m4/ac_c_cxx_compile_flags.m4
+++ /dev/null
@@ -1,22 +0,0 @@
-AC_DEFUN([AC_C_CXX_COMPILE_FLAGS],[
-NEW_CFLAGS="$CFLAGS"
-NEW_CXXFLAGS="$CXXFLAGS"
-for ac_flag in $1
-do
- AC_MSG_CHECKING(whether compiler supports $ac_flag)
- CXXFLAGS="$NEW_CXXFLAGS $ac_flag"
- AC_LANG(C++)
- AC_TRY_COMPILE(,[
-  ;
- ],[
-
-  NEW_CFLAGS="$NEW_CFLAGS $ac_flag"
-  NEW_CXXFLAGS="$NEW_CXXFLAGS $ac_flag"
-
-  AC_MSG_RESULT(yes)
- ],AC_MSG_RESULT(no))
-done
-
-CFLAGS=$NEW_CFLAGS
-CXXFLAGS=$NEW_CXXFLAGS
-])
diff --git a/m4/ax_cxx_compile_stdcxx_11.m4 b/m4/ax_cxx_compile_stdcxx_11.m4
deleted file mode 100644
index 88895ad766..0000000000
--- a/m4/ax_cxx_compile_stdcxx_11.m4
+++ /dev/null
@@ -1,142 +0,0 @@
-# ============================================================================
-#  http://www.gnu.org/software/autoconf-archive/ax_cxx_compile_stdcxx_11.html
-# ============================================================================
-#
-# SYNOPSIS
-#
-#   AX_CXX_COMPILE_STDCXX_11([ext|noext],[mandatory|optional])
-#
-# DESCRIPTION
-#
-#   Check for baseline language coverage in the compiler for the C++11
-#   standard; if necessary, add switches to CXXFLAGS to enable support.
-#
-#   The first argument, if specified, indicates whether you insist on an
-#   extended mode (e.g. -std=gnu++11) or a strict conformance mode (e.g.
-#   -std=c++11).  If neither is specified, you get whatever works, with
-#   preference for an extended mode.
-#
-#   The second argument, if specified 'mandatory' or if left unspecified,
-#   indicates that baseline C++11 support is required and that the macro
-#   should error out if no mode with that support is found.  If specified
-#   'optional', then configuration proceeds regardless, after defining
-#   HAVE_CXX11 if and only if a supporting mode is found.
-#
-# LICENSE
-#
-#   Copyright (c) 2008 Benjamin Kosnik <bkoz@redhat.com>
-#   Copyright (c) 2012 Zack Weinberg <zackw@panix.com>
-#   Copyright (c) 2013 Roy Stogner <roystgnr@ices.utexas.edu>
-#   Copyright (c) 2014 Alexey Sokolov <sokolov@google.com>
-#
-#   Copying and distribution of this file, with or without modification, are
-#   permitted in any medium without royalty provided the copyright notice
-#   and this notice are preserved. This file is offered as-is, without any
-#   warranty.
-
-#serial 4
-
-m4_define([_AX_CXX_COMPILE_STDCXX_11_testbody], [[
-  template <typename T>
-    struct check
-    {
-      static_assert(sizeof(int) <= sizeof(T), "not big enough");
-    };
-
-    struct Base {
-    virtual void f() {}
-    };
-    struct Child : public Base {
-    virtual void f() {} // DiFa: override {}   # override not supported in gcc 4.6
-    };
-
-    typedef check<check<bool>> right_angle_brackets;
-
-    int a;
-    decltype(a) b;
-
-    typedef check<int> check_type;
-    check_type c;
-    check_type&& cr = static_cast<check_type&&>(c);
-
-    auto d = a;
-    auto l = [](){};
-]])
-
-AC_DEFUN([AX_CXX_COMPILE_STDCXX_11], [dnl
-  m4_if([$1], [], [],
-        [$1], [ext], [],
-        [$1], [noext], [],
-        [m4_fatal([invalid argument `$1' to AX_CXX_COMPILE_STDCXX_11])])dnl
-  m4_if([$2], [], [ax_cxx_compile_cxx11_required=true],
-        [$2], [mandatory], [ax_cxx_compile_cxx11_required=true],
-        [$2], [optional], [ax_cxx_compile_cxx11_required=false],
-        [m4_fatal([invalid second argument `$2' to AX_CXX_COMPILE_STDCXX_11])])
-  AC_LANG_PUSH([C++])dnl
-  ac_success=no
-  AC_CACHE_CHECK(whether $CXX supports C++11 features by default,
-  ax_cv_cxx_compile_cxx11,
-  [AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_11_testbody])],
-    [ax_cv_cxx_compile_cxx11=yes],
-    [ax_cv_cxx_compile_cxx11=no])])
-  if test x$ax_cv_cxx_compile_cxx11 = xyes; then
-    ac_success=yes
-  fi
-
-  m4_if([$1], [noext], [], [dnl
-  if test x$ac_success = xno; then
-    for switch in -std=gnu++11 -std=gnu++0x; do
-      cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx11_$switch])
-      AC_CACHE_CHECK(whether $CXX supports C++11 features with $switch,
-                     $cachevar,
-        [ac_save_CXXFLAGS="$CXXFLAGS"
-         CXXFLAGS="$CXXFLAGS $switch"
-         AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_11_testbody])],
-          [eval $cachevar=yes],
-          [eval $cachevar=no])
-         CXXFLAGS="$ac_save_CXXFLAGS"])
-      if eval test x\$$cachevar = xyes; then
-        CXXFLAGS="$CXXFLAGS $switch"
-        ac_success=yes
-        break
-      fi
-    done
-  fi])
-
-  m4_if([$1], [ext], [], [dnl
-  if test x$ac_success = xno; then
-    for switch in -std=c++11 -std=c++0x; do
-      cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx11_$switch])
-      AC_CACHE_CHECK(whether $CXX supports C++11 features with $switch,
-                     $cachevar,
-        [ac_save_CXXFLAGS="$CXXFLAGS"
-         CXXFLAGS="$CXXFLAGS $switch"
-         AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_11_testbody])],
-          [eval $cachevar=yes],
-          [eval $cachevar=no])
-         CXXFLAGS="$ac_save_CXXFLAGS"])
-      if eval test x\$$cachevar = xyes; then
-        CXXFLAGS="$CXXFLAGS $switch"
-        ac_success=yes
-        break
-      fi
-    done
-  fi])
-  AC_LANG_POP([C++])
-  if test x$ax_cxx_compile_cxx11_required = xtrue; then
-    if test x$ac_success = xno; then
-      AC_MSG_ERROR([*** A compiler with support for C++11 language features is required.])
-    fi
-  else
-    if test x$ac_success = xno; then
-      HAVE_CXX11=0
-      AC_MSG_NOTICE([No compiler with C++11 support was found])
-    else
-      HAVE_CXX11=1
-      AC_DEFINE(HAVE_CXX11,1,
-                [define if the compiler supports basic C++11 syntax])
-    fi
-
-    AC_SUBST(HAVE_CXX11)
-  fi
-])
diff --git a/m4/visibility.m4 b/m4/visibility.m4
deleted file mode 100644
index 2ff6330aa4..0000000000
--- a/m4/visibility.m4
+++ /dev/null
@@ -1,52 +0,0 @@
-# visibility.m4 serial 1 (gettext-0.15)
-dnl Copyright (C) 2005 Free Software Foundation, Inc.
-dnl This file is free software; the Free Software Foundation
-dnl gives unlimited permission to copy and/or distribute it,
-dnl with or without modifications, as long as this notice is preserved.
-
-dnl From Bruno Haible.
-
-dnl Tests whether the compiler supports the command-line option
-dnl -fvisibility=hidden and the function and variable attributes
-dnl __attribute__((__visibility__("hidden"))) and
-dnl __attribute__((__visibility__("default"))).
-dnl Does *not* test for __visibility__("protected") - which has tricky
-dnl semantics (see the 'vismain' test in glibc) and does not exist e.g. on
-dnl MacOS X.
-dnl Does *not* test for __visibility__("internal") - which has processor
-dnl dependent semantics.
-dnl Does *not* test for #pragma GCC visibility push(hidden) - which is
-dnl "really only recommended for legacy code".
-dnl Set the variable CFLAG_VISIBILITY.
-dnl Defines and sets the variable HAVE_VISIBILITY.
-
-AC_DEFUN([gl_VISIBILITY],
-[
-  AC_REQUIRE([AC_PROG_CC])
-  CFLAG_VISIBILITY=
-  HAVE_VISIBILITY=0
-  if test -n "$GCC"; then
-    AC_MSG_CHECKING([for simple visibility declarations])
-    AC_CACHE_VAL(gl_cv_cc_visibility, [
-      gl_save_CFLAGS="$CFLAGS"
-      CFLAGS="$CFLAGS -fvisibility=hidden"
-      AC_TRY_COMPILE(
-        [extern __attribute__((__visibility__("hidden"))) int hiddenvar;
-         extern __attribute__((__visibility__("default"))) int exportedvar;
-         extern __attribute__((__visibility__("hidden"))) int hiddenfunc (void);
-         extern __attribute__((__visibility__("default"))) int exportedfunc (void);],
-        [],
-        gl_cv_cc_visibility=yes,
-        gl_cv_cc_visibility=no)
-      CFLAGS="$gl_save_CFLAGS"])
-    AC_MSG_RESULT([$gl_cv_cc_visibility])
-    if test $gl_cv_cc_visibility = yes; then
-      CFLAG_VISIBILITY="-fvisibility=hidden"
-      HAVE_VISIBILITY=1
-    fi
-  fi
-  AC_SUBST([CFLAG_VISIBILITY])
-  AC_SUBST([HAVE_VISIBILITY])
-  AC_DEFINE_UNQUOTED([HAVE_VISIBILITY], [$HAVE_VISIBILITY],
-    [Define to 1 or 0, depending whether the compiler supports simple visibility declarations.])
-])
diff --git a/post.js b/post.js
index 3c0e70fec8..271d39a6f5 100644
--- a/post.js
+++ b/post.js
@@ -14,7 +14,7 @@ var HeifImage = function(handle) {
 
 HeifImage.prototype.free = function() {
     if (this.handle) {
-        libheif.heif_image_handle_release(this.handle);
+        Module.heif_image_handle_release(this.handle);
         this.handle = null;
     }
 };
@@ -24,8 +24,8 @@ HeifImage.prototype._ensureImage = function() {
         return;
     }
 
-    var img = libheif.heif_js_decode_image(this.handle,
-        libheif.heif_colorspace_YCbCr, libheif.heif_chroma_420);
+    var img = Module.heif_js_decode_image(this.handle,
+      Module.heif_colorspace.heif_colorspace_YCbCr, Module.heif_chroma.heif_chroma_420);
     if (!img || img.code) {
         console.log("Decoding image failed", this.handle, img);
         return;
@@ -34,21 +34,31 @@ HeifImage.prototype._ensureImage = function() {
     this.data = new Uint8Array(StringToArrayBuffer(img.data));
     delete img.data;
     this.img = img;
+
+    if (img.alpha !== undefined) {
+        this.alpha = new Uint8Array(StringToArrayBuffer(img.alpha));
+        delete img.alpha;
+    }
 };
 
 HeifImage.prototype.get_width = function() {
-    this._ensureImage();
-    return this.img.width;
+    return Module.heif_image_handle_get_width(this.handle);
 };
 
 HeifImage.prototype.get_height = function() {
-    this._ensureImage();
-    return this.img.height;
+    return Module.heif_image_handle_get_height(this.handle);
 };
 
 HeifImage.prototype.is_primary = function() {
-    this._ensureImage();
-    return !!this.img.is_primary;
+    return !!Module.heif_image_handle_is_primary_image(this.handle);
+}
+
+HeifImage.prototype.has_alpha_channel = function() {
+    return !!Module.heif_image_handle_has_alpha_channel(this.handle);
+}
+
+HeifImage.prototype.is_premultiplied_alpha = function() {
+    return !!Module.heif_image_handle_is_premultiplied_alpha(this.handle);
 }
 
 HeifImage.prototype.display = function(image_data, callback) {
@@ -56,64 +66,40 @@ HeifImage.prototype.display = function(image_data, callback) {
     var w = this.get_width();
     var h = this.get_height();
 
-    setTimeout(function() {
-        this._ensureImage();
+    setTimeout(async function() {
+
+        // If image hasn't been loaded yet, decode the image
+
         if (!this.img) {
-            // Decoding failed.
-            callback(null);
-            return;
-        }
+            var img = await Module.heif_js_decode_image2(this.handle,
+              Module.heif_colorspace.heif_colorspace_RGB, Module.heif_chroma.heif_chroma_interleaved_RGBA);
+            if (!img || img.code) {
+                console.log("Decoding image failed", this.handle, img);
 
-        var yval;
-        var uval;
-        var vval;
-        var xpos = 0;
-        var ypos = 0;
-        var yoffset = 0;
-        var uoffset = 0;
-        var voffset = 0;
-        var x2;
-        var i = 0;
-        var maxi = w*h;
-        var stridey = w;
-        var strideu = Math.ceil(w / 2);
-        var stridev = Math.ceil(w / 2);
-        var h2 = Math.ceil(h / 2);
-        var y = this.data;
-        var u = this.data.subarray(stridey * h, stridey * h + (strideu * h2));
-        var v = this.data.subarray(stridey * h + (strideu * h2), stridey * h + (strideu * h2) + (stridev * h2));
-        var dest = image_data.data;
-        while (i < maxi) {
-            x2 = (xpos >> 1);
-            yval = 1.164 * (y[yoffset + xpos] - 16);
-
-            uval = u[uoffset + x2] - 128;
-            vval = v[voffset + x2] - 128;
-            dest[(i<<2)+0] = yval + 1.596 * vval;
-            dest[(i<<2)+1] = yval - 0.813 * vval - 0.391 * uval;
-            dest[(i<<2)+2] = yval + 2.018 * uval;
-            dest[(i<<2)+3] = 0xff;
-            i++;
-            xpos++;
-
-            if (xpos < w) {
-                yval = 1.164 * (y[yoffset + xpos] - 16);
-                dest[(i<<2)+0] = yval + 1.596 * vval;
-                dest[(i<<2)+1] = yval - 0.813 * vval - 0.391 * uval;
-                dest[(i<<2)+2] = yval + 2.018 * uval;
-                dest[(i<<2)+3] = 0xff;
-                i++;
-                xpos++;
+                callback(null);
+                return;
             }
 
-            if (xpos === w) {
-                xpos = 0;
-                ypos++;
-                yoffset += stridey;
-                uoffset = ((ypos >> 1) * strideu);
-                voffset = ((ypos >> 1) * stridev);
+            for (let c of img.channels) {
+                if (c.id == Module.heif_channel.heif_channel_interleaved) {
+
+                    // copy image into output array
+
+                    if (c.stride == c.width * 4) {
+                        image_data.data.set(c.data);
+                    } else {
+                        for (let y = 0; y < c.height; y++) {
+                            let slice = c.data.slice(y * c.stride, y * c.stride + c.width * 4);
+                            let offset = y * c.width * 4;
+                            image_data.data.set(slice, offset);
+                        }
+                    }
+                }
             }
+
+            Module.heif_image_release(img.image);
         }
+
         callback(image_data);
     }.bind(this), 0);
 };
@@ -124,32 +110,31 @@ var HeifDecoder = function() {
 
 HeifDecoder.prototype.decode = function(buffer) {
     if (this.decoder) {
-        libheif.heif_context_free(this.decoder);
+        Module.heif_context_free(this.decoder);
     }
-    this.decoder = libheif.heif_context_alloc();
+    this.decoder = Module.heif_context_alloc();
     if (!this.decoder) {
         console.log("Could not create HEIF context");
         return [];
     }
-    var error = libheif.heif_context_read_from_memory(this.decoder, buffer);
-    if (error.code !== libheif.heif_error_Ok) {
-        console.log("Could not parse HEIF file", error);
+    var error = Module.heif_context_read_from_memory(this.decoder, buffer);
+    if (error.code !== Module.heif_error_code.heif_error_Ok) {
+        console.log("Could not parse HEIF file", error.message);
         return [];
     }
 
-    var ids = libheif.heif_js_context_get_list_of_top_level_image_IDs(this.decoder);
+    var ids = Module.heif_js_context_get_list_of_top_level_image_IDs(this.decoder);
     if (!ids || ids.code) {
         console.log("Error loading image ids", ids);
         return [];
-    }
-    else if (!ids.length) {
+    } else if (!ids.length) {
         console.log("No images found");
         return [];
     }
 
     var result = [];
     for (var i = 0; i < ids.length; i++) {
-        var handle = libheif.heif_js_context_get_image_handle(this.decoder, ids[i]);
+        var handle = Module.heif_js_context_get_image_handle(this.decoder, ids[i]);
         if (!handle || handle.code) {
             console.log("Could not get image data for id", ids[i], handle);
             continue;
@@ -160,95 +145,39 @@ HeifDecoder.prototype.decode = function(buffer) {
     return result;
 };
 
-var libheif = {
-    // Expose high-level API.
-    /** @expose */
-    HeifDecoder: HeifDecoder,
-
-    // Expose low-level API.
-    /** @expose */
-    fourcc: function(s) {
-        return s.charCodeAt(0) << 24 |
-            s.charCodeAt(1) << 16 |
-            s.charCodeAt(2) << 8 |
-            s.charCodeAt(3);
-    }
-};
+var fourcc = function(s) {
+    return s.charCodeAt(0) << 24 |
+      s.charCodeAt(1) << 16 |
+      s.charCodeAt(2) << 8 |
+      s.charCodeAt(3);
+}
 
-var key;
+Module.HeifImage = HeifImage;
+Module.HeifDecoder = HeifDecoder;
+Module.fourcc = fourcc;
 
 // Expose enum values.
-var enums = {
-    "heif_error_code": true,
-    "heif_suberror_code": true,
-    "heif_compression_format": true,
-    "heif_chroma": true,
-    "heif_colorspace": true,
-    "heif_channel": true
-};
-var e;
-for (e in enums) {
-    if (!enums.hasOwnProperty(e)) {
-        continue;
-    }
-    for (key in Module[e]) {
-        if (!Module[e].hasOwnProperty(key) ||
-            key === "values") {
+const enums = [
+    'heif_error_code',
+    'heif_suberror_code',
+    'heif_compression_format',
+    'heif_chroma',
+    'heif_colorspace',
+    'heif_channel'
+];
+for (const e of enums) {
+    for (const key in Module[e]) {
+        if (!Module[e].hasOwnProperty(key) || key === 'values') {
             continue;
         }
-
-        libheif[key] = Module[e][key];
+        Module[key] = Module[e][key];
     }
 }
 
 // Expose internal C API.
-for (key in Module) {
-    if (enums.hasOwnProperty(key) || key.indexOf("heif_") !== 0) {
+for (const key in Module) {
+    if (key.indexOf('_heif_') !== 0 || Module[key.slice(1)] !== undefined) {
         continue;
     }
-    libheif[key] = Module[key];
-}
-
-// don't pollute the global namespace
-delete this['Module'];
-
-// On IE this function is called with "undefined" as first parameter. Override
-// with a version that supports this behaviour.
-function createNamedFunction(name, body) {
-    if (!name) {
-      name = "function_" + (new Date());
-    }
-    name = makeLegalFunctionName(name);
-    /*jshint evil:true*/
-    return new Function(
-        "body",
-        "return function " + name + "() {\n" +
-        "    \"use strict\";" +
-        "    return body.apply(this, arguments);\n" +
-        "};\n"
-    )(body);
+    Module[key.slice(1)] = Module[key];
 }
-
-var root = this;
-
-if (typeof exports !== 'undefined') {
-    if (typeof module !== 'undefined' && module.exports) {
-        /** @expose */
-        exports = module.exports = libheif;
-    }
-    /** @expose */
-    exports.libheif = libheif;
-} else {
-    /** @expose */
-    root.libheif = libheif;
-}
-
-if (typeof define === "function" && define.amd) {
-    /** @expose */
-    define([], function() {
-        return libheif;
-    });
-}
-
-// NOTE: wrapped inside "(function() {" block from pre.js
-}).call(this);
diff --git a/pre.js b/pre.js
deleted file mode 100644
index 25e608e583..0000000000
--- a/pre.js
+++ /dev/null
@@ -1,33 +0,0 @@
-/**
- * @preserve libheif.js HEIF decoder
- * (c)2017 struktur AG, http://www.struktur.de, opensource@struktur.de
- *
- * This file is part of libheif
- * https://github.com/strukturag/libheif
- *
- * libheif is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as
- * published by the Free Software Foundation, either version 3 of
- * the License, or (at your option) any later version.
- *
- * libheif is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
- */
-(function() {
-var Module = {
-    print: function(text) {
-        text = Array.prototype.slice.call(arguments).join(' ');
-        console.log(text);
-    },
-    printErr: function(text) {
-        text = Array.prototype.slice.call(arguments).join(' ');
-        console.error(text);
-    },
-    canvas: {},
-    noInitialRun: true
-};
diff --git a/scripts/Makefile.am b/scripts/Makefile.am
deleted file mode 100644
index a8e36a1aef..0000000000
--- a/scripts/Makefile.am
+++ /dev/null
@@ -1,14 +0,0 @@
-EXTRA_DIST = \
-    pre-commit.hook \
-    check-emscripten-enums.sh \
-    check-go-enums.sh \
-    check-gofmt.sh \
-    check-licenses.sh \
-    install-clang.sh \
-    install-ci-linux.sh \
-    install-ci-osx.sh \
-    install-emscripten.sh \
-    prepare-ci.sh \
-    run-ci.sh \
-    cpplint.py \
-    test-javascript.js
diff --git a/scripts/build-android-libs.sh b/scripts/build-android-libs.sh
new file mode 100755
index 0000000000..a0f029d2f8
--- /dev/null
+++ b/scripts/build-android-libs.sh
@@ -0,0 +1,78 @@
+#!/bin/bash
+#
+# HEIF codec.
+# Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+#
+# This file is part of libheif.
+#
+# libheif is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# libheif is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+
+# This script builds binaries for all Android architectures. They are placed in the directory 'out'.
+# The script should be run in the root directory of the libheif sources.
+
+# The configuration below builds libheif with heic decoding only.
+
+# Set these variables to suit your needs
+NDK_PATH= ... # for example .../android-sdk/sdk/ndk/25.1.8937393
+TOOLCHAIN=clang
+ANDROID_VERSION=24 # the minimum version of Android to support
+
+function build {
+    mkdir -p build/$1
+    cd build/$1
+    cmake -G"Unix Makefiles" \
+	  -DCMAKE_ASM_FLAGS="--target=arm-linux-androideabi${ANDROID_VERSION}" \
+	  -DCMAKE_TOOLCHAIN_FILE=${NDK_PATH}/build/cmake/android.toolchain.cmake \
+	  -DANDROID_ABI=$1 \
+	  -DANDROID_ARM_MODE=arm \
+	  -DANDROID_PLATFORM=android-${ANDROID_VERSION} \
+	  -DANDROID_TOOLCHAIN=${TOOLCHAIN} \
+    	  -DENABLE_PLUGIN_LOADING=OFF \
+	  -DBUILD_TESTING=OFF \
+	  -DWITH_AOM_DECODER=OFF \
+	  -DWITH_AOM_DECODER_PLUGIN=OFF \
+	  -DWITH_AOM_ENCODER=OFF \
+	  -DWITH_DAV1D=OFF \
+	  -DWITH_DEFLATE_HEADER_COMPRESSION=OFF \
+	  -DWITH_EXAMPLES=OFF \
+	  -DWITH_GDK_PIXBUF=OFF \
+	  -DWITH_LIBDE265=ON \
+	  -DWITH_LIBDE265_PLUGIN=OFF \
+	  -DWITH_RAV1E=OFF \
+	  -DWITH_SvtEnc=OFF \
+	  -DWITH_X265=OFF \
+	  -DCMAKE_INSTALL_PREFIX=../../out/$1 \
+	  -DCMAKE_BUILD_TYPE=Release \
+	  -Dld-version-script=OFF \
+	  ../..
+
+    make VERBOSE=1
+    make install
+    cd ../..
+
+    mkdir -p out/$1
+}
+
+rm -rf build out
+
+
+build armeabi-v7a ON
+build arm64-v8a ON
+build x86 OFF
+build x86_64 OFF
+
+rm -rf build
+rm -rf out/*/share
diff --git a/scripts/build-oss-fuzz.sh b/scripts/build-oss-fuzz.sh
new file mode 100755
index 0000000000..fa6394006e
--- /dev/null
+++ b/scripts/build-oss-fuzz.sh
@@ -0,0 +1,134 @@
+#!/bin/bash -e
+#
+# HEIF codec.
+# Copyright (c) 2026 struktur AG, Joachim Bauch <bauch@struktur.de>
+#
+# This file is part of libheif.
+#
+# libheif is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# libheif is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+if [ -z "$SRC" ]; then
+	echo "Environment variable SRC is not defined."
+	exit 1
+elif [ -z "$OUT" ]; then
+	echo "Environment variable OUT is not defined."
+	exit 1
+elif [ -z "$WORK" ]; then
+	echo "Environment variable WORK is not defined."
+	exit 1
+fi
+
+# Install build dependencies.
+
+apt-get update
+
+apt-get install -y \
+		autoconf \
+		automake \
+		build-essential \
+		cmake \
+		libbrotli-dev \
+		libtool \
+		make \
+		mercurial \
+		pkg-config \
+		yasm \
+		zlib1g-dev
+
+# Install and build codec dependencies.
+
+git clone \
+		--depth 1 \
+		--branch master \
+		https://github.com/strukturag/libde265.git \
+		"$WORK/libde265"
+
+git clone \
+		https://bitbucket.org/multicoreware/x265_git/src/stable/ \
+		"$WORK/x265"
+
+git clone \
+		--depth 1 \
+		--branch master \
+		https://aomedia.googlesource.com/aom \
+		"$WORK/aom"
+
+export DEPS_PATH="$SRC/deps"
+mkdir -p "$DEPS_PATH"
+
+cd "$WORK/x265/build/linux"
+cmake -G "Unix Makefiles" \
+	-DCMAKE_C_COMPILER="$CC" -DCMAKE_CXX_COMPILER="$CXX" \
+	-DCMAKE_C_FLAGS="$CFLAGS" -DCMAKE_CXX_FLAGS="$CXXFLAGS" \
+	-DCMAKE_INSTALL_PREFIX="$DEPS_PATH" \
+	-DENABLE_SHARED:bool=off \
+	../../source
+make clean
+make -j"$(nproc)" x265-static
+make install
+
+cd "$WORK/libde265"
+./autogen.sh
+./configure \
+	--prefix="$DEPS_PATH" \
+	--disable-shared \
+	--enable-static \
+	--disable-dec265 \
+	--disable-sherlock265 \
+	--disable-hdrcopy \
+	--disable-enc265 \
+	--disable-acceleration_speed
+make clean
+make -j"$(nproc)"
+make install
+
+mkdir -p "$WORK/aom/build/linux"
+cd "$WORK/aom/build/linux"
+cmake -G "Unix Makefiles" \
+	-DCMAKE_C_COMPILER="$CC" -DCMAKE_CXX_COMPILER="$CXX" \
+	-DCMAKE_C_FLAGS="$CFLAGS" -DCMAKE_CXX_FLAGS="$CXXFLAGS" \
+	-DCMAKE_INSTALL_PREFIX="$DEPS_PATH" \
+	-DENABLE_SHARED:bool=off -DCONFIG_PIC=1 \
+	-DENABLE_EXAMPLES=0 -DENABLE_DOCS=0 -DENABLE_TESTS=0 \
+	-DCONFIG_SIZE_LIMIT=1 \
+	-DDECODE_HEIGHT_LIMIT=12288 -DDECODE_WIDTH_LIMIT=12288 \
+	-DDO_RANGE_CHECK_CLAMP=1 \
+	-DAOM_MAX_ALLOCABLE_MEMORY=536870912 \
+	-DAOM_TARGET_CPU=generic \
+	../../
+make clean
+make -j"$(nproc)"
+make install
+
+# Remove shared libraries to avoid accidental linking against them.
+rm -f "$DEPS_PATH/lib"/*.so
+rm -f "$DEPS_PATH/lib/"*.so.*
+
+cd "$SRC/libheif"
+mkdir build
+cd build
+PKG_CONFIG="pkg-config --static" PKG_CONFIG_PATH="$DEPS_PATH/lib/pkgconfig" cmake .. --preset=fuzzing \
+	-DFUZZING_COMPILE_OPTIONS="" \
+	-DFUZZING_LINKER_OPTIONS="$LIB_FUZZING_ENGINE" \
+	-DFUZZING_C_COMPILER="$CC" -DFUZZING_CXX_COMPILER="$CXX" \
+	-DWITH_DEFLATE_HEADER_COMPRESSION=OFF
+
+make -j"$(nproc)"
+
+cp fuzzing/*_fuzzer "$OUT"
+cp ../fuzzing/data/dictionary.txt "$OUT/box-fuzzer.dict"
+cp ../fuzzing/data/dictionary.txt "$OUT/file-fuzzer.dict"
+
+zip -r "$OUT/file-fuzzer_seed_corpus.zip" ../fuzzing/data/corpus/*.heic
diff --git a/scripts/check-emscripten-enums.sh b/scripts/check-emscripten-enums.sh
index 5c2d5486c6..b82a732eed 100755
--- a/scripts/check-emscripten-enums.sh
+++ b/scripts/check-emscripten-enums.sh
@@ -29,16 +29,18 @@ DEFINE_TYPES="
     heif_channel_
     "
 
+HEADERS="libheif/api/libheif/heif_error.h libheif/api/libheif/heif_image.h libheif/api/libheif/heif_context.h libheif/api/libheif/heif_color.h"
+
 API_DEFINES=""
 for type in $DEFINE_TYPES; do
-    DEFINES=$(grep "^[ \t]*$type" libheif/heif.h | sed 's|[[:space:]]*\([^ \t=]*\)[[:space:]]*=.*|\1|g')
+    DEFINES=$(grep -h "^[ \t]*$type" $HEADERS | sed 's|[[:space:]]*\([^ \t=]*\)[[:space:]]*=.*|\1|g')
     if [ -z "$API_DEFINES" ]; then
         API_DEFINES="$DEFINES"
     else
         API_DEFINES="$API_DEFINES
 $DEFINES"
     fi
-    ALIASES=$(grep "^[ \t]*#define $type" libheif/heif.h | sed 's|[[:space:]]*#define \([^ \t]*\)[[:space:]]*.*|\1|g')
+    ALIASES=$(grep -h "^[ \t]*#define $type" $HEADERS | sed 's|[[:space:]]*#define \([^ \t]*\)[[:space:]]*.*|\1|g')
     if [ ! -z "$ALIASES" ]; then
         API_DEFINES="$API_DEFINES
 $ALIASES"
@@ -48,7 +50,7 @@ API_DEFINES=$(echo "$API_DEFINES" | sort)
 
 EMSCRIPTEN_DEFINES=""
 for type in $DEFINE_TYPES; do
-    DEFINES=$(grep "\.value(\"$type" libheif/heif_emscripten.h | sed 's|[^\"]*\"\(.*\)\".*|\1|g')
+    DEFINES=$(grep "\.value(\"$type" libheif/api/libheif/heif_emscripten.h | sed 's|[^\"]*\"\(.*\)\".*|\1|g')
     if [ -z "$EMSCRIPTEN_DEFINES" ]; then
         EMSCRIPTEN_DEFINES="$DEFINES"
     else
diff --git a/scripts/check-go-enums.sh b/scripts/check-go-enums.sh
index d77f3e7576..db367df6c7 100755
--- a/scripts/check-go-enums.sh
+++ b/scripts/check-go-enums.sh
@@ -29,16 +29,18 @@ DEFINE_TYPES="
     heif_channel_
     "
 
+HEADERS="libheif/api/libheif/heif_error.h libheif/api/libheif/heif_image.h libheif/api/libheif/heif_context.h libheif/api/libheif/heif_color.h"
+
 API_DEFINES=""
 for type in $DEFINE_TYPES; do
-    DEFINES=$(grep "^[ \t]*$type" libheif/heif.h | sed 's|[[:space:]]*\([^ \t=]*\)[[:space:]]*=.*|\1|g')
+    DEFINES=$(grep -h "^[ \t]*$type" $HEADERS | sed 's|[[:space:]]*\([^ \t=]*\)[[:space:]]*=.*|\1|g')
     if [ -z "$API_DEFINES" ]; then
         API_DEFINES="$DEFINES"
     else
         API_DEFINES="$API_DEFINES
 $DEFINES"
     fi
-    ALIASES=$(grep "^[ \t]*#define $type" libheif/heif.h | sed 's|[[:space:]]*#define \([^ \t]*\)[[:space:]]*.*|\1|g')
+    ALIASES=$(grep -h "^[ \t]*#define $type" $HEADERS | sed 's|[[:space:]]*#define \([^ \t]*\)[[:space:]]*.*|\1|g')
     if [ ! -z "$ALIASES" ]; then
         API_DEFINES="$API_DEFINES
 $ALIASES"
diff --git a/scripts/check-licenses.sh b/scripts/check-licenses.sh
index 486cee70b2..cd39ecda27 100755
--- a/scripts/check-licenses.sh
+++ b/scripts/check-licenses.sh
@@ -21,7 +21,7 @@ set -eu
 #
 
 echo "Checking licenses..."
-CHECK_RESULT=`/usr/bin/licensecheck --recursive --ignore 'emscripten|libde265|README\.md|post\.js|/.git/' .`
+CHECK_RESULT=`/usr/bin/licensecheck --recursive --ignore 'emscripten|libde265|README\.md|post\.js|/.git/|clusterfuzz-testcase-.*|fuzzing/data/.*' .`
 
 FOUND=
 while read -r line; do
diff --git a/scripts/cpplint.py b/scripts/cpplint.py
index 0d4a799d56..e260dea3da 100755
--- a/scripts/cpplint.py
+++ b/scripts/cpplint.py
@@ -577,7 +577,7 @@ def ParseNolintSuppressions(filename, raw_line, linenum, error):
                 'Unknown NOLINT error category: %s' % category)
 
 
-def ProcessGlobalSuppresions(lines):
+def ProcessGlobalSuppressions(lines):
   """Updates the list of global error suppressions.
 
   Parses any lint directives in the file that have global effect.
@@ -605,7 +605,7 @@ def IsErrorSuppressedByNolint(category, linenum):
   """Returns true if the specified error category is suppressed on this line.
 
   Consults the global error_suppressions map populated by
-  ParseNolintSuppressions/ProcessGlobalSuppresions/ResetNolintSuppressions.
+  ParseNolintSuppressions/ProcessGlobalSuppressions/ResetNolintSuppressions.
 
   Args:
     category: str, the category of the error.
@@ -3237,7 +3237,7 @@ def CheckOperatorSpacing(filename, clean_lines, linenum, error):
   elif not Match(r'#.*include', line):
     # Look for < that is not surrounded by spaces.  This is only
     # triggered if both sides are missing spaces, even though
-    # technically should should flag if at least one side is missing a
+    # technically it should flag if at least one side is missing a
     # space.  This is done to avoid some false positives with shifts.
     match = Match(r'^(.*[^\s<])<[^\s=<,]', line)
     if match:
@@ -5784,7 +5784,7 @@ def ProcessFileData(filename, file_extension, lines, error,
   ResetNolintSuppressions()
 
   CheckForCopyright(filename, lines, error)
-  ProcessGlobalSuppresions(lines)
+  ProcessGlobalSuppressions(lines)
   RemoveMultiLineComments(filename, lines, error)
   clean_lines = CleansedLines(lines)
 
diff --git a/scripts/encode-all-sequences.sh b/scripts/encode-all-sequences.sh
new file mode 100755
index 0000000000..b3f8ad599b
--- /dev/null
+++ b/scripts/encode-all-sequences.sh
@@ -0,0 +1,81 @@
+#!/bin/bash
+#
+# HEIF codec.
+# Copyright (c) 2025 Dirk Farin <dirk.farin@gmail.com>
+#
+# This file is part of libheif.
+#
+# libheif is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# libheif is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+if [ "$#" -ne 1 ]; then
+    echo "Usage: pass name of first (PNG) image (with alpha) as only argument"
+    exit 5
+fi
+
+input_images=$1
+
+for enc in "--hevc -e x265" \
+	   "--hevc -e kvazaar" \
+	   "--avc -e x264" \
+	   "--vvc -e vvenc" \
+	   "--vvc -e uvg266" \
+	   "--avif -e aom" \
+	   "--avif -e svt" \
+	   "--avif -e rav1e" \
+	   "--jpeg -e jpeg" \
+	   "--jpeg2000 -e openjpeg" \
+	   "--htj2k -e openjph" \
+	   "--uncompressed -e uncompressed" ;
+do
+    format=${enc#--}        # remove leading --
+    format="${format%% *}"  # stop at whitespace
+    codec="${enc##* }"      # extract last word
+
+    if [[ $format == "avif" ]] ; then
+	suffix="avif"
+    elif [[ $format == "hevc" ]] ; then
+	suffix="heics"
+    else
+	suffix="heif"
+    fi
+    
+    for alpha in "alpha" "noalpha" ; do
+	if [[ $alpha == "alpha" ]] ; then
+	    alpha_arg=""
+	else
+	    alpha_arg="--no-alpha"
+	fi
+
+	for loop in "loop" "once" ; do
+	    if [[ $loop == "once" ]] ; then
+		loop_arg=""
+	    else
+		loop_arg="--repetitions infinite"
+	    fi
+	    
+	    echo "----- format: ${format}, encoder: ${codec}, ${alpha}, ${loop} -----"
+
+	    if [[ $format == "hevc" || $format == "avc" || $format == "vvc" || $format == "avif" ]] ; then
+		for pred in "i" "p" "b" ; do
+		    ./examples/heif-enc -S $input_images -o ${alpha}-${format}-${pred}-${codec}-${loop}.$suffix $enc $alpha_arg $loop_arg --gop-structure $pred
+		done
+	    else
+		./examples/heif-enc -S $input_images -o ${alpha}-${format}-${codec}-${loop}.$suffix $enc $alpha_arg $loop_arg
+	    fi
+	done
+	
+    done
+    
+done
diff --git a/scripts/install-ci-linux.sh b/scripts/install-ci-linux.sh
index 7a05065bfa..38c60c6d5d 100755
--- a/scripts/install-ci-linux.sh
+++ b/scripts/install-ci-linux.sh
@@ -22,7 +22,7 @@ set -e
 
 ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")" >/dev/null 2>&1 && pwd)"
 
-INSTALL_PACKAGES=
+INSTALL_PACKAGES="gdb "
 REMOVE_PACKAGES=
 BUILD_ROOT=$ROOT/..
 UPDATE_APT=
@@ -55,6 +55,14 @@ if [ "$WITH_LIBDE265" = "2" ]; then
         --disable-acceleration_speed
     make -j $(nproc) && make -j $(nproc) install
     popd
+
+    ls -lR $BUILD_ROOT/libde265/dist
+fi
+
+if [ "$WITH_LIBDE265" = "3" ]; then
+    INSTALL_PACKAGES="$INSTALL_PACKAGES \
+        libde265-dev \
+        "
 fi
 
 if [ "$WITH_AOM" = "1" ]; then
@@ -105,26 +113,38 @@ if [ ! -z "$WITH_GRAPHICS" ]; then
         libgdk-pixbuf2.0-dev \
         libjpeg-dev \
         libpng-dev \
+        libtiff-dev \
+        "
+fi
+
+if [ ! -z "$WITH_UNCOMPRESSED_CODEC" ]; then
+    INSTALL_PACKAGES="$INSTALL_PACKAGES \
+        libbrotli-dev \
+        zlib-dev \
         "
 fi
 
 if [ "$MINGW" == "32" ]; then
     sudo dpkg --add-architecture i386
+    sudo apt-get update
     INSTALL_PACKAGES="$INSTALL_PACKAGES \
         binutils-mingw-w64-i686 \
         g++-mingw-w64-i686 \
         gcc-mingw-w64-i686 \
         mingw-w64-i686-dev \
+        libz-mingw-w64-dev \
+        libz-mingw-w64 \
         wine-stable \
         wine32 \
         "
-    UPDATE_APT=1
 elif [ "$MINGW" == "64" ]; then
     INSTALL_PACKAGES="$INSTALL_PACKAGES \
         binutils-mingw-w64-x86-64 \
         g++-mingw-w64-x86-64 \
         gcc-mingw-w64-x86-64 \
         mingw-w64-x86-64-dev \
+        libz-mingw-w64-dev \
+        libz-mingw-w64 \
         wine-stable \
         "
 fi
@@ -185,15 +205,15 @@ if [ "$WITH_DAV1D" = "1" ]; then
 
     export PATH="$PATH:$HOME/.local/bin"
     cd third-party
-    sh dav1d.cmd -Denable_avx512=false
+    sh -e dav1d.cmd # dav1d does not support this option anymore: -Denable_avx512=false
     cd ..
 fi
 
 if [ "$WITH_RAV1E" = "1" ]; then
-    cargo install --force cargo-c
+    cargo install --force cargo-c@0.9.14+cargo-0.66
 
     export PATH="$PATH:$HOME/.cargo/bin"
     cd third-party
-    sh rav1e.cmd
+    sh -e rav1e.cmd
     cd ..
 fi
diff --git a/scripts/install-clang.sh b/scripts/install-clang.sh
index 279311c3b1..f275d3f601 100755
--- a/scripts/install-clang.sh
+++ b/scripts/install-clang.sh
@@ -23,7 +23,7 @@ set -e
 # Use script from https://chromium.googlesource.com/chromium/src/tools/clang/
 # to download prebuilt version of clang. This commit defines which version of
 # the script should be used (and thus defines the version of clang).
-COMMIT_HASH=f30572cab0ed7d31dc5547e709670ac9d252c6c0
+COMMIT_HASH=55676aed71dd450595d83f107d24cb31c00160b3
 
 DEST=$1
 
diff --git a/scripts/install-emscripten.sh b/scripts/install-emscripten.sh
index 87eb8c9e4b..066c77f463 100755
--- a/scripts/install-emscripten.sh
+++ b/scripts/install-emscripten.sh
@@ -32,11 +32,13 @@ if [ ! -d emsdk ]; then
 fi
 
 cd emsdk
-echo "Updating SDK ..."
+echo "Updating SDK base to ${VERSION} ..."
+git checkout main
 git pull --verbose
+git checkout ${VERSION}
 
-echo "Installing SDK version ${VERSION} ..."
-./emsdk install sdk-fastcomp-${VERSION}-64bit
+echo "Installing SDK version latest ..."
+./emsdk install ${VERSION}
 
-echo "Activating SDK version ${VERSION} ..."
-./emsdk activate sdk-fastcomp-${VERSION}-64bit
+echo "Activating SDK version latest ..."
+./emsdk activate ${VERSION}
diff --git a/scripts/prepare-ci.sh b/scripts/prepare-ci.sh
index 94eabc855d..b5aa00855c 100755
--- a/scripts/prepare-ci.sh
+++ b/scripts/prepare-ci.sh
@@ -40,41 +40,11 @@ if [ ! -z "$PKG_CONFIG_PATH" ]; then
     export PKG_CONFIG_PATH="$PKG_CONFIG_PATH"
 fi
 
-CONFIGURE_HOST=
-if [ "$MINGW" == "32" ]; then
-    CONFIGURE_HOST=i686-w64-mingw32
-elif [ "$MINGW" == "64" ]; then
-    CONFIGURE_HOST=x86_64-w64-mingw32
-fi
-
-if [ -z "$CHECK_LICENSES" ] && [ -z "$CPPLINT" ] && [ -z "$CMAKE" ]; then
-    ./autogen.sh
-    CONFIGURE_ARGS=
-    if [ -z "$CONFIGURE_HOST" ]; then
-        if [ ! -z "$FUZZER" ]; then
-            export CC="$BUILD_ROOT/clang/bin/clang"
-            export CXX="$BUILD_ROOT/clang/bin/clang++"
-            FUZZER_FLAGS="-fsanitize=fuzzer-no-link,address,shift,integer -fno-sanitize-recover=shift,integer"
-            export CFLAGS="$CFLAGS -g -O0 $FUZZER_FLAGS"
-            export CXXFLAGS="$CXXFLAGS -g -O0 $FUZZER_FLAGS"
-            CONFIGURE_ARGS="$CONFIGURE_ARGS --enable-libfuzzer=-fsanitize=fuzzer"
-        fi
-    else
-        # Make sure the correct compiler will be used.
-        unset CC
-        unset CXX
-        CONFIGURE_ARGS="$CONFIGURE_ARGS --host=$CONFIGURE_HOST"
-    fi
-    if [ ! -z "$GO" ]; then
-        CONFIGURE_ARGS="$CONFIGURE_ARGS --prefix=$BUILD_ROOT/dist --disable-gdk-pixbuf"
-    else
-        CONFIGURE_ARGS="$CONFIGURE_ARGS --disable-go"
-    fi
-    if [ ! -z "$TESTS" ]; then
-        CONFIGURE_ARGS="$CONFIGURE_ARGS --enable-tests"
-    fi
-    if [ "$WITH_RAV1E" = "1" ]; then
-        CONFIGURE_ARGS="$CONFIGURE_ARGS --enable-local-rav1e"
-    fi
-    ./configure $CONFIGURE_ARGS
-fi
+# This was used with autotools, but not work cmake
+#
+#CONFIGURE_HOST=
+#if [ "$MINGW" == "32" ]; then
+#    CONFIGURE_HOST=i686-w64-mingw32
+#elif [ "$MINGW" == "64" ]; then
+#    CONFIGURE_HOST=x86_64-w64-mingw32
+#fi
diff --git a/scripts/run-ci.sh b/scripts/run-ci.sh
index 70a55bf014..7461fdf29b 100755
--- a/scripts/run-ci.sh
+++ b/scripts/run-ci.sh
@@ -67,21 +67,20 @@ BIN_SUFFIX=
 BIN_WRAPPER=
 if [ "$MINGW" == "32" ]; then
     # Make sure the correct compiler will be used.
-    unset CC
-    unset CXX
+    export CC=i686-w64-mingw32-gcc
+    export CXX=i686-w64-mingw32-g++
     BIN_SUFFIX=.exe
-    BIN_WRAPPER=wine
-    export WINEPATH="/usr/lib/gcc/i686-w64-mingw32/7.3-posix/;/usr/i686-w64-mingw32/lib"
+    BIN_WRAPPER=/usr/lib/wine/wine
+    MINGW_SYSROOT="/usr/i686-w64-mingw32"
+    export WINEPATH="$(dirname $($CXX --print-file-name=libstdc++.a));$MINGW_SYSROOT/lib"
 elif [ "$MINGW" == "64" ]; then
     # Make sure the correct compiler will be used.
-    unset CC
-    unset CXX
+    export CC=x86_64-w64-mingw32-gcc
+    export CXX=x86_64-w64-mingw32-g++
     BIN_SUFFIX=.exe
-    BIN_WRAPPER=wine64
-    export WINEPATH="/usr/lib/gcc/x86_64-w64-mingw32/7.3-posix/;/usr/x86_64-w64-mingw32/lib"
-elif [ ! -z "$FUZZER" ]; then
-    export CC="$BUILD_ROOT/clang/bin/clang"
-    export CXX="$BUILD_ROOT/clang/bin/clang++"
+    BIN_WRAPPER=/usr/lib/wine/wine64
+    MINGW_SYSROOT="/usr/x86_64-w64-mingw32"
+    export WINEPATH="$(dirname $($CXX --print-file-name=libstdc++.a));$MINGW_SYSROOT/lib"
 fi
 
 PKG_CONFIG_PATH=
@@ -122,148 +121,175 @@ if [ ! -z "$WITH_HEIF_DECODER" ]; then
     fi
 fi
 
-if [ ! -z "$CMAKE" ]; then
-    echo "Preparing cmake build files ..."
-    CMAKE_OPTIONS=
-    if [ "$CURRENT_OS" = "osx" ] ; then
-        # Make sure the homebrew installed libraries are used when building instead
-        # of the libraries provided by Apple.
-        CMAKE_OPTIONS="$CMAKE_OPTIONS -DCMAKE_FIND_FRAMEWORK=LAST"
-    fi
-    if [ "$WITH_RAV1E" = "1" ]; then
-        CMAKE_OPTIONS="$CMAKE_OPTIONS -DUSE_LOCAL_RAV1E=1"
-    fi
 
-    cmake . $CMAKE_OPTIONS
+echo "Preparing cmake build files ..."
+
+if [ ! -z "$FUZZER" ]; then
+    CMAKE_OPTIONS="--preset=fuzzing"
+fi
+if [ ! -z "$TESTS" ]; then
+    CMAKE_OPTIONS="--preset=testing"
+fi
+if [ -z "$FUZZER" ] && [ -z "$TESTS" ]; then
+    CMAKE_OPTIONS="--preset=release -DENABLE_PLUGIN_LOADING=OFF -DWITH_OPENJPH_ENCODER=OFF"
+fi
+	
+if [ "$CURRENT_OS" = "osx" ] ; then
+    # Make sure the homebrew installed libraries are used when building instead
+    # of the libraries provided by Apple.
+    CMAKE_OPTIONS="$CMAKE_OPTIONS -DCMAKE_FIND_FRAMEWORK=LAST"
+fi
+if [ -n "$MINGW" ]; then
+    CMAKE_OPTIONS="$CMAKE_OPTIONS -DCMAKE_SYSTEM_NAME=Windows -DCMAKE_FIND_ROOT_PATH=$MINGW_SYSROOT"
 fi
+if [ "$CLANG_TIDY" = "1" ]; then
+    CMAKE_OPTIONS="$CMAKE_OPTIONS -DCMAKE_EXPORT_COMPILE_COMMANDS=ON"
+fi
+
+echo "install prefix: ${BUILD_ROOT}/dist"
+mkdir ${BUILD_ROOT}/dist
+CMAKE_OPTIONS="$CMAKE_OPTIONS -DCMAKE_INSTALL_PREFIX=${BUILD_ROOT}/dist"
+
+# turn on warnings-as-errors
+CMAKE_OPTIONS="$CMAKE_OPTIONS -DCMAKE_COMPILE_WARNING_AS_ERROR=1"
+
+# compilation mode
+CMAKE_OPTIONS="$CMAKE_OPTIONS -DCMAKE_BUILD_TYPE=Release"
+
 
 if [ ! -z "$FUZZER" ] && [ "$CURRENT_OS" = "linux" ]; then
     export ASAN_SYMBOLIZER="$BUILD_ROOT/clang/bin/llvm-symbolizer"
 fi
 
-if [ -z "$EMSCRIPTEN_VERSION" ] && [ -z "$CHECK_LICENSES" ] && [ -z "$TARBALL" ]; then
+if [ -z "$EMSCRIPTEN_VERSION" ] && [ -z "$CHECK_LICENSES" ] && [ -z "$TARBALL" ] ; then
     echo "Building libheif ..."
-    make -j $(nproc)
-    if [ "$CURRENT_OS" = "linux" ] && [ -z "$CMAKE" ] && [ -z "$MINGW" ] && [ -z "$FUZZER" ]; then
+    cmake . $CMAKE_OPTIONS
+    make VERBOSE=1 -j $(nproc)
+    if [ "$CURRENT_OS" = "linux" ] && [ -z "$MINGW" ] && [ -z "$FUZZER" ] && [ ! -z "$TESTS" ] ; then
         echo "Running tests ..."
         make test
     fi
-    echo "Dumping information of sample file ..."
-    ${BIN_WRAPPER} ./examples/heif-info${BIN_SUFFIX} --dump-boxes examples/example.heic
-    if [ ! -z "$WITH_GRAPHICS" ] && [ ! -z "$WITH_HEIF_DECODER" ]; then
-        echo "Converting sample HEIF file to JPEG ..."
-        ${BIN_WRAPPER} ./examples/heif-convert${BIN_SUFFIX} examples/example.heic example.jpg
-        echo "Checking first generated file ..."
-        [ -s "example-1.jpg" ] || exit 1
-        echo "Checking second generated file ..."
-        [ -s "example-2.jpg" ] || exit 1
-        echo "Converting sample HEIF file to PNG ..."
-        ${BIN_WRAPPER} ./examples/heif-convert${BIN_SUFFIX} examples/example.heic example.png
-        echo "Checking first generated file ..."
-        [ -s "example-1.png" ] || exit 1
-        echo "Checking second generated file ..."
-        [ -s "example-2.png" ] || exit 1
-    fi
-    if [ ! -z "$WITH_GRAPHICS" ] && [ ! -z "$WITH_AVIF_DECODER" ]; then
-        echo "Converting sample AVIF file to JPEG ..."
-        ${BIN_WRAPPER} ./examples/heif-convert${BIN_SUFFIX} examples/example.avif example.jpg
-        echo "Checking generated file ..."
-        [ -s "example.jpg" ] || exit 1
-        echo "Converting sample AVIF file to PNG ..."
-        ${BIN_WRAPPER} ./examples/heif-convert${BIN_SUFFIX} examples/example.avif example.png
-        echo "Checking generated file ..."
-        [ -s "example.png" ] || exit 1
-    fi
-    if [ ! -z "$WITH_GRAPHICS" ] && [ ! -z "$WITH_HEIF_ENCODER" ]; then
-        echo "Converting single JPEG file to heif ..."
-        ${BIN_WRAPPER} ./examples/heif-enc${BIN_SUFFIX} -o output-single.heic -v -v -v --thumb 320x240 example-1.jpg
-        echo "Checking generated file ..."
-        [ -s "output-single.heic" ] || exit 1
-        echo "Converting back generated heif to JPEG ..."
-        ${BIN_WRAPPER} ./examples/heif-convert${BIN_SUFFIX} output-single.heic output-single.jpg
-        echo "Checking generated file ..."
-        [ -s "output-single.jpg" ] || exit 1
-        echo "Converting multiple JPEG files to heif ..."
-        ${BIN_WRAPPER} ./examples/heif-enc${BIN_SUFFIX} -o output-multi.heic -v -v -v --thumb 320x240 example-1.jpg example-2.jpg
-        echo "Checking generated file ..."
-        [ -s "output-multi.heic" ] || exit 1
-        ${BIN_WRAPPER} ./examples/heif-convert${BIN_SUFFIX} output-multi.heic output-multi.jpg
-        echo "Checking first generated file ..."
-        [ -s "output-multi-1.jpg" ] || exit 1
-        echo "Checking second generated file ..."
-        [ -s "output-multi-2.jpg" ] || exit 1
-    fi
-    if [ ! -z "$WITH_GRAPHICS" ] && [ ! -z "$WITH_AVIF_ENCODER" ]; then
-        echo "Converting JPEG file to AVIF ..."
-        ${BIN_WRAPPER} ./examples/heif-enc${BIN_SUFFIX} -o output-jpeg.avif -v -v -v -A --thumb 320x240 example.jpg
-        echo "Checking generated file ..."
-        [ -s "output-jpeg.avif" ] || exit 1
-        echo "Converting back generated AVIF to JPEG ..."
-        ${BIN_WRAPPER} ./examples/heif-convert${BIN_SUFFIX} output-jpeg.avif output-jpeg.jpg
-        echo "Checking generated file ..."
-        [ -s "output-jpeg.jpg" ] || exit 1
-    fi
-    if [ ! -z "$GO" ]; then
-        echo "Installing library ..."
-        make -j $(nproc) install
+    if [ -z "$FUZZER" ] ; then
+	echo "List available encoders"
+        ${BIN_WRAPPER} ./examples/heif-enc${BIN_SUFFIX} --list-encoders
+
+	echo "List available decoders"
+        ${BIN_WRAPPER} ./examples/heif-dec${BIN_SUFFIX} --list-decoders
+
+        echo "Dumping information of sample file ..."
+        #${BIN_WRAPPER} gdb -batch -ex "run" -ex "bt" --args ./examples/heif-info${BIN_SUFFIX} --dump-boxes examples/example.heic
+        ${BIN_WRAPPER} ./examples/heif-info${BIN_SUFFIX} --dump-boxes examples/example.heic
+        if [ ! -z "$WITH_GRAPHICS" ] && [ ! -z "$WITH_HEIF_DECODER" ]; then
+            echo "Converting sample HEIF file to JPEG ..."
+            ${BIN_WRAPPER} ./examples/heif-dec${BIN_SUFFIX} examples/example.heic example.jpg
+            echo "Checking first generated file ..."
+            [ -s "example-1.jpg" ] || exit 1
+            echo "Checking second generated file ..."
+            [ -s "example-2.jpg" ] || exit 1
+            echo "Converting sample HEIF file to PNG ..."
+            ${BIN_WRAPPER} ./examples/heif-dec${BIN_SUFFIX} examples/example.heic example.png
+            echo "Checking first generated file ..."
+            [ -s "example-1.png" ] || exit 1
+            echo "Checking second generated file ..."
+            [ -s "example-2.png" ] || exit 1
+        fi
+        if [ ! -z "$WITH_GRAPHICS" ] && [ ! -z "$WITH_AVIF_DECODER" ]; then
+            echo "Converting sample AVIF file to JPEG ..."
+            ${BIN_WRAPPER} ./examples/heif-dec${BIN_SUFFIX} examples/example.avif example.jpg
+            echo "Checking generated file ..."
+            [ -s "example.jpg" ] || exit 1
+            echo "Converting sample AVIF file to PNG ..."
+            ${BIN_WRAPPER} ./examples/heif-dec${BIN_SUFFIX} examples/example.avif example.png
+            echo "Checking generated file ..."
+            [ -s "example.png" ] || exit 1
+        fi
+        if [ ! -z "$WITH_GRAPHICS" ] && [ ! -z "$WITH_HEIF_ENCODER" ]; then
+            echo "Converting single JPEG file to heif ..."
+            ${BIN_WRAPPER} ./examples/heif-enc${BIN_SUFFIX} -o output-single.heic --verbose --verbose --verbose --thumb 320x240 example-1.jpg
+            echo "Checking generated file ..."
+            [ -s "output-single.heic" ] || exit 1
+            echo "Converting back generated heif to JPEG ..."
+            ${BIN_WRAPPER} ./examples/heif-dec${BIN_SUFFIX} output-single.heic output-single.jpg
+            echo "Checking generated file ..."
+            [ -s "output-single.jpg" ] || exit 1
+            echo "Converting multiple JPEG files to heif ..."
+            ${BIN_WRAPPER} ./examples/heif-enc${BIN_SUFFIX} -o output-multi.heic --verbose --verbose --verbose --thumb 320x240 example-1.jpg example-2.jpg
+            echo "Checking generated file ..."
+            [ -s "output-multi.heic" ] || exit 1
+            ${BIN_WRAPPER} ./examples/heif-dec${BIN_SUFFIX} output-multi.heic output-multi.jpg
+            echo "Checking first generated file ..."
+            [ -s "output-multi-1.jpg" ] || exit 1
+            echo "Checking second generated file ..."
+            [ -s "output-multi-2.jpg" ] || exit 1
+        fi
+        if [ ! -z "$WITH_GRAPHICS" ] && [ ! -z "$WITH_AVIF_ENCODER" ]; then
+            echo "Converting JPEG file to AVIF ..."
+            ${BIN_WRAPPER} ./examples/heif-enc${BIN_SUFFIX} -o output-jpeg.avif --verbose --verbose --verbose -A --thumb 320x240 example.jpg
+            echo "Checking generated file ..."
+            [ -s "output-jpeg.avif" ] || exit 1
+            echo "Converting back generated AVIF to JPEG ..."
+            ${BIN_WRAPPER} ./examples/heif-dec${BIN_SUFFIX} output-jpeg.avif output-jpeg.jpg
+            echo "Checking generated file ..."
+            [ -s "output-jpeg.jpg" ] || exit 1
+        fi
+        if [ ! -z "$GO" ]; then
+            echo "Installing library ..."
+            make -j $(nproc) install
 
-        echo "Running golang example ..."
-        export GOPATH="$BUILD_ROOT/gopath"
-        export PKG_CONFIG_PATH="$BUILD_ROOT/dist/lib/pkgconfig:$BUILD_ROOT/libde265/dist/lib/pkgconfig/"
-        export LD_LIBRARY_PATH="$BUILD_ROOT/dist/lib"
-        mkdir -p "$GOPATH/src/github.com/strukturag"
-        ln -s "$BUILD_ROOT" "$GOPATH/src/github.com/strukturag/libheif"
-        go run examples/heif-test.go examples/example.heic
-        echo "Checking first generated file ..."
-        [ -s "examples/example_lowlevel.png" ] || exit 1
-        echo "Checking second generated file ..."
-        [ -s "examples/example_highlevel.png" ] || exit 1
-        echo "Checking race tester ..."
-        go run tests/test-race.go examples/example.heic
+            echo "Running golang example ..."
+            export GOPATH="$BUILD_ROOT/gopath"
+            export PKG_CONFIG_PATH="$BUILD_ROOT/dist/lib/pkgconfig:$BUILD_ROOT/libde265/dist/lib/pkgconfig/"
+            export LD_LIBRARY_PATH="$BUILD_ROOT/dist/lib:$BUILD_ROOT/libde265/dist/lib"
+            mkdir -p "$GOPATH/src/github.com/strukturag"
+            ln -s "$BUILD_ROOT" "$GOPATH/src/github.com/strukturag/libheif"
+            go run examples/heif-test.go examples/example.heic
+            echo "Checking first generated file ..."
+            [ -s "examples/example_lowlevel.png" ] || exit 1
+            echo "Checking second generated file ..."
+            [ -s "examples/example_highlevel.png" ] || exit 1
+            echo "Checking race tester ..."
+            go run tests/test-race.go examples/example.heic
+        fi
     fi
 fi
 
 if [ ! -z "$EMSCRIPTEN_VERSION" ]; then
     echo "Building with emscripten $EMSCRIPTEN_VERSION ..."
-    source ./emscripten/emsdk/emsdk_env.sh && ./build-emscripten.sh
+    source ./emscripten/emsdk/emsdk_env.sh && USE_WASM=0 ./build-emscripten.sh .
     source ./emscripten/emsdk/emsdk_env.sh && node scripts/test-javascript.js
 fi
 
 if [ ! -z "$TARBALL" ]; then
-    CONFIGURE_ARGS=
-    if [ ! -z "$GO" ]; then
-        CONFIGURE_ARGS="$CONFIGURE_ARGS --prefix=$BUILD_ROOT/dist --disable-gdk-pixbuf"
-    else
-        CONFIGURE_ARGS="$CONFIGURE_ARGS --disable-go"
-    fi
-    if [ ! -z "$TESTS" ]; then
-        CONFIGURE_ARGS="$CONFIGURE_ARGS --enable-tests"
-    fi
-    if [ "$WITH_RAV1E" = "1" ]; then
-        CONFIGURE_ARGS="$CONFIGURE_ARGS --enable-local-rav1e"
-    fi
-
-    VERSION=$(grep AC_INIT configure.ac | sed -r 's/^[^0-9]*([0-9]+\.[0-9]+\.[0-9]+).*/\1/g')
+    VERSION=$(grep project CMakeLists.txt | sed -r 's/^[^0-9]*([0-9]+\.[0-9]+\.[0-9]+).*/\1/g')
     echo "Creating tarball for version $VERSION ..."
-    make dist
+    mkdir build
+    pushd build
+    cmake .. --preset=release
+    make package_source
+    mv libheif-$VERSION.tar.gz ..
+    popd
 
     echo "Building from tarball ..."
     tar xf libheif-$VERSION.tar*
     pushd libheif-$VERSION
-    mkdir -p ./third-party/
-    ln -s $BUILD_ROOT/third-party/rav1e ./third-party/
-    ./configure $CONFIGURE_ARGS
-    make -j $(nproc)
+    mkdir build
+    pushd build
+    cmake .. --preset=release
+    make VERBOSE=1 -j $(nproc)
     popd
 fi
 
 if [ ! -z "$FUZZER" ] && [ "$CURRENT_OS" = "linux" ]; then
-    ./libheif/file-fuzzer ./fuzzing/corpus/*
+    ./fuzzing/color_conversion_fuzzer ./fuzzing/data/corpus/*color-conversion-fuzzer*
+    ./fuzzing/file_fuzzer ./fuzzing/data/corpus/*.heic
 
     echo "Running color conversion fuzzer ..."
-    ./libheif/color-conversion-fuzzer -max_total_time=120
-    echo "Running encoder fuzzer ..."
-    ./libheif/encoder-fuzzer -max_total_time=120
+    ./fuzzing/color_conversion_fuzzer -max_total_time=120
+
+    # Do not run encoder_fuzzer because it will just find errors in x265...
+    #echo "Running encoder fuzzer ..."
+    #./fuzzing/encoder_fuzzer -max_total_time=120
+    
     echo "Running file fuzzer ..."
-    ./libheif/file-fuzzer -dict=./fuzzing/dictionary.txt -max_total_time=120
+    ./fuzzing/file_fuzzer -dict=./fuzzing/data/dictionary.txt -max_total_time=120
 fi
diff --git a/scripts/test-javascript.js b/scripts/test-javascript.js
index 8b23fddfeb..a75621ef40 100644
--- a/scripts/test-javascript.js
+++ b/scripts/test-javascript.js
@@ -18,41 +18,27 @@
  * You should have received a copy of the GNU Lesser General Public License
  * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
  */
-(function() {
-
-    console.log("Running libheif JavaScript tests ...");
-
-    var libheif = require('../libheif.js');
-    console.log("Loaded libheif.js", libheif.heif_get_version());
-
-    // Ensure that no "undefined" properties are exported.
-    var key;
-    var missing = [];
-    for (key in libheif) {
-        if (!libheif.hasOwnProperty(key)) {
-            continue;
-        }
-        if (typeof(libheif[key]) === "undefined") {
-            missing.push(key);
-        }
-    }
-    if (missing.length) {
-        throw new Error("The following properties are not defined: " + missing);
-    }
-
-    // Decode the example file and make sure at least one image is returned.
-    var fs = require('fs');
-    fs.readFile('examples/example.heic', function(err, data) {
-        if (err) {
-            throw err; 
-        }
-
-        var decoder = new libheif.HeifDecoder();
-        var image_data = decoder.decode(data);
-        console.log("Loaded images:", image_data.length);
-        if (!image_data.length) {
-            throw new Error("Should have loaded images");
-        }
-    });
-
-})();
+
+const assert = require('assert');
+const fs = require('fs');
+
+console.log('Running libheif JavaScript tests ...');
+
+const libheif = require('../libheif.js')();
+
+// Test Embind API.
+console.log('Loaded libheif.js', libheif.heif_get_version());
+
+// Test internal C API.
+assert(libheif.heif_get_version_number_major() === 1, 'libheif major version should be 1')
+
+// Test enum values.
+assert(libheif.heif_error_Ok.value === 0, 'heif_error_Ok should be 0')
+
+// Decode the example file and make sure at least one image is returned.
+const data = fs.readFileSync('examples/example.heic');
+const decoder = new libheif.HeifDecoder();
+const image_data = decoder.decode(data);
+
+console.log('Loaded images:', image_data.length);
+assert(image_data.length > 0, "Should have loaded images")
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
new file mode 100644
index 0000000000..557e7424eb
--- /dev/null
+++ b/tests/CMakeLists.txt
@@ -0,0 +1,121 @@
+# Needed to find libheif/heif_version.h while compiling the library
+include_directories(${libheif_BINARY_DIR} ${libheif_SOURCE_DIR}/libheif ${libheif_SOURCE_DIR}/libheif/api)
+
+# prepare C++ configuration file (test-config.cc)
+
+set(TESTING_DATA_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/data")
+set(LIBHEIFIO_TESTING_DATA_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/data/heifio")
+configure_file(test-config.cc.in ${CMAKE_BINARY_DIR}/generated/test-config.cc)
+
+if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" OR CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    set_source_files_properties(catch_amalgamated.cpp PROPERTIES COMPILE_FLAGS -Wno-conversion)
+endif()
+
+add_library(testframework STATIC ${CMAKE_BINARY_DIR}/generated/test-config.cc test_utils.cc catch_amalgamated.cpp)
+target_link_libraries(testframework PRIVATE heif)
+
+macro(add_libheif_test TEST_FILE)
+    set(TEST_NAME ${TEST_FILE})
+    add_executable(${TEST_NAME} ${TEST_FILE}.cc)
+    target_link_libraries(${TEST_NAME} PRIVATE heif testframework)
+    add_test(NAME ${TEST_NAME} COMMAND ./${TEST_NAME})
+    set_tests_properties(${TEST_NAME} PROPERTIES SKIP_REGULAR_EXPRESSION "[1-9][0-9]* skipped")
+endmacro()
+
+macro(add_heifio_test TEST_FILE)
+    set(TEST_NAME ${TEST_FILE})
+    add_executable(${TEST_NAME} main.cc ${TEST_FILE}.cc)
+    target_link_libraries(${TEST_NAME} PRIVATE heif heifio testframework)
+    target_include_directories(${TEST_NAME} PRIVATE ${libheif_SOURCE_DIR})
+    add_test(NAME ${TEST_NAME} COMMAND ./${TEST_NAME})
+    set_tests_properties(${TEST_NAME} PROPERTIES SKIP_REGULAR_EXPRESSION "[1-9][0-9]* skipped")
+endmacro()
+
+# --- tests that require access to internal symbols
+
+if (WITH_REDUCED_VISIBILITY)
+    message(WARNING "Several unit tests have been disabled because they can only be compiled with full symbol visibility (WITH_REDUCED_VISIBILITY=OFF)")
+else()
+    add_libheif_test(bitstream_tests)
+    add_libheif_test(box_equals)
+    add_libheif_test(conversion)
+    add_libheif_test(idat)
+    add_libheif_test(jpeg2000)
+    add_libheif_test(avc_box)
+    add_libheif_test(file_layout)
+endif()
+
+if (ENABLE_EXPERIMENTAL_FEATURES AND NOT WITH_REDUCED_VISIBILITY)
+    add_libheif_test(pixel_data_types)
+endif()
+
+if (NOT WITH_REDUCED_VISIBILITY AND WITH_UNCOMPRESSED_CODEC)
+    add_libheif_test(uncompressed_box)
+endif()
+
+# --- tests that only access the public API
+
+add_libheif_test(encode)
+add_libheif_test(extended_type)
+add_libheif_test(region)
+add_libheif_test(tai)
+add_libheif_test(text)
+add_libheif_test(cxx_wrapper)
+
+if (WITH_OPENJPH_ENCODER AND SUPPORTS_J2K_HT_ENCODING)
+    add_libheif_test(encode_htj2k)
+else()
+    message(INFO "Disabling HT-JPEG 2000 encoder tests because no HT-JPEG 2000 codec is enabled")
+endif()
+
+if (WITH_OpenJPEG_ENCODER AND SUPPORTS_J2K_ENCODING)
+    add_libheif_test(encode_jpeg2000)
+else()
+    message(INFO "Disabling JPEG 2000 encoder tests because no JPEG 2000 codec is enabled")
+endif()
+
+if (ENABLE_EXPERIMENTAL_MINI_FORMAT)
+    if (NOT WITH_REDUCED_VISIBILITY)
+        add_libheif_test(mini_box)
+    endif()
+    add_libheif_test(mini_decode)
+endif()
+
+if (HEIF_WITH_OMAF)
+    if (NOT WITH_REDUCED_VISIBILITY)
+        add_libheif_test(omaf_boxes)
+    endif()
+    add_libheif_test(omaf)
+endif()
+
+if (WITH_UNCOMPRESSED_CODEC)
+    add_libheif_test(uncompressed_decode)
+    add_libheif_test(uncompressed_decode_mono)
+    add_libheif_test(uncompressed_decode_rgb)
+    add_libheif_test(uncompressed_decode_rgb16)
+    add_libheif_test(uncompressed_decode_rgb565)
+    add_libheif_test(uncompressed_decode_rgb7)
+    add_libheif_test(uncompressed_decode_ycbcr)
+    add_libheif_test(uncompressed_decode_ycbcr420)
+    add_libheif_test(uncompressed_decode_ycbcr422)
+    add_libheif_test(uncompressed_encode)
+
+    if (ENABLE_EXPERIMENTAL_FEATURES)
+        add_libheif_test(uncompressed_encode_multicomponent)
+    endif()
+
+    if (ZLIB_FOUND)
+        add_libheif_test(uncompressed_decode_generic_compression)
+    else()
+        message(WARNING "Generic compress tests of the 'uncompressed codec' are not compiled because zlib was not found")
+    endif ()
+else()
+    message(WARNING "Tests of the 'uncompressed codec' are not compiled because the uncompressed codec is not enabled (WITH_UNCOMPRESSED_CODEC==OFF)")
+endif ()
+
+add_heifio_test(tiffdecode)
+
+if (ENABLE_PLUGIN_LOADING)
+    get_directory_property(ALL_TESTS TESTS)
+    set_tests_properties(${ALL_TESTS} PROPERTIES ENVIRONMENT "LIBHEIF_PLUGIN_PATH=${CMAKE_BINARY_DIR}/libheif/plugins")
+endif ()
diff --git a/tests/Makefile.am b/tests/Makefile.am
deleted file mode 100644
index 3b1a3ed479..0000000000
--- a/tests/Makefile.am
+++ /dev/null
@@ -1,38 +0,0 @@
-noinst_PROGRAMS =
-
-if HAVE_TESTS
-noinst_PROGRAMS += \
-  heif-unit-tests
-
-heif_unit_tests_DEPENDENCIES = ../libheif/libheif.la
-heif_unit_tests_CXXFLAGS = -I$(top_srcdir) -I$(top_builddir)/.
-heif_unit_tests_LDFLAGS =
-heif_unit_tests_LDADD = ../libheif/libheif.la
-heif_unit_tests_SOURCES = main.cc encode.cc catch.hpp conversion.cc
-
-test-local: heif-unit-tests
-	./heif-unit-tests
-
-endif
-
-if HAVE_GO
-noinst_PROGRAMS += \
-	test-race
-
-test_race_SOURCES = test-race.go
-
-gopath:
-	mkdir -p ${CURDIR}/src/github.com/strukturag/libheif
-	ln -sf ${CURDIR}/../go ${CURDIR}/src/github.com/strukturag/libheif/
-
-test-race: gopath $(top_builddir)/libheif/libheif.la $(top_builddir)/libheif.pc test-race.go
-	GOPATH=${CURDIR} PKG_CONFIG_PATH=${PKG_CONFIG_PATH}:$(abs_top_builddir):$(abs_top_builddir)/libde265/dist/lib/pkgconfig/ CGO_CFLAGS="-I$(abs_top_builddir)" CGO_LDFLAGS="-L$(abs_top_builddir)/libheif/.libs" LD_LIBRARY_PATH=$(abs_top_builddir)/libheif/.libs $(GO) build -o test-race ${test_race_SOURCES}
-
-format-go: ${test_race_SOURCES}
-	$(GO) fmt ${test_race_SOURCES}
-else
-format-go:
-	echo ""go" not present in "${PATH}", skipping formatting"
-endif
-
-format-local: format-go
diff --git a/tests/avc_box.cc b/tests/avc_box.cc
new file mode 100644
index 0000000000..771ded2e97
--- /dev/null
+++ b/tests/avc_box.cc
@@ -0,0 +1,84 @@
+/*
+  libheif AVC (H.264) unit tests
+
+  MIT License
+
+  Copyright (c) 2023 Brad Hards <bradh@frogmouth.net>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#include "catch_amalgamated.hpp"
+#include "codecs/avc_boxes.h"
+#include "error.h"
+#include <cstdint>
+#include <iostream>
+#include <memory>
+
+
+TEST_CASE("avcC") {
+  std::vector<uint8_t> byteArray{
+      0x00, 0x00, 0x00, 0x34, 0x61, 0x76, 0x63, 0x43, 0x01, 0x42, 0x80,
+      0x1e, 0xff, 0xe1, 0x00, 0x1a, 0x67, 0x64, 0x00, 0x28, 0xac, 0x72,
+      0x04, 0x40, 0x40, 0x04, 0x1a, 0x10, 0x00, 0x00, 0x03, 0x00, 0x10,
+      0x00, 0x00, 0x03, 0x03, 0x20, 0xf1, 0x83, 0x18, 0x46, 0x01, 0x00,
+      0x07, 0x68, 0xe8, 0x43, 0x83, 0x92, 0xc8, 0xb0};
+
+  auto reader = std::make_shared<StreamReader_memory>(byteArray.data(),
+                                                      byteArray.size(), false);
+
+  BitstreamRange range(reader, byteArray.size());
+  std::shared_ptr<Box> box;
+  Error error = Box::read(range, &box, heif_get_global_security_limits());
+  REQUIRE(error == Error::Ok);
+  REQUIRE(range.error() == 0);
+
+  REQUIRE(box->get_short_type() == fourcc("avcC"));
+  REQUIRE(box->get_type_string() == "avcC");
+  std::shared_ptr<Box_avcC> avcC = std::dynamic_pointer_cast<Box_avcC>(box);
+  Box_avcC::configuration configuration = avcC->get_configuration();
+  REQUIRE(configuration.configuration_version == 1);
+  REQUIRE(configuration.AVCProfileIndication == 66);
+  REQUIRE(configuration.profile_compatibility == 0x80);
+  REQUIRE(configuration.AVCLevelIndication == 30);
+  REQUIRE(avcC->getSequenceParameterSets().size() == 1);
+  REQUIRE(avcC->getSequenceParameterSets()[0].size() == 0x1a);
+  REQUIRE(avcC->getPictureParameterSets().size() == 1);
+  REQUIRE(avcC->getPictureParameterSets()[0].size() == 7);
+  Indent indent;
+  std::string dumpResult = box->dump(indent);
+  REQUIRE(dumpResult == "Box: avcC -----\n"
+                        "size: 52   (header size: 8)\n"
+                        "configuration_version: 1\n"
+                        "AVCProfileIndication: 66 (Constrained Baseline)\n"
+                        "profile_compatibility: 128\n"
+                        "AVCLevelIndication: 30\n"
+                        "Chroma format: 4:2:0\n"
+                        "Bit depth luma: 8\n"
+                        "Bit depth chroma: 8\n"
+                        "SPS: 67 64 00 28 ac 72 04 40 40 04 1a 10 00 00 03 00 "
+                        "10 00 00 03 03 20 f1 83 18 46 \n"
+                        "PPS: 68 e8 43 83 92 c8 b0 \n");
+
+  StreamWriter writer;
+  Error err = avcC->write(writer);
+  REQUIRE(err.error_code == heif_error_Ok);
+  const std::vector<uint8_t> bytes = writer.get_data();
+  REQUIRE(bytes == byteArray);
+}
diff --git a/tests/bitstream_tests.cc b/tests/bitstream_tests.cc
new file mode 100644
index 0000000000..aa0309e4d8
--- /dev/null
+++ b/tests/bitstream_tests.cc
@@ -0,0 +1,86 @@
+/*
+  libheif bitstream unit tests
+
+  MIT License
+
+  Copyright (c) 2024 Brad Hards <bradh@frogmouth.net>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#include "catch_amalgamated.hpp"
+#include "error.h"
+#include <cstdint>
+#include <iostream>
+#include <memory>
+#include <bitstream.h>
+
+
+TEST_CASE("read bits") {
+  std::vector<uint8_t> byteArray{0x7f, 0xf1, 0b01000001, 0b10000111, 0b10001111};
+  BitReader uut(byteArray.data(), (int)byteArray.size());
+  uint32_t byte0 = uut.get_bits(8);
+  REQUIRE(byte0 == 0x7f);
+  uint32_t byte1_high = uut.get_bits(4);
+  REQUIRE(byte1_high == 0x0f);
+  uint32_t byte1_low = uut.get_bits(4);
+  REQUIRE(byte1_low == 0x01);
+  uint32_t byte2_partial1 = uut.get_bits(3);
+  REQUIRE(byte2_partial1 == 0x02);
+  uint32_t byte2_partial2 = uut.get_bits(3);
+  REQUIRE(byte2_partial2 == 0x00);
+  uint32_t byte2_3_overlap = uut.get_bits(11);
+  REQUIRE(byte2_3_overlap == 0b0000001100001111);
+}
+
+TEST_CASE("read uint8") {
+  std::vector<uint8_t> byteArray{0x7f, 0xf1, 0b01000001, 0b10000111, 0b10001111};
+  BitReader uut(byteArray.data(), (int)byteArray.size());
+  uint8_t byte0 = uut.get_bits8(8);
+  REQUIRE(byte0 == 0x7f);
+  uint8_t byte1_high = uut.get_bits8(4);
+  REQUIRE(byte1_high == 0x0f);
+  uint8_t byte1_low = uut.get_bits8(4);
+  REQUIRE(byte1_low == 0x01);
+  uint8_t byte2_partial1 = uut.get_bits8(3);
+  REQUIRE(byte2_partial1 == 0x02);
+  uint8_t byte2_partial2 = uut.get_bits8(3);
+  REQUIRE(byte2_partial2 == 0x00);
+  uint8_t byte2_3_overlap = uut.get_bits8(8);
+  REQUIRE((int)byte2_3_overlap == 0b1100001);
+}
+
+TEST_CASE("read uint32") {
+  std::vector<uint8_t> byteArray{0x7f, 0b11110001, 0b01000001, 0b10000111, 0b10001111};
+  BitReader uut(byteArray.data(), (int)byteArray.size());
+  uint32_t byte0 = uut.get_bits32(8);
+  REQUIRE(byte0 == 0x7f);
+  uint32_t byte1_high = uut.get_bits(1);
+  REQUIRE(byte1_high == 0x01);
+  uint32_t overlap = uut.get_bits32(30);
+  REQUIRE(overlap == 0b111000101000001100001111000111);
+}
+
+TEST_CASE("read float") {
+  std::vector<uint8_t> byteArray{0x40, 0x00, 0x00, 0x00};
+  std::shared_ptr<StreamReader_memory> stream = std::make_shared<StreamReader_memory>(byteArray.data(), (int)byteArray.size(), false);
+  BitstreamRange uut(stream, byteArray.size(), nullptr);
+  float f = uut.read_float32();
+  REQUIRE(f == 2.0);
+}
diff --git a/tests/box_equals.cc b/tests/box_equals.cc
new file mode 100644
index 0000000000..dca2a59349
--- /dev/null
+++ b/tests/box_equals.cc
@@ -0,0 +1,65 @@
+/*
+  libheif Box equality unit tests
+
+  MIT License
+
+  Copyright (c) 2024 Brad Hards <bradh@frogmouth.net>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#include "catch_amalgamated.hpp"
+#include "box.h"
+
+TEST_CASE("box equals") {
+  std::shared_ptr<Box_ispe> ispe1 = std::make_shared<Box_ispe>();
+  ispe1->set_size(100, 200);
+
+  std::shared_ptr<Box_ispe> ispe2 = std::make_shared<Box_ispe>();
+  ispe2->set_size(100, 250);
+  
+  std::shared_ptr<Box_ispe> ispe3 = std::make_shared<Box_ispe>();
+  ispe3->set_size(100, 200);
+  
+  std::shared_ptr<Box_clap> clap = std::make_shared<Box_clap>();
+  clap->set(100, 200, 150, 250);
+
+  REQUIRE(Box::equal(ispe1, ispe2) == false);
+  REQUIRE(Box::equal(ispe1, ispe3) == true);
+  REQUIRE(Box::equal(ispe3, ispe1) == true);
+  REQUIRE(Box::equal(ispe1, 0) == false);
+  REQUIRE(Box::equal(clap, ispe1) == false);
+  REQUIRE(Box::equal(0, ispe1) == false);
+}
+
+TEST_CASE("add_box") {
+  std::shared_ptr<Box_ispe> ispe1 = std::make_shared<Box_ispe>();
+  ispe1->set_size(100, 200);
+
+  std::shared_ptr<Box_ispe> ispe2 = std::make_shared<Box_ispe>();
+  ispe2->set_size(100, 250);
+  
+  std::shared_ptr<Box_ispe> ispe3 = std::make_shared<Box_ispe>();
+  ispe3->set_size(100, 200);
+  
+  std::shared_ptr<Box_ipco> ipco = std::make_shared<Box_ipco>();
+  REQUIRE(ipco->find_or_append_child_box(ispe1) == 0);
+  REQUIRE(ipco->find_or_append_child_box(ispe2) == 1);
+  REQUIRE(ipco->find_or_append_child_box(ispe3) == 0);
+}
diff --git a/tests/catch.hpp b/tests/catch.hpp
deleted file mode 100644
index 303f664ffc..0000000000
--- a/tests/catch.hpp
+++ /dev/null
@@ -1,16865 +0,0 @@
-/*
- *  Catch v2.9.1
- *  Generated: 2019-06-17 11:59:24.363643
- *  ----------------------------------------------------------
- *  This file has been merged from multiple headers. Please don't edit it directly
- *  Copyright (c) 2019 Two Blue Cubes Ltd. All rights reserved.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
-#ifndef TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
-#define TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
-// start catch.hpp
-
-
-#define CATCH_VERSION_MAJOR 2
-#define CATCH_VERSION_MINOR 9
-#define CATCH_VERSION_PATCH 1
-
-#ifdef __clang__
-#    pragma clang system_header
-#elif defined __GNUC__
-#    pragma GCC system_header
-#endif
-
-// start catch_suppress_warnings.h
-
-#ifdef __clang__
-#   ifdef __ICC // icpc defines the __clang__ macro
-#       pragma warning(push)
-#       pragma warning(disable: 161 1682)
-#   else // __ICC
-#       pragma clang diagnostic push
-#       pragma clang diagnostic ignored "-Wpadded"
-#       pragma clang diagnostic ignored "-Wswitch-enum"
-#       pragma clang diagnostic ignored "-Wcovered-switch-default"
-#    endif
-#elif defined __GNUC__
-     // Because REQUIREs trigger GCC's -Wparentheses, and because still
-     // supported version of g++ have only buggy support for _Pragmas,
-     // Wparentheses have to be suppressed globally.
-#    pragma GCC diagnostic ignored "-Wparentheses" // See #674 for details
-
-#    pragma GCC diagnostic push
-#    pragma GCC diagnostic ignored "-Wunused-variable"
-#    pragma GCC diagnostic ignored "-Wpadded"
-#endif
-// end catch_suppress_warnings.h
-#if defined(CATCH_CONFIG_MAIN) || defined(CATCH_CONFIG_RUNNER)
-#  define CATCH_IMPL
-#  define CATCH_CONFIG_ALL_PARTS
-#endif
-
-// In the impl file, we want to have access to all parts of the headers
-// Can also be used to sanely support PCHs
-#if defined(CATCH_CONFIG_ALL_PARTS)
-#  define CATCH_CONFIG_EXTERNAL_INTERFACES
-#  if defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#    undef CATCH_CONFIG_DISABLE_MATCHERS
-#  endif
-#  if !defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)
-#    define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
-#  endif
-#endif
-
-#if !defined(CATCH_CONFIG_IMPL_ONLY)
-// start catch_platform.h
-
-#ifdef __APPLE__
-# include <TargetConditionals.h>
-# if TARGET_OS_OSX == 1
-#  define CATCH_PLATFORM_MAC
-# elif TARGET_OS_IPHONE == 1
-#  define CATCH_PLATFORM_IPHONE
-# endif
-
-#elif defined(linux) || defined(__linux) || defined(__linux__)
-#  define CATCH_PLATFORM_LINUX
-
-#elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) || defined(__MINGW32__)
-#  define CATCH_PLATFORM_WINDOWS
-#endif
-
-// end catch_platform.h
-
-#ifdef CATCH_IMPL
-#  ifndef CLARA_CONFIG_MAIN
-#    define CLARA_CONFIG_MAIN_NOT_DEFINED
-#    define CLARA_CONFIG_MAIN
-#  endif
-#endif
-
-// start catch_user_interfaces.h
-
-namespace Catch {
-    unsigned int rngSeed();
-}
-
-// end catch_user_interfaces.h
-// start catch_tag_alias_autoregistrar.h
-
-// start catch_common.h
-
-// start catch_compiler_capabilities.h
-
-// Detect a number of compiler features - by compiler
-// The following features are defined:
-//
-// CATCH_CONFIG_COUNTER : is the __COUNTER__ macro supported?
-// CATCH_CONFIG_WINDOWS_SEH : is Windows SEH supported?
-// CATCH_CONFIG_POSIX_SIGNALS : are POSIX signals supported?
-// CATCH_CONFIG_DISABLE_EXCEPTIONS : Are exceptions enabled?
-// ****************
-// Note to maintainers: if new toggles are added please document them
-// in configuration.md, too
-// ****************
-
-// In general each macro has a _NO_<feature name> form
-// (e.g. CATCH_CONFIG_NO_POSIX_SIGNALS) which disables the feature.
-// Many features, at point of detection, define an _INTERNAL_ macro, so they
-// can be combined, en-mass, with the _NO_ forms later.
-
-#ifdef __cplusplus
-
-#  if (__cplusplus >= 201402L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201402L)
-#    define CATCH_CPP14_OR_GREATER
-#  endif
-
-#  if (__cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
-#    define CATCH_CPP17_OR_GREATER
-#  endif
-
-#endif
-
-#if defined(CATCH_CPP17_OR_GREATER)
-#  define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
-#endif
-
-#ifdef __clang__
-
-#       define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-            _Pragma( "clang diagnostic push" ) \
-            _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) \
-            _Pragma( "clang diagnostic ignored \"-Wglobal-constructors\"")
-#       define CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS \
-            _Pragma( "clang diagnostic pop" )
-
-#       define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
-            _Pragma( "clang diagnostic push" ) \
-            _Pragma( "clang diagnostic ignored \"-Wparentheses\"" )
-#       define CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS \
-            _Pragma( "clang diagnostic pop" )
-
-#       define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
-            _Pragma( "clang diagnostic push" ) \
-            _Pragma( "clang diagnostic ignored \"-Wunused-variable\"" )
-#       define CATCH_INTERNAL_UNSUPPRESS_UNUSED_WARNINGS \
-            _Pragma( "clang diagnostic pop" )
-
-#       define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
-            _Pragma( "clang diagnostic push" ) \
-            _Pragma( "clang diagnostic ignored \"-Wgnu-zero-variadic-macro-arguments\"" )
-#       define CATCH_INTERNAL_UNSUPPRESS_ZERO_VARIADIC_WARNINGS \
-            _Pragma( "clang diagnostic pop" )
-
-#endif // __clang__
-
-////////////////////////////////////////////////////////////////////////////////
-// Assume that non-Windows platforms support posix signals by default
-#if !defined(CATCH_PLATFORM_WINDOWS)
-    #define CATCH_INTERNAL_CONFIG_POSIX_SIGNALS
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// We know some environments not to support full POSIX signals
-#if defined(__CYGWIN__) || defined(__QNX__) || defined(__EMSCRIPTEN__) || defined(__DJGPP__)
-    #define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
-#endif
-
-#ifdef __OS400__
-#       define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
-#       define CATCH_CONFIG_COLOUR_NONE
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// Android somehow still does not support std::to_string
-#if defined(__ANDROID__)
-#    define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// Not all Windows environments support SEH properly
-#if defined(__MINGW32__)
-#    define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// PS4
-#if defined(__ORBIS__)
-#    define CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// Cygwin
-#ifdef __CYGWIN__
-
-// Required for some versions of Cygwin to declare gettimeofday
-// see: http://stackoverflow.com/questions/36901803/gettimeofday-not-declared-in-this-scope-cygwin
-#   define _BSD_SOURCE
-// some versions of cygwin (most) do not support std::to_string. Use the libstd check.
-// https://gcc.gnu.org/onlinedocs/gcc-4.8.2/libstdc++/api/a01053_source.html line 2812-2813
-# if !((__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99) \
-           && !defined(_GLIBCXX_HAVE_BROKEN_VSWPRINTF))
-
-#    define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
-
-# endif
-#endif // __CYGWIN__
-
-////////////////////////////////////////////////////////////////////////////////
-// Visual C++
-#ifdef _MSC_VER
-
-#  if _MSC_VER >= 1900 // Visual Studio 2015 or newer
-#    define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
-#  endif
-
-// Universal Windows platform does not support SEH
-// Or console colours (or console at all...)
-#  if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP)
-#    define CATCH_CONFIG_COLOUR_NONE
-#  else
-#    define CATCH_INTERNAL_CONFIG_WINDOWS_SEH
-#  endif
-
-// MSVC traditional preprocessor needs some workaround for __VA_ARGS__
-// _MSVC_TRADITIONAL == 0 means new conformant preprocessor
-// _MSVC_TRADITIONAL == 1 means old traditional non-conformant preprocessor
-#  if !defined(_MSVC_TRADITIONAL) || (defined(_MSVC_TRADITIONAL) && _MSVC_TRADITIONAL)
-#    define CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#  endif
-#endif // _MSC_VER
-
-#if defined(_REENTRANT) || defined(_MSC_VER)
-// Enable async processing, as -pthread is specified or no additional linking is required
-# define CATCH_INTERNAL_CONFIG_USE_ASYNC
-#endif // _MSC_VER
-
-////////////////////////////////////////////////////////////////////////////////
-// Check if we are compiled with -fno-exceptions or equivalent
-#if defined(__EXCEPTIONS) || defined(__cpp_exceptions) || defined(_CPPUNWIND)
-#  define CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// DJGPP
-#ifdef __DJGPP__
-#  define CATCH_INTERNAL_CONFIG_NO_WCHAR
-#endif // __DJGPP__
-
-////////////////////////////////////////////////////////////////////////////////
-// Embarcadero C++Build
-#if defined(__BORLANDC__)
-    #define CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-
-// Use of __COUNTER__ is suppressed during code analysis in
-// CLion/AppCode 2017.2.x and former, because __COUNTER__ is not properly
-// handled by it.
-// Otherwise all supported compilers support COUNTER macro,
-// but user still might want to turn it off
-#if ( !defined(__JETBRAINS_IDE__) || __JETBRAINS_IDE__ >= 20170300L )
-    #define CATCH_INTERNAL_CONFIG_COUNTER
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// Check if string_view is available and usable
-// The check is split apart to work around v140 (VS2015) preprocessor issue...
-#if defined(__has_include)
-#if __has_include(<string_view>) && defined(CATCH_CPP17_OR_GREATER)
-#    define CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW
-#endif
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// Check if optional is available and usable
-#if defined(__has_include)
-#  if __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
-#    define CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL
-#  endif // __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
-#endif // __has_include
-
-////////////////////////////////////////////////////////////////////////////////
-// Check if variant is available and usable
-#if defined(__has_include)
-#  if __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
-#    if defined(__clang__) && (__clang_major__ < 8)
-       // work around clang bug with libstdc++ https://bugs.llvm.org/show_bug.cgi?id=31852
-       // fix should be in clang 8, workaround in libstdc++ 8.2
-#      include <ciso646>
-#      if defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
-#        define CATCH_CONFIG_NO_CPP17_VARIANT
-#      else
-#        define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
-#      endif // defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
-#    else
-#      define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
-#    endif // defined(__clang__) && (__clang_major__ < 8)
-#  endif // __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
-#endif // __has_include
-
-#if defined(CATCH_INTERNAL_CONFIG_COUNTER) && !defined(CATCH_CONFIG_NO_COUNTER) && !defined(CATCH_CONFIG_COUNTER)
-#   define CATCH_CONFIG_COUNTER
-#endif
-#if defined(CATCH_INTERNAL_CONFIG_WINDOWS_SEH) && !defined(CATCH_CONFIG_NO_WINDOWS_SEH) && !defined(CATCH_CONFIG_WINDOWS_SEH) && !defined(CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH)
-#   define CATCH_CONFIG_WINDOWS_SEH
-#endif
-// This is set by default, because we assume that unix compilers are posix-signal-compatible by default.
-#if defined(CATCH_INTERNAL_CONFIG_POSIX_SIGNALS) && !defined(CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_POSIX_SIGNALS)
-#   define CATCH_CONFIG_POSIX_SIGNALS
-#endif
-// This is set by default, because we assume that compilers with no wchar_t support are just rare exceptions.
-#if !defined(CATCH_INTERNAL_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_WCHAR)
-#   define CATCH_CONFIG_WCHAR
-#endif
-
-#if !defined(CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_CPP11_TO_STRING)
-#    define CATCH_CONFIG_CPP11_TO_STRING
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_NO_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_CPP17_OPTIONAL)
-#  define CATCH_CONFIG_CPP17_OPTIONAL
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS) && !defined(CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS) && !defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
-#  define CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_NO_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_CPP17_STRING_VIEW)
-#  define CATCH_CONFIG_CPP17_STRING_VIEW
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_CPP17_VARIANT) && !defined(CATCH_CONFIG_NO_CPP17_VARIANT) && !defined(CATCH_CONFIG_CPP17_VARIANT)
-#  define CATCH_CONFIG_CPP17_VARIANT
-#endif
-
-#if defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT)
-#  define CATCH_INTERNAL_CONFIG_NEW_CAPTURE
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_NEW_CAPTURE) && !defined(CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NEW_CAPTURE)
-#  define CATCH_CONFIG_NEW_CAPTURE
-#endif
-
-#if !defined(CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-#  define CATCH_CONFIG_DISABLE_EXCEPTIONS
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_NO_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_POLYFILL_ISNAN)
-#  define CATCH_CONFIG_POLYFILL_ISNAN
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_USE_ASYNC)  && !defined(CATCH_CONFIG_NO_USE_ASYNC) && !defined(CATCH_CONFIG_USE_ASYNC)
-#  define CATCH_CONFIG_USE_ASYNC
-#endif
-
-#if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS)
-#   define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS
-#   define CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS
-#endif
-#if !defined(CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS)
-#   define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
-#   define CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS
-#endif
-#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS)
-#   define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS
-#   define CATCH_INTERNAL_UNSUPPRESS_UNUSED_WARNINGS
-#endif
-#if !defined(CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS)
-#   define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS
-#   define CATCH_INTERNAL_UNSUPPRESS_ZERO_VARIADIC_WARNINGS
-#endif
-
-#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-#define CATCH_TRY if ((true))
-#define CATCH_CATCH_ALL if ((false))
-#define CATCH_CATCH_ANON(type) if ((false))
-#else
-#define CATCH_TRY try
-#define CATCH_CATCH_ALL catch (...)
-#define CATCH_CATCH_ANON(type) catch (type)
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_NO_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR)
-#define CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#endif
-
-// end catch_compiler_capabilities.h
-#define INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) name##line
-#define INTERNAL_CATCH_UNIQUE_NAME_LINE( name, line ) INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line )
-#ifdef CATCH_CONFIG_COUNTER
-#  define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __COUNTER__ )
-#else
-#  define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __LINE__ )
-#endif
-
-#include <iosfwd>
-#include <string>
-#include <cstdint>
-
-// We need a dummy global operator<< so we can bring it into Catch namespace later
-struct Catch_global_namespace_dummy {};
-std::ostream& operator<<(std::ostream&, Catch_global_namespace_dummy);
-
-namespace Catch {
-
-    struct CaseSensitive { enum Choice {
-        Yes,
-        No
-    }; };
-
-    class NonCopyable {
-        NonCopyable( NonCopyable const& )              = delete;
-        NonCopyable( NonCopyable && )                  = delete;
-        NonCopyable& operator = ( NonCopyable const& ) = delete;
-        NonCopyable& operator = ( NonCopyable && )     = delete;
-
-    protected:
-        NonCopyable();
-        virtual ~NonCopyable();
-    };
-
-    struct SourceLineInfo {
-
-        SourceLineInfo() = delete;
-        SourceLineInfo( char const* _file, std::size_t _line ) noexcept
-        :   file( _file ),
-            line( _line )
-        {}
-
-        SourceLineInfo( SourceLineInfo const& other )            = default;
-        SourceLineInfo& operator = ( SourceLineInfo const& )     = default;
-        SourceLineInfo( SourceLineInfo&& )              noexcept = default;
-        SourceLineInfo& operator = ( SourceLineInfo&& ) noexcept = default;
-
-        bool empty() const noexcept;
-        bool operator == ( SourceLineInfo const& other ) const noexcept;
-        bool operator < ( SourceLineInfo const& other ) const noexcept;
-
-        char const* file;
-        std::size_t line;
-    };
-
-    std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info );
-
-    // Bring in operator<< from global namespace into Catch namespace
-    // This is necessary because the overload of operator<< above makes
-    // lookup stop at namespace Catch
-    using ::operator<<;
-
-    // Use this in variadic streaming macros to allow
-    //    >> +StreamEndStop
-    // as well as
-    //    >> stuff +StreamEndStop
-    struct StreamEndStop {
-        std::string operator+() const;
-    };
-    template<typename T>
-    T const& operator + ( T const& value, StreamEndStop ) {
-        return value;
-    }
-}
-
-#define CATCH_INTERNAL_LINEINFO \
-    ::Catch::SourceLineInfo( __FILE__, static_cast<std::size_t>( __LINE__ ) )
-
-// end catch_common.h
-namespace Catch {
-
-    struct RegistrarForTagAliases {
-        RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo );
-    };
-
-} // end namespace Catch
-
-#define CATCH_REGISTER_TAG_ALIAS( alias, spec ) \
-    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-    namespace{ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); } \
-    CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS
-
-// end catch_tag_alias_autoregistrar.h
-// start catch_test_registry.h
-
-// start catch_interfaces_testcase.h
-
-#include <vector>
-
-namespace Catch {
-
-    class TestSpec;
-
-    struct ITestInvoker {
-        virtual void invoke () const = 0;
-        virtual ~ITestInvoker();
-    };
-
-    class TestCase;
-    struct IConfig;
-
-    struct ITestCaseRegistry {
-        virtual ~ITestCaseRegistry();
-        virtual std::vector<TestCase> const& getAllTests() const = 0;
-        virtual std::vector<TestCase> const& getAllTestsSorted( IConfig const& config ) const = 0;
-    };
-
-    bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config );
-    std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config );
-    std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config );
-
-}
-
-// end catch_interfaces_testcase.h
-// start catch_stringref.h
-
-#include <cstddef>
-#include <string>
-#include <iosfwd>
-
-namespace Catch {
-
-    /// A non-owning string class (similar to the forthcoming std::string_view)
-    /// Note that, because a StringRef may be a substring of another string,
-    /// it may not be null terminated. c_str() must return a null terminated
-    /// string, however, and so the StringRef will internally take ownership
-    /// (taking a copy), if necessary. In theory this ownership is not externally
-    /// visible - but it does mean (substring) StringRefs should not be shared between
-    /// threads.
-    class StringRef {
-    public:
-        using size_type = std::size_t;
-
-    private:
-        friend struct StringRefTestAccess;
-
-        char const* m_start;
-        size_type m_size;
-
-        char* m_data = nullptr;
-
-        void takeOwnership();
-
-        static constexpr char const* const s_empty = "";
-
-    public: // construction/ assignment
-        StringRef() noexcept
-        :   StringRef( s_empty, 0 )
-        {}
-
-        StringRef( StringRef const& other ) noexcept
-        :   m_start( other.m_start ),
-            m_size( other.m_size )
-        {}
-
-        StringRef( StringRef&& other ) noexcept
-        :   m_start( other.m_start ),
-            m_size( other.m_size ),
-            m_data( other.m_data )
-        {
-            other.m_data = nullptr;
-        }
-
-        StringRef( char const* rawChars ) noexcept;
-
-        StringRef( char const* rawChars, size_type size ) noexcept
-        :   m_start( rawChars ),
-            m_size( size )
-        {}
-
-        StringRef( std::string const& stdString ) noexcept
-        :   m_start( stdString.c_str() ),
-            m_size( stdString.size() )
-        {}
-
-        ~StringRef() noexcept {
-            delete[] m_data;
-        }
-
-        auto operator = ( StringRef const &other ) noexcept -> StringRef& {
-            delete[] m_data;
-            m_data = nullptr;
-            m_start = other.m_start;
-            m_size = other.m_size;
-            return *this;
-        }
-
-        operator std::string() const;
-
-        void swap( StringRef& other ) noexcept;
-
-    public: // operators
-        auto operator == ( StringRef const& other ) const noexcept -> bool;
-        auto operator != ( StringRef const& other ) const noexcept -> bool;
-
-        auto operator[] ( size_type index ) const noexcept -> char;
-
-    public: // named queries
-        auto empty() const noexcept -> bool {
-            return m_size == 0;
-        }
-        auto size() const noexcept -> size_type {
-            return m_size;
-        }
-
-        auto numberOfCharacters() const noexcept -> size_type;
-        auto c_str() const -> char const*;
-
-    public: // substrings and searches
-        auto substr( size_type start, size_type size ) const noexcept -> StringRef;
-
-        // Returns the current start pointer.
-        // Note that the pointer can change when if the StringRef is a substring
-        auto currentData() const noexcept -> char const*;
-
-    private: // ownership queries - may not be consistent between calls
-        auto isOwned() const noexcept -> bool;
-        auto isSubstring() const noexcept -> bool;
-    };
-
-    auto operator + ( StringRef const& lhs, StringRef const& rhs ) -> std::string;
-    auto operator + ( StringRef const& lhs, char const* rhs ) -> std::string;
-    auto operator + ( char const* lhs, StringRef const& rhs ) -> std::string;
-
-    auto operator += ( std::string& lhs, StringRef const& sr ) -> std::string&;
-    auto operator << ( std::ostream& os, StringRef const& sr ) -> std::ostream&;
-
-    inline auto operator "" _sr( char const* rawChars, std::size_t size ) noexcept -> StringRef {
-        return StringRef( rawChars, size );
-    }
-
-} // namespace Catch
-
-inline auto operator "" _catch_sr( char const* rawChars, std::size_t size ) noexcept -> Catch::StringRef {
-    return Catch::StringRef( rawChars, size );
-}
-
-// end catch_stringref.h
-// start catch_type_traits.hpp
-
-
-#include <type_traits>
-
-namespace Catch{
-
-#ifdef CATCH_CPP17_OR_GREATER
-	template <typename...>
-	inline constexpr auto is_unique = std::true_type{};
-
-	template <typename T, typename... Rest>
-	inline constexpr auto is_unique<T, Rest...> = std::bool_constant<
-		(!std::is_same_v<T, Rest> && ...) && is_unique<Rest...>
-	>{};
-#else
-
-template <typename...>
-struct is_unique : std::true_type{};
-
-template <typename T0, typename T1, typename... Rest>
-struct is_unique<T0, T1, Rest...> : std::integral_constant
-<bool,
-     !std::is_same<T0, T1>::value
-     && is_unique<T0, Rest...>::value
-     && is_unique<T1, Rest...>::value
->{};
-
-#endif
-}
-
-// end catch_type_traits.hpp
-// start catch_preprocessor.hpp
-
-
-#define CATCH_RECURSION_LEVEL0(...) __VA_ARGS__
-#define CATCH_RECURSION_LEVEL1(...) CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(__VA_ARGS__)))
-#define CATCH_RECURSION_LEVEL2(...) CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(__VA_ARGS__)))
-#define CATCH_RECURSION_LEVEL3(...) CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(__VA_ARGS__)))
-#define CATCH_RECURSION_LEVEL4(...) CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(__VA_ARGS__)))
-#define CATCH_RECURSION_LEVEL5(...) CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(__VA_ARGS__)))
-
-#ifdef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define INTERNAL_CATCH_EXPAND_VARGS(...) __VA_ARGS__
-// MSVC needs more evaluations
-#define CATCH_RECURSION_LEVEL6(...) CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(__VA_ARGS__)))
-#define CATCH_RECURSE(...)  CATCH_RECURSION_LEVEL6(CATCH_RECURSION_LEVEL6(__VA_ARGS__))
-#else
-#define CATCH_RECURSE(...)  CATCH_RECURSION_LEVEL5(__VA_ARGS__)
-#endif
-
-#define CATCH_REC_END(...)
-#define CATCH_REC_OUT
-
-#define CATCH_EMPTY()
-#define CATCH_DEFER(id) id CATCH_EMPTY()
-
-#define CATCH_REC_GET_END2() 0, CATCH_REC_END
-#define CATCH_REC_GET_END1(...) CATCH_REC_GET_END2
-#define CATCH_REC_GET_END(...) CATCH_REC_GET_END1
-#define CATCH_REC_NEXT0(test, next, ...) next CATCH_REC_OUT
-#define CATCH_REC_NEXT1(test, next) CATCH_DEFER ( CATCH_REC_NEXT0 ) ( test, next, 0)
-#define CATCH_REC_NEXT(test, next)  CATCH_REC_NEXT1(CATCH_REC_GET_END test, next)
-
-#define CATCH_REC_LIST0(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )
-#define CATCH_REC_LIST1(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0) ) ( f, peek, __VA_ARGS__ )
-#define CATCH_REC_LIST2(f, x, peek, ...)   f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )
-
-#define CATCH_REC_LIST0_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )
-#define CATCH_REC_LIST1_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0_UD) ) ( f, userdata, peek, __VA_ARGS__ )
-#define CATCH_REC_LIST2_UD(f, userdata, x, peek, ...)   f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )
-
-// Applies the function macro `f` to each of the remaining parameters, inserts commas between the results,
-// and passes userdata as the first parameter to each invocation,
-// e.g. CATCH_REC_LIST_UD(f, x, a, b, c) evaluates to f(x, a), f(x, b), f(x, c)
-#define CATCH_REC_LIST_UD(f, userdata, ...) CATCH_RECURSE(CATCH_REC_LIST2_UD(f, userdata, __VA_ARGS__, ()()(), ()()(), ()()(), 0))
-
-#define CATCH_REC_LIST(f, ...) CATCH_RECURSE(CATCH_REC_LIST2(f, __VA_ARGS__, ()()(), ()()(), ()()(), 0))
-
-#define INTERNAL_CATCH_EXPAND1(param) INTERNAL_CATCH_EXPAND2(param)
-#define INTERNAL_CATCH_EXPAND2(...) INTERNAL_CATCH_NO## __VA_ARGS__
-#define INTERNAL_CATCH_DEF(...) INTERNAL_CATCH_DEF __VA_ARGS__
-#define INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
-#define INTERNAL_CATCH_STRINGIZE(...) INTERNAL_CATCH_STRINGIZE2(__VA_ARGS__)
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define INTERNAL_CATCH_STRINGIZE2(...) #__VA_ARGS__
-#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param))
-#else
-// MSVC is adding extra space and needs another indirection to expand INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
-#define INTERNAL_CATCH_STRINGIZE2(...) INTERNAL_CATCH_STRINGIZE3(__VA_ARGS__)
-#define INTERNAL_CATCH_STRINGIZE3(...) #__VA_ARGS__
-#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) (INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param)) + 1)
-#endif
-
-#define INTERNAL_CATCH_MAKE_NAMESPACE2(...) ns_##__VA_ARGS__
-#define INTERNAL_CATCH_MAKE_NAMESPACE(name) INTERNAL_CATCH_MAKE_NAMESPACE2(name)
-
-#define INTERNAL_CATCH_REMOVE_PARENS(...) INTERNAL_CATCH_EXPAND1(INTERNAL_CATCH_DEF __VA_ARGS__)
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>())
-#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__))
-#else
-#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) INTERNAL_CATCH_EXPAND_VARGS(decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>()))
-#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__)))
-#endif
-
-#define INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(...)\
-    CATCH_REC_LIST(INTERNAL_CATCH_MAKE_TYPE_LIST,__VA_ARGS__)
-
-#define INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_0) INTERNAL_CATCH_REMOVE_PARENS(_0)
-#define INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_0, _1) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_1)
-#define INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_0, _1, _2) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_1, _2)
-#define INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_0, _1, _2, _3) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_1, _2, _3)
-#define INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_0, _1, _2, _3, _4) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_1, _2, _3, _4)
-#define INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_0, _1, _2, _3, _4, _5) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_1, _2, _3, _4, _5)
-#define INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_0, _1, _2, _3, _4, _5, _6) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_1, _2, _4, _5, _6)
-#define INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_0, _1, _2, _3, _4, _5, _6, _7) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_1, _2, _3, _4, _5, _6, _7)
-#define INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_1, _2, _3, _4, _5, _6, _7, _8)
-#define INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9)
-#define INTERNAL_CATCH_REMOVE_PARENS_11_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10)
-
-#define INTERNAL_CATCH_VA_NARGS_IMPL(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N
-
-#define INTERNAL_CATCH_TYPE_GEN\
-    template<typename...> struct TypeList {};\
-    template<typename...Ts>\
-    constexpr auto get_wrapper() noexcept -> TypeList<Ts...> { return {}; }\
-    \
-    template<template<typename...> class L1, typename...E1, template<typename...> class L2, typename...E2> \
-    constexpr auto append(L1<E1...>, L2<E2...>) noexcept -> L1<E1...,E2...> { return {}; }\
-    template< template<typename...> class L1, typename...E1, template<typename...> class L2, typename...E2, typename...Rest>\
-    constexpr auto append(L1<E1...>, L2<E2...>, Rest...) noexcept -> decltype(append(L1<E1...,E2...>{}, Rest{}...)) { return {}; }\
-    template< template<typename...> class L1, typename...E1, typename...Rest>\
-    constexpr auto append(L1<E1...>, TypeList<mpl_::na>, Rest...) noexcept -> L1<E1...> { return {}; }\
-    \
-    template< template<typename...> class Container, template<typename...> class List, typename...elems>\
-    constexpr auto rewrap(List<elems...>) noexcept -> TypeList<Container<elems...>> { return {}; }\
-    template< template<typename...> class Container, template<typename...> class List, class...Elems, typename...Elements>\
-    constexpr auto rewrap(List<Elems...>,Elements...) noexcept -> decltype(append(TypeList<Container<Elems...>>{}, rewrap<Container>(Elements{}...))) { return {}; }\
-    \
-    template<template <typename...> class Final, template< typename...> class...Containers, typename...Types>\
-    constexpr auto create(TypeList<Types...>) noexcept -> decltype(append(Final<>{}, rewrap<Containers>(Types{}...)...)) { return {}; }\
-    template<template <typename...> class Final, template <typename...> class List, typename...Ts>\
-    constexpr auto convert(List<Ts...>) noexcept -> decltype(append(Final<>{},TypeList<Ts>{}...)) { return {}; }
-
-#define INTERNAL_CATCH_NTTP_1(signature, ...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> struct Nttp{};\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    constexpr auto get_wrapper() noexcept -> Nttp<__VA_ARGS__> { return {}; } \
-    \
-    template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    constexpr auto rewrap(List<__VA_ARGS__>) noexcept -> TypeList<Container<__VA_ARGS__>> { return {}; }\
-    template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature), typename...Elements>\
-    constexpr auto rewrap(List<__VA_ARGS__>,Elements...elems) noexcept -> decltype(append(TypeList<Container<__VA_ARGS__>>{}, rewrap<Container>(elems...))) { return {}; }\
-    template<template <typename...> class Final, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...Containers, typename...Types>\
-    constexpr auto create(TypeList<Types...>) noexcept -> decltype(append(Final<>{}, rewrap<Containers>(Types{}...)...)) { return {}; }
-
-#define INTERNAL_CATCH_DECLARE_SIG_TEST0(TestName)
-#define INTERNAL_CATCH_DECLARE_SIG_TEST1(TestName, signature)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    static void TestName()
-#define INTERNAL_CATCH_DECLARE_SIG_TEST_X(TestName, signature, ...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    static void TestName()
-
-#define INTERNAL_CATCH_DEFINE_SIG_TEST0(TestName)
-#define INTERNAL_CATCH_DEFINE_SIG_TEST1(TestName, signature)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    static void TestName()
-#define INTERNAL_CATCH_DEFINE_SIG_TEST_X(TestName, signature,...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    static void TestName()
-
-#define INTERNAL_CATCH_NTTP_REGISTER0(TestFunc, signature)\
-    template<typename Type>\
-    void reg_test(TypeList<Type>, Catch::NameAndTags nameAndTags)\
-    {\
-        Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<Type>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
-    }
-
-#define INTERNAL_CATCH_NTTP_REGISTER(TestFunc, signature, ...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    void reg_test(Nttp<__VA_ARGS__>, Catch::NameAndTags nameAndTags)\
-    {\
-        Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<__VA_ARGS__>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
-    }
-
-#define INTERNAL_CATCH_NTTP_REGISTER_METHOD0(TestName, signature, ...)\
-    template<typename Type>\
-    void reg_test(TypeList<Type>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
-    {\
-        Catch::AutoReg( Catch::makeTestInvoker(&TestName<Type>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
-    }
-
-#define INTERNAL_CATCH_NTTP_REGISTER_METHOD(TestName, signature, ...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    void reg_test(Nttp<__VA_ARGS__>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
-    {\
-        Catch::AutoReg( Catch::makeTestInvoker(&TestName<__VA_ARGS__>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
-    }
-
-#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0(TestName, ClassName)
-#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1(TestName, ClassName, signature)\
-    template<typename TestType> \
-    struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<TestType> { \
-        void test();\
-    }
-
-#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X(TestName, ClassName, signature, ...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
-    struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<__VA_ARGS__> { \
-        void test();\
-    }
-
-#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0(TestName)
-#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1(TestName, signature)\
-    template<typename TestType> \
-    void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<TestType>::test()
-#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X(TestName, signature, ...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
-    void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<__VA_ARGS__>::test()
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define INTERNAL_CATCH_NTTP_0
-#define INTERNAL_CATCH_NTTP_GEN(...) INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__),INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_0)
-#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__)
-#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__)
-#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__)
-#define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__)
-#define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__)
-#define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__)
-#define INTERNAL_CATCH_REMOVE_PARENS_GEN(...) INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG,INTERNAL_CATCH_REMOVE_PARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,INTERNAL_CATCH_REMOVE_PARENS_8_ARG,INTERNAL_CATCH_REMOVE_PARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,INTERNAL_CATCH_REMOVE_PARENS_5_ARG,INTERNAL_CATCH_REMOVE_PARENS_4_ARG,INTERNAL_CATCH_REMOVE_PARENS_3_ARG,INTERNAL_CATCH_REMOVE_PARENS_2_ARG,INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__)
-#else
-#define INTERNAL_CATCH_NTTP_0(signature)
-#define INTERNAL_CATCH_NTTP_GEN(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1,INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_0)( __VA_ARGS__))
-#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__))
-#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__))
-#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__))
-#define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__))
-#define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__))
-#define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__))
-#define INTERNAL_CATCH_REMOVE_PARENS_GEN(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG,INTERNAL_CATCH_REMOVE_PARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,INTERNAL_CATCH_REMOVE_PARENS_8_ARG,INTERNAL_CATCH_REMOVE_PARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,INTERNAL_CATCH_REMOVE_PARENS_5_ARG,INTERNAL_CATCH_REMOVE_PARENS_4_ARG,INTERNAL_CATCH_REMOVE_PARENS_3_ARG,INTERNAL_CATCH_REMOVE_PARENS_2_ARG,INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__))
-#endif
-
-// end catch_preprocessor.hpp
-// start catch_meta.hpp
-
-
-#include <type_traits>
-
-namespace Catch {
-template<typename T>
-struct always_false : std::false_type {};
-
-template <typename> struct true_given : std::true_type {};
-struct is_callable_tester {
-    template <typename Fun, typename... Args>
-    true_given<decltype(std::declval<Fun>()(std::declval<Args>()...))> static test(int);
-    template <typename...>
-    std::false_type static test(...);
-};
-
-template <typename T>
-struct is_callable;
-
-template <typename Fun, typename... Args>
-struct is_callable<Fun(Args...)> : decltype(is_callable_tester::test<Fun, Args...>(0)) {};
-
-} // namespace Catch
-
-namespace mpl_{
-    struct na;
-}
-
-// end catch_meta.hpp
-namespace Catch {
-
-template<typename C>
-class TestInvokerAsMethod : public ITestInvoker {
-    void (C::*m_testAsMethod)();
-public:
-    TestInvokerAsMethod( void (C::*testAsMethod)() ) noexcept : m_testAsMethod( testAsMethod ) {}
-
-    void invoke() const override {
-        C obj;
-        (obj.*m_testAsMethod)();
-    }
-};
-
-auto makeTestInvoker( void(*testAsFunction)() ) noexcept -> ITestInvoker*;
-
-template<typename C>
-auto makeTestInvoker( void (C::*testAsMethod)() ) noexcept -> ITestInvoker* {
-    return new(std::nothrow) TestInvokerAsMethod<C>( testAsMethod );
-}
-
-struct NameAndTags {
-    NameAndTags( StringRef const& name_ = StringRef(), StringRef const& tags_ = StringRef() ) noexcept;
-    StringRef name;
-    StringRef tags;
-};
-
-struct AutoReg : NonCopyable {
-    AutoReg( ITestInvoker* invoker, SourceLineInfo const& lineInfo, StringRef const& classOrMethod, NameAndTags const& nameAndTags ) noexcept;
-    ~AutoReg();
-};
-
-} // end namespace Catch
-
-#if defined(CATCH_CONFIG_DISABLE)
-    #define INTERNAL_CATCH_TESTCASE_NO_REGISTRATION( TestName, ... ) \
-        static void TestName()
-    #define INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION( TestName, ClassName, ... ) \
-        namespace{                        \
-            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
-                void test();              \
-            };                            \
-        }                                 \
-        void TestName::test()
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( TestName, TestFunc, Name, Tags, Signature, ... )  \
-        INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature))
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( TestNameClass, TestName, ClassName, Name, Tags, Signature, ... )    \
-        namespace{                                                                                  \
-            namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) {                                      \
-            INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
-        }                                                                                           \
-        }                                                                                           \
-        INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))
-
-    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...) \
-            INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ )
-    #else
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...) \
-            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ ) )
-    #endif
-
-    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...) \
-            INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ )
-    #else
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...) \
-            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ ) )
-    #endif
-
-    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( ClassName, Name, Tags,... ) \
-            INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ )
-    #else
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( ClassName, Name, Tags,... ) \
-            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ ) )
-    #endif
-
-    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION( ClassName, Name, Tags, Signature, ... ) \
-            INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ )
-    #else
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION( ClassName, Name, Tags, Signature, ... ) \
-            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ ) )
-    #endif
-#endif
-
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_TESTCASE2( TestName, ... ) \
-        static void TestName(); \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &TestName ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
-        CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS \
-        static void TestName()
-    #define INTERNAL_CATCH_TESTCASE( ... ) \
-        INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), __VA_ARGS__ )
-
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, ... ) \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &QualifiedMethod ), CATCH_INTERNAL_LINEINFO, "&" #QualifiedMethod, Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
-        CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS
-
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_TEST_CASE_METHOD2( TestName, ClassName, ... )\
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        namespace{ \
-            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
-                void test(); \
-            }; \
-            Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( Catch::makeTestInvoker( &TestName::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
-        } \
-        CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS \
-        void TestName::test()
-    #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, ... ) \
-        INTERNAL_CATCH_TEST_CASE_METHOD2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), ClassName, __VA_ARGS__ )
-
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_REGISTER_TESTCASE( Function, ... ) \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( Function ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
-        CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS
-
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_2(TestName, TestFunc, Name, Tags, Signature, ... )\
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
-        INTERNAL_CATCH_DECLARE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
-        namespace {\
-        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
-            INTERNAL_CATCH_TYPE_GEN\
-            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
-            INTERNAL_CATCH_NTTP_REG_GEN(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))\
-            template<typename...Types> \
-            struct TestName{\
-                TestName(){\
-                    int index = 0;                                    \
-                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};\
-                    using expander = int[];\
-                    (void)expander{(reg_test(Types{}, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++, 0)... };/* NOLINT */ \
-                }\
-            };\
-            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
-            TestName<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
-            return 0;\
-        }();\
-        }\
-        }\
-        CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS \
-        CATCH_INTERNAL_UNSUPPRESS_ZERO_VARIADIC_WARNINGS \
-        INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
-        INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ )
-#else
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ ) )
-#endif
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...) \
-        INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ )
-#else
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...) \
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ ) )
-#endif
-
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(TestName, TestFuncName, Name, Tags, Signature, TmplTypes, TypesList) \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                      \
-        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS                \
-        template<typename TestType> static void TestFuncName();       \
-        namespace {\
-        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) {                                     \
-            INTERNAL_CATCH_TYPE_GEN                                                  \
-            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))         \
-            template<typename... Types>                               \
-            struct TestName {                                         \
-                void reg_tests() {                                          \
-                    int index = 0;                                    \
-                    using expander = int[];                           \
-                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\
-                    constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\
-                    constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\
-                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFuncName<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + "<" + std::string(types_list[index % num_types]) + ">", Tags } ), index++, 0)... };/* NOLINT */\
-                }                                                     \
-            };                                                        \
-            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
-                using TestInit = decltype(create<TestName, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>(TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(INTERNAL_CATCH_REMOVE_PARENS(TypesList))>{})); \
-                TestInit t;                                           \
-                t.reg_tests();                                        \
-                return 0;                                             \
-            }();                                                      \
-        }                                                             \
-        }                                                             \
-        CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS                    \
-        CATCH_INTERNAL_UNSUPPRESS_ZERO_VARIADIC_WARNINGS              \
-        template<typename TestType>                                   \
-        static void TestFuncName()
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)\
-        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename T,__VA_ARGS__)
-#else
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)\
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename T, __VA_ARGS__ ) )
-#endif
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)\
-        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__)
-#else
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)\
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ ) )
-#endif
-
-    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2(TestName, TestFunc, Name, Tags, TmplList)\
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        template<typename TestType> static void TestFunc();       \
-        namespace {\
-        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
-        INTERNAL_CATCH_TYPE_GEN\
-        template<typename... Types>                               \
-        struct TestName {                                         \
-            void reg_tests() {                                          \
-                int index = 0;                                    \
-                using expander = int[];                           \
-                (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFunc<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " + std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) + " - " + std::to_string(index), Tags } ), index++, 0)... };/* NOLINT */\
-            }                                                     \
-        };\
-        static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
-                using TestInit = decltype(convert<TestName>(TmplList {})); \
-                TestInit t;                                           \
-                t.reg_tests();                                        \
-                return 0;                                             \
-            }();                                                        \
-        }}\
-        CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS                    \
-        template<typename TestType>                                   \
-        static void TestFunc()
-
-    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(Name, Tags, TmplList) \
-        INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, TmplList )
-
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, Signature, ... ) \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
-        namespace {\
-        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
-            INTERNAL_CATCH_TYPE_GEN\
-            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
-            INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
-            INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))\
-            template<typename...Types> \
-            struct TestNameClass{\
-                TestNameClass(){\
-                    int index = 0;                                    \
-                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};\
-                    using expander = int[];\
-                    (void)expander{(reg_test(Types{}, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++, 0)... };/* NOLINT */ \
-                }\
-            };\
-            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
-                TestNameClass<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
-                return 0;\
-        }();\
-        }\
-        }\
-        CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS\
-        CATCH_INTERNAL_UNSUPPRESS_ZERO_VARIADIC_WARNINGS\
-        INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
-        INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ )
-#else
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ ) )
-#endif
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... ) \
-        INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ )
-#else
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... ) \
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ ) )
-#endif
-
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2(TestNameClass, TestName, ClassName, Name, Tags, Signature, TmplTypes, TypesList)\
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
-        template<typename TestType> \
-            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
-                void test();\
-            };\
-        namespace {\
-        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestNameClass) {\
-            INTERNAL_CATCH_TYPE_GEN                  \
-            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
-            template<typename...Types>\
-            struct TestNameClass{\
-                void reg_tests(){\
-                    int index = 0;\
-                    using expander = int[];\
-                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\
-                    constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\
-                    constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\
-                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + "<" + std::string(types_list[index % num_types]) + ">", Tags } ), index++, 0)... };/* NOLINT */ \
-                }\
-            };\
-            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
-                using TestInit = decltype(create<TestNameClass, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>(TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(INTERNAL_CATCH_REMOVE_PARENS(TypesList))>{}));\
-                TestInit t;\
-                t.reg_tests();\
-                return 0;\
-            }(); \
-        }\
-        }\
-        CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS \
-        CATCH_INTERNAL_UNSUPPRESS_ZERO_VARIADIC_WARNINGS \
-        template<typename TestType> \
-        void TestName<TestType>::test()
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( ClassName, Name, Tags, ... )\
-        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, typename T, __VA_ARGS__ )
-#else
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( ClassName, Name, Tags, ... )\
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, typename T,__VA_ARGS__ ) )
-#endif
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... )\
-        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, Signature, __VA_ARGS__ )
-#else
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... )\
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, Signature,__VA_ARGS__ ) )
-#endif
-
-    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, TmplList) \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        template<typename TestType> \
-        struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
-            void test();\
-        };\
-        namespace {\
-        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
-            INTERNAL_CATCH_TYPE_GEN\
-            template<typename...Types>\
-            struct TestNameClass{\
-                void reg_tests(){\
-                    int index = 0;\
-                    using expander = int[];\
-                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ Name " - " + std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) + " - " + std::to_string(index), Tags } ), index++, 0)... };/* NOLINT */ \
-                }\
-            };\
-            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
-                using TestInit = decltype(convert<TestNameClass>(TmplList {}));\
-                TestInit t;\
-                t.reg_tests();\
-                return 0;\
-            }(); \
-        }}\
-        CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS \
-        template<typename TestType> \
-        void TestName<TestType>::test()
-
-#define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD(ClassName, Name, Tags, TmplList) \
-        INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, TmplList )
-
-// end catch_test_registry.h
-// start catch_capture.hpp
-
-// start catch_assertionhandler.h
-
-// start catch_assertioninfo.h
-
-// start catch_result_type.h
-
-namespace Catch {
-
-    // ResultWas::OfType enum
-    struct ResultWas { enum OfType {
-        Unknown = -1,
-        Ok = 0,
-        Info = 1,
-        Warning = 2,
-
-        FailureBit = 0x10,
-
-        ExpressionFailed = FailureBit | 1,
-        ExplicitFailure = FailureBit | 2,
-
-        Exception = 0x100 | FailureBit,
-
-        ThrewException = Exception | 1,
-        DidntThrowException = Exception | 2,
-
-        FatalErrorCondition = 0x200 | FailureBit
-
-    }; };
-
-    bool isOk( ResultWas::OfType resultType );
-    bool isJustInfo( int flags );
-
-    // ResultDisposition::Flags enum
-    struct ResultDisposition { enum Flags {
-        Normal = 0x01,
-
-        ContinueOnFailure = 0x02,   // Failures fail test, but execution continues
-        FalseTest = 0x04,           // Prefix expression with !
-        SuppressFail = 0x08         // Failures are reported but do not fail the test
-    }; };
-
-    ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs );
-
-    bool shouldContinueOnFailure( int flags );
-    inline bool isFalseTest( int flags ) { return ( flags & ResultDisposition::FalseTest ) != 0; }
-    bool shouldSuppressFailure( int flags );
-
-} // end namespace Catch
-
-// end catch_result_type.h
-namespace Catch {
-
-    struct AssertionInfo
-    {
-        StringRef macroName;
-        SourceLineInfo lineInfo;
-        StringRef capturedExpression;
-        ResultDisposition::Flags resultDisposition;
-
-        // We want to delete this constructor but a compiler bug in 4.8 means
-        // the struct is then treated as non-aggregate
-        //AssertionInfo() = delete;
-    };
-
-} // end namespace Catch
-
-// end catch_assertioninfo.h
-// start catch_decomposer.h
-
-// start catch_tostring.h
-
-#include <vector>
-#include <cstddef>
-#include <type_traits>
-#include <string>
-// start catch_stream.h
-
-#include <iosfwd>
-#include <cstddef>
-#include <ostream>
-
-namespace Catch {
-
-    std::ostream& cout();
-    std::ostream& cerr();
-    std::ostream& clog();
-
-    class StringRef;
-
-    struct IStream {
-        virtual ~IStream();
-        virtual std::ostream& stream() const = 0;
-    };
-
-    auto makeStream( StringRef const &filename ) -> IStream const*;
-
-    class ReusableStringStream {
-        std::size_t m_index;
-        std::ostream* m_oss;
-    public:
-        ReusableStringStream();
-        ~ReusableStringStream();
-
-        auto str() const -> std::string;
-
-        template<typename T>
-        auto operator << ( T const& value ) -> ReusableStringStream& {
-            *m_oss << value;
-            return *this;
-        }
-        auto get() -> std::ostream& { return *m_oss; }
-    };
-}
-
-// end catch_stream.h
-// start catch_interfaces_enum_values_registry.h
-
-#include <vector>
-
-namespace Catch {
-
-    namespace Detail {
-        struct EnumInfo {
-            StringRef m_name;
-            std::vector<std::pair<int, std::string>> m_values;
-
-            ~EnumInfo();
-
-            StringRef lookup( int value ) const;
-        };
-    } // namespace Detail
-
-    struct IMutableEnumValuesRegistry {
-        virtual ~IMutableEnumValuesRegistry();
-
-        virtual Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::vector<int> const& values ) = 0;
-
-        template<typename E>
-        Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::initializer_list<E> values ) {
-            std::vector<int> intValues;
-            intValues.reserve( values.size() );
-            for( auto enumValue : values )
-                intValues.push_back( static_cast<int>( enumValue ) );
-            return registerEnum( enumName, allEnums, intValues );
-        }
-    };
-
-} // Catch
-
-// end catch_interfaces_enum_values_registry.h
-
-#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
-#include <string_view>
-#endif
-
-#ifdef __OBJC__
-// start catch_objc_arc.hpp
-
-#import <Foundation/Foundation.h>
-
-#ifdef __has_feature
-#define CATCH_ARC_ENABLED __has_feature(objc_arc)
-#else
-#define CATCH_ARC_ENABLED 0
-#endif
-
-void arcSafeRelease( NSObject* obj );
-id performOptionalSelector( id obj, SEL sel );
-
-#if !CATCH_ARC_ENABLED
-inline void arcSafeRelease( NSObject* obj ) {
-    [obj release];
-}
-inline id performOptionalSelector( id obj, SEL sel ) {
-    if( [obj respondsToSelector: sel] )
-        return [obj performSelector: sel];
-    return nil;
-}
-#define CATCH_UNSAFE_UNRETAINED
-#define CATCH_ARC_STRONG
-#else
-inline void arcSafeRelease( NSObject* ){}
-inline id performOptionalSelector( id obj, SEL sel ) {
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
-#endif
-    if( [obj respondsToSelector: sel] )
-        return [obj performSelector: sel];
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-    return nil;
-}
-#define CATCH_UNSAFE_UNRETAINED __unsafe_unretained
-#define CATCH_ARC_STRONG __strong
-#endif
-
-// end catch_objc_arc.hpp
-#endif
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable:4180) // We attempt to stream a function (address) by const&, which MSVC complains about but is harmless
-#endif
-
-namespace Catch {
-    namespace Detail {
-
-        extern const std::string unprintableString;
-
-        std::string rawMemoryToString( const void *object, std::size_t size );
-
-        template<typename T>
-        std::string rawMemoryToString( const T& object ) {
-          return rawMemoryToString( &object, sizeof(object) );
-        }
-
-        template<typename T>
-        class IsStreamInsertable {
-            template<typename SS, typename TT>
-            static auto test(int)
-                -> decltype(std::declval<SS&>() << std::declval<TT>(), std::true_type());
-
-            template<typename, typename>
-            static auto test(...)->std::false_type;
-
-        public:
-            static const bool value = decltype(test<std::ostream, const T&>(0))::value;
-        };
-
-        template<typename E>
-        std::string convertUnknownEnumToString( E e );
-
-        template<typename T>
-        typename std::enable_if<
-            !std::is_enum<T>::value && !std::is_base_of<std::exception, T>::value,
-        std::string>::type convertUnstreamable( T const& ) {
-            return Detail::unprintableString;
-        }
-        template<typename T>
-        typename std::enable_if<
-            !std::is_enum<T>::value && std::is_base_of<std::exception, T>::value,
-         std::string>::type convertUnstreamable(T const& ex) {
-            return ex.what();
-        }
-
-        template<typename T>
-        typename std::enable_if<
-            std::is_enum<T>::value
-        , std::string>::type convertUnstreamable( T const& value ) {
-            return convertUnknownEnumToString( value );
-        }
-
-#if defined(_MANAGED)
-        //! Convert a CLR string to a utf8 std::string
-        template<typename T>
-        std::string clrReferenceToString( T^ ref ) {
-            if (ref == nullptr)
-                return std::string("null");
-            auto bytes = System::Text::Encoding::UTF8->GetBytes(ref->ToString());
-            cli::pin_ptr<System::Byte> p = &bytes[0];
-            return std::string(reinterpret_cast<char const *>(p), bytes->Length);
-        }
-#endif
-
-    } // namespace Detail
-
-    // If we decide for C++14, change these to enable_if_ts
-    template <typename T, typename = void>
-    struct StringMaker {
-        template <typename Fake = T>
-        static
-        typename std::enable_if<::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>::type
-            convert(const Fake& value) {
-                ReusableStringStream rss;
-                // NB: call using the function-like syntax to avoid ambiguity with
-                // user-defined templated operator<< under clang.
-                rss.operator<<(value);
-                return rss.str();
-        }
-
-        template <typename Fake = T>
-        static
-        typename std::enable_if<!::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>::type
-            convert( const Fake& value ) {
-#if !defined(CATCH_CONFIG_FALLBACK_STRINGIFIER)
-            return Detail::convertUnstreamable(value);
-#else
-            return CATCH_CONFIG_FALLBACK_STRINGIFIER(value);
-#endif
-        }
-    };
-
-    namespace Detail {
-
-        // This function dispatches all stringification requests inside of Catch.
-        // Should be preferably called fully qualified, like ::Catch::Detail::stringify
-        template <typename T>
-        std::string stringify(const T& e) {
-            return ::Catch::StringMaker<typename std::remove_cv<typename std::remove_reference<T>::type>::type>::convert(e);
-        }
-
-        template<typename E>
-        std::string convertUnknownEnumToString( E e ) {
-            return ::Catch::Detail::stringify(static_cast<typename std::underlying_type<E>::type>(e));
-        }
-
-#if defined(_MANAGED)
-        template <typename T>
-        std::string stringify( T^ e ) {
-            return ::Catch::StringMaker<T^>::convert(e);
-        }
-#endif
-
-    } // namespace Detail
-
-    // Some predefined specializations
-
-    template<>
-    struct StringMaker<std::string> {
-        static std::string convert(const std::string& str);
-    };
-
-#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
-    template<>
-    struct StringMaker<std::string_view> {
-        static std::string convert(std::string_view str);
-    };
-#endif
-
-    template<>
-    struct StringMaker<char const *> {
-        static std::string convert(char const * str);
-    };
-    template<>
-    struct StringMaker<char *> {
-        static std::string convert(char * str);
-    };
-
-#ifdef CATCH_CONFIG_WCHAR
-    template<>
-    struct StringMaker<std::wstring> {
-        static std::string convert(const std::wstring& wstr);
-    };
-
-# ifdef CATCH_CONFIG_CPP17_STRING_VIEW
-    template<>
-    struct StringMaker<std::wstring_view> {
-        static std::string convert(std::wstring_view str);
-    };
-# endif
-
-    template<>
-    struct StringMaker<wchar_t const *> {
-        static std::string convert(wchar_t const * str);
-    };
-    template<>
-    struct StringMaker<wchar_t *> {
-        static std::string convert(wchar_t * str);
-    };
-#endif
-
-    // TBD: Should we use `strnlen` to ensure that we don't go out of the buffer,
-    //      while keeping string semantics?
-    template<int SZ>
-    struct StringMaker<char[SZ]> {
-        static std::string convert(char const* str) {
-            return ::Catch::Detail::stringify(std::string{ str });
-        }
-    };
-    template<int SZ>
-    struct StringMaker<signed char[SZ]> {
-        static std::string convert(signed char const* str) {
-            return ::Catch::Detail::stringify(std::string{ reinterpret_cast<char const *>(str) });
-        }
-    };
-    template<int SZ>
-    struct StringMaker<unsigned char[SZ]> {
-        static std::string convert(unsigned char const* str) {
-            return ::Catch::Detail::stringify(std::string{ reinterpret_cast<char const *>(str) });
-        }
-    };
-
-    template<>
-    struct StringMaker<int> {
-        static std::string convert(int value);
-    };
-    template<>
-    struct StringMaker<long> {
-        static std::string convert(long value);
-    };
-    template<>
-    struct StringMaker<long long> {
-        static std::string convert(long long value);
-    };
-    template<>
-    struct StringMaker<unsigned int> {
-        static std::string convert(unsigned int value);
-    };
-    template<>
-    struct StringMaker<unsigned long> {
-        static std::string convert(unsigned long value);
-    };
-    template<>
-    struct StringMaker<unsigned long long> {
-        static std::string convert(unsigned long long value);
-    };
-
-    template<>
-    struct StringMaker<bool> {
-        static std::string convert(bool b);
-    };
-
-    template<>
-    struct StringMaker<char> {
-        static std::string convert(char c);
-    };
-    template<>
-    struct StringMaker<signed char> {
-        static std::string convert(signed char c);
-    };
-    template<>
-    struct StringMaker<unsigned char> {
-        static std::string convert(unsigned char c);
-    };
-
-    template<>
-    struct StringMaker<std::nullptr_t> {
-        static std::string convert(std::nullptr_t);
-    };
-
-    template<>
-    struct StringMaker<float> {
-        static std::string convert(float value);
-        static int precision;
-    };
-
-    template<>
-    struct StringMaker<double> {
-        static std::string convert(double value);
-        static int precision;
-    };
-
-    template <typename T>
-    struct StringMaker<T*> {
-        template <typename U>
-        static std::string convert(U* p) {
-            if (p) {
-                return ::Catch::Detail::rawMemoryToString(p);
-            } else {
-                return "nullptr";
-            }
-        }
-    };
-
-    template <typename R, typename C>
-    struct StringMaker<R C::*> {
-        static std::string convert(R C::* p) {
-            if (p) {
-                return ::Catch::Detail::rawMemoryToString(p);
-            } else {
-                return "nullptr";
-            }
-        }
-    };
-
-#if defined(_MANAGED)
-    template <typename T>
-    struct StringMaker<T^> {
-        static std::string convert( T^ ref ) {
-            return ::Catch::Detail::clrReferenceToString(ref);
-        }
-    };
-#endif
-
-    namespace Detail {
-        template<typename InputIterator>
-        std::string rangeToString(InputIterator first, InputIterator last) {
-            ReusableStringStream rss;
-            rss << "{ ";
-            if (first != last) {
-                rss << ::Catch::Detail::stringify(*first);
-                for (++first; first != last; ++first)
-                    rss << ", " << ::Catch::Detail::stringify(*first);
-            }
-            rss << " }";
-            return rss.str();
-        }
-    }
-
-#ifdef __OBJC__
-    template<>
-    struct StringMaker<NSString*> {
-        static std::string convert(NSString * nsstring) {
-            if (!nsstring)
-                return "nil";
-            return std::string("@") + [nsstring UTF8String];
-        }
-    };
-    template<>
-    struct StringMaker<NSObject*> {
-        static std::string convert(NSObject* nsObject) {
-            return ::Catch::Detail::stringify([nsObject description]);
-        }
-
-    };
-    namespace Detail {
-        inline std::string stringify( NSString* nsstring ) {
-            return StringMaker<NSString*>::convert( nsstring );
-        }
-
-    } // namespace Detail
-#endif // __OBJC__
-
-} // namespace Catch
-
-//////////////////////////////////////////////////////
-// Separate std-lib types stringification, so it can be selectively enabled
-// This means that we do not bring in
-
-#if defined(CATCH_CONFIG_ENABLE_ALL_STRINGMAKERS)
-#  define CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
-#  define CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER
-#  define CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
-#  define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
-#  define CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER
-#endif
-
-// Separate std::pair specialization
-#if defined(CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER)
-#include <utility>
-namespace Catch {
-    template<typename T1, typename T2>
-    struct StringMaker<std::pair<T1, T2> > {
-        static std::string convert(const std::pair<T1, T2>& pair) {
-            ReusableStringStream rss;
-            rss << "{ "
-                << ::Catch::Detail::stringify(pair.first)
-                << ", "
-                << ::Catch::Detail::stringify(pair.second)
-                << " }";
-            return rss.str();
-        }
-    };
-}
-#endif // CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
-
-#if defined(CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_OPTIONAL)
-#include <optional>
-namespace Catch {
-    template<typename T>
-    struct StringMaker<std::optional<T> > {
-        static std::string convert(const std::optional<T>& optional) {
-            ReusableStringStream rss;
-            if (optional.has_value()) {
-                rss << ::Catch::Detail::stringify(*optional);
-            } else {
-                rss << "{ }";
-            }
-            return rss.str();
-        }
-    };
-}
-#endif // CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER
-
-// Separate std::tuple specialization
-#if defined(CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER)
-#include <tuple>
-namespace Catch {
-    namespace Detail {
-        template<
-            typename Tuple,
-            std::size_t N = 0,
-            bool = (N < std::tuple_size<Tuple>::value)
-            >
-            struct TupleElementPrinter {
-            static void print(const Tuple& tuple, std::ostream& os) {
-                os << (N ? ", " : " ")
-                    << ::Catch::Detail::stringify(std::get<N>(tuple));
-                TupleElementPrinter<Tuple, N + 1>::print(tuple, os);
-            }
-        };
-
-        template<
-            typename Tuple,
-            std::size_t N
-        >
-            struct TupleElementPrinter<Tuple, N, false> {
-            static void print(const Tuple&, std::ostream&) {}
-        };
-
-    }
-
-    template<typename ...Types>
-    struct StringMaker<std::tuple<Types...>> {
-        static std::string convert(const std::tuple<Types...>& tuple) {
-            ReusableStringStream rss;
-            rss << '{';
-            Detail::TupleElementPrinter<std::tuple<Types...>>::print(tuple, rss.get());
-            rss << " }";
-            return rss.str();
-        }
-    };
-}
-#endif // CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER
-
-#if defined(CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_VARIANT)
-#include <variant>
-namespace Catch {
-    template<>
-    struct StringMaker<std::monostate> {
-        static std::string convert(const std::monostate&) {
-            return "{ }";
-        }
-    };
-
-    template<typename... Elements>
-    struct StringMaker<std::variant<Elements...>> {
-        static std::string convert(const std::variant<Elements...>& variant) {
-            if (variant.valueless_by_exception()) {
-                return "{valueless variant}";
-            } else {
-                return std::visit(
-                    [](const auto& value) {
-                        return ::Catch::Detail::stringify(value);
-                    },
-                    variant
-                );
-            }
-        }
-    };
-}
-#endif // CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
-
-namespace Catch {
-    struct not_this_one {}; // Tag type for detecting which begin/ end are being selected
-
-    // Import begin/ end from std here so they are considered alongside the fallback (...) overloads in this namespace
-    using std::begin;
-    using std::end;
-
-    not_this_one begin( ... );
-    not_this_one end( ... );
-
-    template <typename T>
-    struct is_range {
-        static const bool value =
-            !std::is_same<decltype(begin(std::declval<T>())), not_this_one>::value &&
-            !std::is_same<decltype(end(std::declval<T>())), not_this_one>::value;
-    };
-
-#if defined(_MANAGED) // Managed types are never ranges
-    template <typename T>
-    struct is_range<T^> {
-        static const bool value = false;
-    };
-#endif
-
-    template<typename Range>
-    std::string rangeToString( Range const& range ) {
-        return ::Catch::Detail::rangeToString( begin( range ), end( range ) );
-    }
-
-    // Handle vector<bool> specially
-    template<typename Allocator>
-    std::string rangeToString( std::vector<bool, Allocator> const& v ) {
-        ReusableStringStream rss;
-        rss << "{ ";
-        bool first = true;
-        for( bool b : v ) {
-            if( first )
-                first = false;
-            else
-                rss << ", ";
-            rss << ::Catch::Detail::stringify( b );
-        }
-        rss << " }";
-        return rss.str();
-    }
-
-    template<typename R>
-    struct StringMaker<R, typename std::enable_if<is_range<R>::value && !::Catch::Detail::IsStreamInsertable<R>::value>::type> {
-        static std::string convert( R const& range ) {
-            return rangeToString( range );
-        }
-    };
-
-    template <typename T, int SZ>
-    struct StringMaker<T[SZ]> {
-        static std::string convert(T const(&arr)[SZ]) {
-            return rangeToString(arr);
-        }
-    };
-
-} // namespace Catch
-
-// Separate std::chrono::duration specialization
-#if defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)
-#include <ctime>
-#include <ratio>
-#include <chrono>
-
-namespace Catch {
-
-template <class Ratio>
-struct ratio_string {
-    static std::string symbol();
-};
-
-template <class Ratio>
-std::string ratio_string<Ratio>::symbol() {
-    Catch::ReusableStringStream rss;
-    rss << '[' << Ratio::num << '/'
-        << Ratio::den << ']';
-    return rss.str();
-}
-template <>
-struct ratio_string<std::atto> {
-    static std::string symbol();
-};
-template <>
-struct ratio_string<std::femto> {
-    static std::string symbol();
-};
-template <>
-struct ratio_string<std::pico> {
-    static std::string symbol();
-};
-template <>
-struct ratio_string<std::nano> {
-    static std::string symbol();
-};
-template <>
-struct ratio_string<std::micro> {
-    static std::string symbol();
-};
-template <>
-struct ratio_string<std::milli> {
-    static std::string symbol();
-};
-
-    ////////////
-    // std::chrono::duration specializations
-    template<typename Value, typename Ratio>
-    struct StringMaker<std::chrono::duration<Value, Ratio>> {
-        static std::string convert(std::chrono::duration<Value, Ratio> const& duration) {
-            ReusableStringStream rss;
-            rss << duration.count() << ' ' << ratio_string<Ratio>::symbol() << 's';
-            return rss.str();
-        }
-    };
-    template<typename Value>
-    struct StringMaker<std::chrono::duration<Value, std::ratio<1>>> {
-        static std::string convert(std::chrono::duration<Value, std::ratio<1>> const& duration) {
-            ReusableStringStream rss;
-            rss << duration.count() << " s";
-            return rss.str();
-        }
-    };
-    template<typename Value>
-    struct StringMaker<std::chrono::duration<Value, std::ratio<60>>> {
-        static std::string convert(std::chrono::duration<Value, std::ratio<60>> const& duration) {
-            ReusableStringStream rss;
-            rss << duration.count() << " m";
-            return rss.str();
-        }
-    };
-    template<typename Value>
-    struct StringMaker<std::chrono::duration<Value, std::ratio<3600>>> {
-        static std::string convert(std::chrono::duration<Value, std::ratio<3600>> const& duration) {
-            ReusableStringStream rss;
-            rss << duration.count() << " h";
-            return rss.str();
-        }
-    };
-
-    ////////////
-    // std::chrono::time_point specialization
-    // Generic time_point cannot be specialized, only std::chrono::time_point<system_clock>
-    template<typename Clock, typename Duration>
-    struct StringMaker<std::chrono::time_point<Clock, Duration>> {
-        static std::string convert(std::chrono::time_point<Clock, Duration> const& time_point) {
-            return ::Catch::Detail::stringify(time_point.time_since_epoch()) + " since epoch";
-        }
-    };
-    // std::chrono::time_point<system_clock> specialization
-    template<typename Duration>
-    struct StringMaker<std::chrono::time_point<std::chrono::system_clock, Duration>> {
-        static std::string convert(std::chrono::time_point<std::chrono::system_clock, Duration> const& time_point) {
-            auto converted = std::chrono::system_clock::to_time_t(time_point);
-
-#ifdef _MSC_VER
-            std::tm timeInfo = {};
-            gmtime_s(&timeInfo, &converted);
-#else
-            std::tm* timeInfo = std::gmtime(&converted);
-#endif
-
-            auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
-            char timeStamp[timeStampSize];
-            const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";
-
-#ifdef _MSC_VER
-            std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
-#else
-            std::strftime(timeStamp, timeStampSize, fmt, timeInfo);
-#endif
-            return std::string(timeStamp);
-        }
-    };
-}
-#endif // CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
-
-#define INTERNAL_CATCH_REGISTER_ENUM( enumName, ... ) \
-namespace Catch { \
-    template<> struct StringMaker<enumName> { \
-        static std::string convert( enumName value ) { \
-            static const auto& enumInfo = ::Catch::getMutableRegistryHub().getMutableEnumValuesRegistry().registerEnum( #enumName, #__VA_ARGS__, { __VA_ARGS__ } ); \
-            return enumInfo.lookup( static_cast<int>( value ) ); \
-        } \
-    }; \
-}
-
-#define CATCH_REGISTER_ENUM( enumName, ... ) INTERNAL_CATCH_REGISTER_ENUM( enumName, __VA_ARGS__ )
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-// end catch_tostring.h
-#include <iosfwd>
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable:4389) // '==' : signed/unsigned mismatch
-#pragma warning(disable:4018) // more "signed/unsigned mismatch"
-#pragma warning(disable:4312) // Converting int to T* using reinterpret_cast (issue on x64 platform)
-#pragma warning(disable:4180) // qualifier applied to function type has no meaning
-#pragma warning(disable:4800) // Forcing result to true or false
-#endif
-
-namespace Catch {
-
-    struct ITransientExpression {
-        auto isBinaryExpression() const -> bool { return m_isBinaryExpression; }
-        auto getResult() const -> bool { return m_result; }
-        virtual void streamReconstructedExpression( std::ostream &os ) const = 0;
-
-        ITransientExpression( bool isBinaryExpression, bool result )
-        :   m_isBinaryExpression( isBinaryExpression ),
-            m_result( result )
-        {}
-
-        // We don't actually need a virtual destructor, but many static analysers
-        // complain if it's not here :-(
-        virtual ~ITransientExpression();
-
-        bool m_isBinaryExpression;
-        bool m_result;
-
-    };
-
-    void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs );
-
-    template<typename LhsT, typename RhsT>
-    class BinaryExpr  : public ITransientExpression {
-        LhsT m_lhs;
-        StringRef m_op;
-        RhsT m_rhs;
-
-        void streamReconstructedExpression( std::ostream &os ) const override {
-            formatReconstructedExpression
-                    ( os, Catch::Detail::stringify( m_lhs ), m_op, Catch::Detail::stringify( m_rhs ) );
-        }
-
-    public:
-        BinaryExpr( bool comparisonResult, LhsT lhs, StringRef op, RhsT rhs )
-        :   ITransientExpression{ true, comparisonResult },
-            m_lhs( lhs ),
-            m_op( op ),
-            m_rhs( rhs )
-        {}
-
-        template<typename T>
-        auto operator && ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename T>
-        auto operator || ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename T>
-        auto operator == ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename T>
-        auto operator != ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename T>
-        auto operator > ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename T>
-        auto operator < ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename T>
-        auto operator >= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename T>
-        auto operator <= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-    };
-
-    template<typename LhsT>
-    class UnaryExpr : public ITransientExpression {
-        LhsT m_lhs;
-
-        void streamReconstructedExpression( std::ostream &os ) const override {
-            os << Catch::Detail::stringify( m_lhs );
-        }
-
-    public:
-        explicit UnaryExpr( LhsT lhs )
-        :   ITransientExpression{ false, static_cast<bool>(lhs) },
-            m_lhs( lhs )
-        {}
-    };
-
-    // Specialised comparison functions to handle equality comparisons between ints and pointers (NULL deduces as an int)
-    template<typename LhsT, typename RhsT>
-    auto compareEqual( LhsT const& lhs, RhsT const& rhs ) -> bool { return static_cast<bool>(lhs == rhs); }
-    template<typename T>
-    auto compareEqual( T* const& lhs, int rhs ) -> bool { return lhs == reinterpret_cast<void const*>( rhs ); }
-    template<typename T>
-    auto compareEqual( T* const& lhs, long rhs ) -> bool { return lhs == reinterpret_cast<void const*>( rhs ); }
-    template<typename T>
-    auto compareEqual( int lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) == rhs; }
-    template<typename T>
-    auto compareEqual( long lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) == rhs; }
-
-    template<typename LhsT, typename RhsT>
-    auto compareNotEqual( LhsT const& lhs, RhsT&& rhs ) -> bool { return static_cast<bool>(lhs != rhs); }
-    template<typename T>
-    auto compareNotEqual( T* const& lhs, int rhs ) -> bool { return lhs != reinterpret_cast<void const*>( rhs ); }
-    template<typename T>
-    auto compareNotEqual( T* const& lhs, long rhs ) -> bool { return lhs != reinterpret_cast<void const*>( rhs ); }
-    template<typename T>
-    auto compareNotEqual( int lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) != rhs; }
-    template<typename T>
-    auto compareNotEqual( long lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) != rhs; }
-
-    template<typename LhsT>
-    class ExprLhs {
-        LhsT m_lhs;
-    public:
-        explicit ExprLhs( LhsT lhs ) : m_lhs( lhs ) {}
-
-        template<typename RhsT>
-        auto operator == ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { compareEqual( m_lhs, rhs ), m_lhs, "==", rhs };
-        }
-        auto operator == ( bool rhs ) -> BinaryExpr<LhsT, bool> const {
-            return { m_lhs == rhs, m_lhs, "==", rhs };
-        }
-
-        template<typename RhsT>
-        auto operator != ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { compareNotEqual( m_lhs, rhs ), m_lhs, "!=", rhs };
-        }
-        auto operator != ( bool rhs ) -> BinaryExpr<LhsT, bool> const {
-            return { m_lhs != rhs, m_lhs, "!=", rhs };
-        }
-
-        template<typename RhsT>
-        auto operator > ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { static_cast<bool>(m_lhs > rhs), m_lhs, ">", rhs };
-        }
-        template<typename RhsT>
-        auto operator < ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { static_cast<bool>(m_lhs < rhs), m_lhs, "<", rhs };
-        }
-        template<typename RhsT>
-        auto operator >= ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { static_cast<bool>(m_lhs >= rhs), m_lhs, ">=", rhs };
-        }
-        template<typename RhsT>
-        auto operator <= ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { static_cast<bool>(m_lhs <= rhs), m_lhs, "<=", rhs };
-        }
-
-        template<typename RhsT>
-        auto operator && ( RhsT const& ) -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<RhsT>::value,
-            "operator&& is not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename RhsT>
-        auto operator || ( RhsT const& ) -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<RhsT>::value,
-            "operator|| is not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        auto makeUnaryExpr() const -> UnaryExpr<LhsT> {
-            return UnaryExpr<LhsT>{ m_lhs };
-        }
-    };
-
-    void handleExpression( ITransientExpression const& expr );
-
-    template<typename T>
-    void handleExpression( ExprLhs<T> const& expr ) {
-        handleExpression( expr.makeUnaryExpr() );
-    }
-
-    struct Decomposer {
-        template<typename T>
-        auto operator <= ( T const& lhs ) -> ExprLhs<T const&> {
-            return ExprLhs<T const&>{ lhs };
-        }
-
-        auto operator <=( bool value ) -> ExprLhs<bool> {
-            return ExprLhs<bool>{ value };
-        }
-    };
-
-} // end namespace Catch
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-// end catch_decomposer.h
-// start catch_interfaces_capture.h
-
-#include <string>
-#include <chrono>
-
-namespace Catch {
-
-    class AssertionResult;
-    struct AssertionInfo;
-    struct SectionInfo;
-    struct SectionEndInfo;
-    struct MessageInfo;
-    struct MessageBuilder;
-    struct Counts;
-    struct AssertionReaction;
-    struct SourceLineInfo;
-
-    struct ITransientExpression;
-    struct IGeneratorTracker;
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-    struct BenchmarkInfo;
-    template <typename Duration = std::chrono::duration<double, std::nano>>
-    struct BenchmarkStats;
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-    struct IResultCapture {
-
-        virtual ~IResultCapture();
-
-        virtual bool sectionStarted(    SectionInfo const& sectionInfo,
-                                        Counts& assertions ) = 0;
-        virtual void sectionEnded( SectionEndInfo const& endInfo ) = 0;
-        virtual void sectionEndedEarly( SectionEndInfo const& endInfo ) = 0;
-
-        virtual auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& = 0;
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-        virtual void benchmarkPreparing( std::string const& name ) = 0;
-        virtual void benchmarkStarting( BenchmarkInfo const& info ) = 0;
-        virtual void benchmarkEnded( BenchmarkStats<> const& stats ) = 0;
-        virtual void benchmarkFailed( std::string const& error ) = 0;
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-        virtual void pushScopedMessage( MessageInfo const& message ) = 0;
-        virtual void popScopedMessage( MessageInfo const& message ) = 0;
-
-        virtual void emplaceUnscopedMessage( MessageBuilder const& builder ) = 0;
-
-        virtual void handleFatalErrorCondition( StringRef message ) = 0;
-
-        virtual void handleExpr
-                (   AssertionInfo const& info,
-                    ITransientExpression const& expr,
-                    AssertionReaction& reaction ) = 0;
-        virtual void handleMessage
-                (   AssertionInfo const& info,
-                    ResultWas::OfType resultType,
-                    StringRef const& message,
-                    AssertionReaction& reaction ) = 0;
-        virtual void handleUnexpectedExceptionNotThrown
-                (   AssertionInfo const& info,
-                    AssertionReaction& reaction ) = 0;
-        virtual void handleUnexpectedInflightException
-                (   AssertionInfo const& info,
-                    std::string const& message,
-                    AssertionReaction& reaction ) = 0;
-        virtual void handleIncomplete
-                (   AssertionInfo const& info ) = 0;
-        virtual void handleNonExpr
-                (   AssertionInfo const &info,
-                    ResultWas::OfType resultType,
-                    AssertionReaction &reaction ) = 0;
-
-        virtual bool lastAssertionPassed() = 0;
-        virtual void assertionPassed() = 0;
-
-        // Deprecated, do not use:
-        virtual std::string getCurrentTestName() const = 0;
-        virtual const AssertionResult* getLastResult() const = 0;
-        virtual void exceptionEarlyReported() = 0;
-    };
-
-    IResultCapture& getResultCapture();
-}
-
-// end catch_interfaces_capture.h
-namespace Catch {
-
-    struct TestFailureException{};
-    struct AssertionResultData;
-    struct IResultCapture;
-    class RunContext;
-
-    class LazyExpression {
-        friend class AssertionHandler;
-        friend struct AssertionStats;
-        friend class RunContext;
-
-        ITransientExpression const* m_transientExpression = nullptr;
-        bool m_isNegated;
-    public:
-        LazyExpression( bool isNegated );
-        LazyExpression( LazyExpression const& other );
-        LazyExpression& operator = ( LazyExpression const& ) = delete;
-
-        explicit operator bool() const;
-
-        friend auto operator << ( std::ostream& os, LazyExpression const& lazyExpr ) -> std::ostream&;
-    };
-
-    struct AssertionReaction {
-        bool shouldDebugBreak = false;
-        bool shouldThrow = false;
-    };
-
-    class AssertionHandler {
-        AssertionInfo m_assertionInfo;
-        AssertionReaction m_reaction;
-        bool m_completed = false;
-        IResultCapture& m_resultCapture;
-
-    public:
-        AssertionHandler
-            (   StringRef const& macroName,
-                SourceLineInfo const& lineInfo,
-                StringRef capturedExpression,
-                ResultDisposition::Flags resultDisposition );
-        ~AssertionHandler() {
-            if ( !m_completed ) {
-                m_resultCapture.handleIncomplete( m_assertionInfo );
-            }
-        }
-
-        template<typename T>
-        void handleExpr( ExprLhs<T> const& expr ) {
-            handleExpr( expr.makeUnaryExpr() );
-        }
-        void handleExpr( ITransientExpression const& expr );
-
-        void handleMessage(ResultWas::OfType resultType, StringRef const& message);
-
-        void handleExceptionThrownAsExpected();
-        void handleUnexpectedExceptionNotThrown();
-        void handleExceptionNotThrownAsExpected();
-        void handleThrowingCallSkipped();
-        void handleUnexpectedInflightException();
-
-        void complete();
-        void setCompleted();
-
-        // query
-        auto allowThrows() const -> bool;
-    };
-
-    void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str, StringRef const& matcherString );
-
-} // namespace Catch
-
-// end catch_assertionhandler.h
-// start catch_message.h
-
-#include <string>
-#include <vector>
-
-namespace Catch {
-
-    struct MessageInfo {
-        MessageInfo(    StringRef const& _macroName,
-                        SourceLineInfo const& _lineInfo,
-                        ResultWas::OfType _type );
-
-        StringRef macroName;
-        std::string message;
-        SourceLineInfo lineInfo;
-        ResultWas::OfType type;
-        unsigned int sequence;
-
-        bool operator == ( MessageInfo const& other ) const;
-        bool operator < ( MessageInfo const& other ) const;
-    private:
-        static unsigned int globalCount;
-    };
-
-    struct MessageStream {
-
-        template<typename T>
-        MessageStream& operator << ( T const& value ) {
-            m_stream << value;
-            return *this;
-        }
-
-        ReusableStringStream m_stream;
-    };
-
-    struct MessageBuilder : MessageStream {
-        MessageBuilder( StringRef const& macroName,
-                        SourceLineInfo const& lineInfo,
-                        ResultWas::OfType type );
-
-        template<typename T>
-        MessageBuilder& operator << ( T const& value ) {
-            m_stream << value;
-            return *this;
-        }
-
-        MessageInfo m_info;
-    };
-
-    class ScopedMessage {
-    public:
-        explicit ScopedMessage( MessageBuilder const& builder );
-        ScopedMessage( ScopedMessage& duplicate ) = delete;
-        ScopedMessage( ScopedMessage&& old );
-        ~ScopedMessage();
-
-        MessageInfo m_info;
-        bool m_moved;
-    };
-
-    class Capturer {
-        std::vector<MessageInfo> m_messages;
-        IResultCapture& m_resultCapture = getResultCapture();
-        size_t m_captured = 0;
-    public:
-        Capturer( StringRef macroName, SourceLineInfo const& lineInfo, ResultWas::OfType resultType, StringRef names );
-        ~Capturer();
-
-        void captureValue( size_t index, std::string const& value );
-
-        template<typename T>
-        void captureValues( size_t index, T const& value ) {
-            captureValue( index, Catch::Detail::stringify( value ) );
-        }
-
-        template<typename T, typename... Ts>
-        void captureValues( size_t index, T const& value, Ts const&... values ) {
-            captureValue( index, Catch::Detail::stringify(value) );
-            captureValues( index+1, values... );
-        }
-    };
-
-} // end namespace Catch
-
-// end catch_message.h
-#if !defined(CATCH_CONFIG_DISABLE)
-
-#if !defined(CATCH_CONFIG_DISABLE_STRINGIFICATION)
-  #define CATCH_INTERNAL_STRINGIFY(...) #__VA_ARGS__
-#else
-  #define CATCH_INTERNAL_STRINGIFY(...) "Disabled by CATCH_CONFIG_DISABLE_STRINGIFICATION"
-#endif
-
-#if defined(CATCH_CONFIG_FAST_COMPILE) || defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-
-///////////////////////////////////////////////////////////////////////////////
-// Another way to speed-up compilation is to omit local try-catch for REQUIRE*
-// macros.
-#define INTERNAL_CATCH_TRY
-#define INTERNAL_CATCH_CATCH( capturer )
-
-#else // CATCH_CONFIG_FAST_COMPILE
-
-#define INTERNAL_CATCH_TRY try
-#define INTERNAL_CATCH_CATCH( handler ) catch(...) { handler.handleUnexpectedInflightException(); }
-
-#endif
-
-#define INTERNAL_CATCH_REACT( handler ) handler.complete();
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_TEST( macroName, resultDisposition, ... ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
-        INTERNAL_CATCH_TRY { \
-            CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
-            catchAssertionHandler.handleExpr( Catch::Decomposer() <= __VA_ARGS__ ); \
-            CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS \
-        } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( (void)0, (false) && static_cast<bool>( !!(__VA_ARGS__) ) ) // the expression here is never evaluated at runtime but it forces the compiler to give it a look
-    // The double negation silences MSVC's C4800 warning, the static_cast forces short-circuit evaluation if the type has overloaded &&.
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_IF( macroName, resultDisposition, ... ) \
-    INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \
-    if( Catch::getResultCapture().lastAssertionPassed() )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_ELSE( macroName, resultDisposition, ... ) \
-    INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \
-    if( !Catch::getResultCapture().lastAssertionPassed() )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_NO_THROW( macroName, resultDisposition, ... ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
-        try { \
-            static_cast<void>(__VA_ARGS__); \
-            catchAssertionHandler.handleExceptionNotThrownAsExpected(); \
-        } \
-        catch( ... ) { \
-            catchAssertionHandler.handleUnexpectedInflightException(); \
-        } \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_THROWS( macroName, resultDisposition, ... ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition); \
-        if( catchAssertionHandler.allowThrows() ) \
-            try { \
-                static_cast<void>(__VA_ARGS__); \
-                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
-            } \
-            catch( ... ) { \
-                catchAssertionHandler.handleExceptionThrownAsExpected(); \
-            } \
-        else \
-            catchAssertionHandler.handleThrowingCallSkipped(); \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_THROWS_AS( macroName, exceptionType, resultDisposition, expr ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr) ", " CATCH_INTERNAL_STRINGIFY(exceptionType), resultDisposition ); \
-        if( catchAssertionHandler.allowThrows() ) \
-            try { \
-                static_cast<void>(expr); \
-                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
-            } \
-            catch( exceptionType const& ) { \
-                catchAssertionHandler.handleExceptionThrownAsExpected(); \
-            } \
-            catch( ... ) { \
-                catchAssertionHandler.handleUnexpectedInflightException(); \
-            } \
-        else \
-            catchAssertionHandler.handleThrowingCallSkipped(); \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_MSG( macroName, messageType, resultDisposition, ... ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::StringRef(), resultDisposition ); \
-        catchAssertionHandler.handleMessage( messageType, ( Catch::MessageStream() << __VA_ARGS__ + ::Catch::StreamEndStop() ).m_stream.str() ); \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_CAPTURE( varName, macroName, ... ) \
-    auto varName = Catch::Capturer( macroName, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info, #__VA_ARGS__ ); \
-    varName.captureValues( 0, __VA_ARGS__ )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_INFO( macroName, log ) \
-    Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage )( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log );
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_UNSCOPED_INFO( macroName, log ) \
-    Catch::getResultCapture().emplaceUnscopedMessage( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log )
-
-///////////////////////////////////////////////////////////////////////////////
-// Although this is matcher-based, it can be used with just a string
-#define INTERNAL_CATCH_THROWS_STR_MATCHES( macroName, resultDisposition, matcher, ... ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
-        if( catchAssertionHandler.allowThrows() ) \
-            try { \
-                static_cast<void>(__VA_ARGS__); \
-                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
-            } \
-            catch( ... ) { \
-                Catch::handleExceptionMatchExpr( catchAssertionHandler, matcher, #matcher##_catch_sr ); \
-            } \
-        else \
-            catchAssertionHandler.handleThrowingCallSkipped(); \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
-
-#endif // CATCH_CONFIG_DISABLE
-
-// end catch_capture.hpp
-// start catch_section.h
-
-// start catch_section_info.h
-
-// start catch_totals.h
-
-#include <cstddef>
-
-namespace Catch {
-
-    struct Counts {
-        Counts operator - ( Counts const& other ) const;
-        Counts& operator += ( Counts const& other );
-
-        std::size_t total() const;
-        bool allPassed() const;
-        bool allOk() const;
-
-        std::size_t passed = 0;
-        std::size_t failed = 0;
-        std::size_t failedButOk = 0;
-    };
-
-    struct Totals {
-
-        Totals operator - ( Totals const& other ) const;
-        Totals& operator += ( Totals const& other );
-
-        Totals delta( Totals const& prevTotals ) const;
-
-        int error = 0;
-        Counts assertions;
-        Counts testCases;
-    };
-}
-
-// end catch_totals.h
-#include <string>
-
-namespace Catch {
-
-    struct SectionInfo {
-        SectionInfo
-            (   SourceLineInfo const& _lineInfo,
-                std::string const& _name );
-
-        // Deprecated
-        SectionInfo
-            (   SourceLineInfo const& _lineInfo,
-                std::string const& _name,
-                std::string const& ) : SectionInfo( _lineInfo, _name ) {}
-
-        std::string name;
-        std::string description; // !Deprecated: this will always be empty
-        SourceLineInfo lineInfo;
-    };
-
-    struct SectionEndInfo {
-        SectionInfo sectionInfo;
-        Counts prevAssertions;
-        double durationInSeconds;
-    };
-
-} // end namespace Catch
-
-// end catch_section_info.h
-// start catch_timer.h
-
-#include <cstdint>
-
-namespace Catch {
-
-    auto getCurrentNanosecondsSinceEpoch() -> uint64_t;
-    auto getEstimatedClockResolution() -> uint64_t;
-
-    class Timer {
-        uint64_t m_nanoseconds = 0;
-    public:
-        void start();
-        auto getElapsedNanoseconds() const -> uint64_t;
-        auto getElapsedMicroseconds() const -> uint64_t;
-        auto getElapsedMilliseconds() const -> unsigned int;
-        auto getElapsedSeconds() const -> double;
-    };
-
-} // namespace Catch
-
-// end catch_timer.h
-#include <string>
-
-namespace Catch {
-
-    class Section : NonCopyable {
-    public:
-        Section( SectionInfo const& info );
-        ~Section();
-
-        // This indicates whether the section should be executed or not
-        explicit operator bool() const;
-
-    private:
-        SectionInfo m_info;
-
-        std::string m_name;
-        Counts m_assertions;
-        bool m_sectionIncluded;
-        Timer m_timer;
-    };
-
-} // end namespace Catch
-
-#define INTERNAL_CATCH_SECTION( ... ) \
-    CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
-    if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, __VA_ARGS__ ) ) \
-    CATCH_INTERNAL_UNSUPPRESS_UNUSED_WARNINGS
-
-#define INTERNAL_CATCH_DYNAMIC_SECTION( ... ) \
-    CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
-    if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, (Catch::ReusableStringStream() << __VA_ARGS__).str() ) ) \
-    CATCH_INTERNAL_UNSUPPRESS_UNUSED_WARNINGS
-
-// end catch_section.h
-// start catch_interfaces_exception.h
-
-// start catch_interfaces_registry_hub.h
-
-#include <string>
-#include <memory>
-
-namespace Catch {
-
-    class TestCase;
-    struct ITestCaseRegistry;
-    struct IExceptionTranslatorRegistry;
-    struct IExceptionTranslator;
-    struct IReporterRegistry;
-    struct IReporterFactory;
-    struct ITagAliasRegistry;
-    struct IMutableEnumValuesRegistry;
-
-    class StartupExceptionRegistry;
-
-    using IReporterFactoryPtr = std::shared_ptr<IReporterFactory>;
-
-    struct IRegistryHub {
-        virtual ~IRegistryHub();
-
-        virtual IReporterRegistry const& getReporterRegistry() const = 0;
-        virtual ITestCaseRegistry const& getTestCaseRegistry() const = 0;
-        virtual ITagAliasRegistry const& getTagAliasRegistry() const = 0;
-        virtual IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const = 0;
-
-        virtual StartupExceptionRegistry const& getStartupExceptionRegistry() const = 0;
-    };
-
-    struct IMutableRegistryHub {
-        virtual ~IMutableRegistryHub();
-        virtual void registerReporter( std::string const& name, IReporterFactoryPtr const& factory ) = 0;
-        virtual void registerListener( IReporterFactoryPtr const& factory ) = 0;
-        virtual void registerTest( TestCase const& testInfo ) = 0;
-        virtual void registerTranslator( const IExceptionTranslator* translator ) = 0;
-        virtual void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) = 0;
-        virtual void registerStartupException() noexcept = 0;
-        virtual IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() = 0;
-    };
-
-    IRegistryHub const& getRegistryHub();
-    IMutableRegistryHub& getMutableRegistryHub();
-    void cleanUp();
-    std::string translateActiveException();
-
-}
-
-// end catch_interfaces_registry_hub.h
-#if defined(CATCH_CONFIG_DISABLE)
-    #define INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( translatorName, signature) \
-        static std::string translatorName( signature )
-#endif
-
-#include <exception>
-#include <string>
-#include <vector>
-
-namespace Catch {
-    using exceptionTranslateFunction = std::string(*)();
-
-    struct IExceptionTranslator;
-    using ExceptionTranslators = std::vector<std::unique_ptr<IExceptionTranslator const>>;
-
-    struct IExceptionTranslator {
-        virtual ~IExceptionTranslator();
-        virtual std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const = 0;
-    };
-
-    struct IExceptionTranslatorRegistry {
-        virtual ~IExceptionTranslatorRegistry();
-
-        virtual std::string translateActiveException() const = 0;
-    };
-
-    class ExceptionTranslatorRegistrar {
-        template<typename T>
-        class ExceptionTranslator : public IExceptionTranslator {
-        public:
-
-            ExceptionTranslator( std::string(*translateFunction)( T& ) )
-            : m_translateFunction( translateFunction )
-            {}
-
-            std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const override {
-                try {
-                    if( it == itEnd )
-                        std::rethrow_exception(std::current_exception());
-                    else
-                        return (*it)->translate( it+1, itEnd );
-                }
-                catch( T& ex ) {
-                    return m_translateFunction( ex );
-                }
-            }
-
-        protected:
-            std::string(*m_translateFunction)( T& );
-        };
-
-    public:
-        template<typename T>
-        ExceptionTranslatorRegistrar( std::string(*translateFunction)( T& ) ) {
-            getMutableRegistryHub().registerTranslator
-                ( new ExceptionTranslator<T>( translateFunction ) );
-        }
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_TRANSLATE_EXCEPTION2( translatorName, signature ) \
-    static std::string translatorName( signature ); \
-    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-    namespace{ Catch::ExceptionTranslatorRegistrar INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionRegistrar )( &translatorName ); } \
-    CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS \
-    static std::string translatorName( signature )
-
-#define INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION2( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
-
-// end catch_interfaces_exception.h
-// start catch_approx.h
-
-#include <type_traits>
-
-namespace Catch {
-namespace Detail {
-
-    class Approx {
-    private:
-        bool equalityComparisonImpl(double other) const;
-        // Validates the new margin (margin >= 0)
-        // out-of-line to avoid including stdexcept in the header
-        void setMargin(double margin);
-        // Validates the new epsilon (0 < epsilon < 1)
-        // out-of-line to avoid including stdexcept in the header
-        void setEpsilon(double epsilon);
-
-    public:
-        explicit Approx ( double value );
-
-        static Approx custom();
-
-        Approx operator-() const;
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        Approx operator()( T const& value ) {
-            Approx approx( static_cast<double>(value) );
-            approx.m_epsilon = m_epsilon;
-            approx.m_margin = m_margin;
-            approx.m_scale = m_scale;
-            return approx;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        explicit Approx( T const& value ): Approx(static_cast<double>(value))
-        {}
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator == ( const T& lhs, Approx const& rhs ) {
-            auto lhs_v = static_cast<double>(lhs);
-            return rhs.equalityComparisonImpl(lhs_v);
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator == ( Approx const& lhs, const T& rhs ) {
-            return operator==( rhs, lhs );
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator != ( T const& lhs, Approx const& rhs ) {
-            return !operator==( lhs, rhs );
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator != ( Approx const& lhs, T const& rhs ) {
-            return !operator==( rhs, lhs );
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator <= ( T const& lhs, Approx const& rhs ) {
-            return static_cast<double>(lhs) < rhs.m_value || lhs == rhs;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator <= ( Approx const& lhs, T const& rhs ) {
-            return lhs.m_value < static_cast<double>(rhs) || lhs == rhs;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator >= ( T const& lhs, Approx const& rhs ) {
-            return static_cast<double>(lhs) > rhs.m_value || lhs == rhs;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator >= ( Approx const& lhs, T const& rhs ) {
-            return lhs.m_value > static_cast<double>(rhs) || lhs == rhs;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        Approx& epsilon( T const& newEpsilon ) {
-            double epsilonAsDouble = static_cast<double>(newEpsilon);
-            setEpsilon(epsilonAsDouble);
-            return *this;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        Approx& margin( T const& newMargin ) {
-            double marginAsDouble = static_cast<double>(newMargin);
-            setMargin(marginAsDouble);
-            return *this;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        Approx& scale( T const& newScale ) {
-            m_scale = static_cast<double>(newScale);
-            return *this;
-        }
-
-        std::string toString() const;
-
-    private:
-        double m_epsilon;
-        double m_margin;
-        double m_scale;
-        double m_value;
-    };
-} // end namespace Detail
-
-namespace literals {
-    Detail::Approx operator "" _a(long double val);
-    Detail::Approx operator "" _a(unsigned long long val);
-} // end namespace literals
-
-template<>
-struct StringMaker<Catch::Detail::Approx> {
-    static std::string convert(Catch::Detail::Approx const& value);
-};
-
-} // end namespace Catch
-
-// end catch_approx.h
-// start catch_string_manip.h
-
-#include <string>
-#include <iosfwd>
-#include <vector>
-
-namespace Catch {
-
-    bool startsWith( std::string const& s, std::string const& prefix );
-    bool startsWith( std::string const& s, char prefix );
-    bool endsWith( std::string const& s, std::string const& suffix );
-    bool endsWith( std::string const& s, char suffix );
-    bool contains( std::string const& s, std::string const& infix );
-    void toLowerInPlace( std::string& s );
-    std::string toLower( std::string const& s );
-    std::string trim( std::string const& str );
-
-    // !!! Be aware, returns refs into original string - make sure original string outlives them
-    std::vector<StringRef> splitStringRef( StringRef str, char delimiter );
-    bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis );
-
-    struct pluralise {
-        pluralise( std::size_t count, std::string const& label );
-
-        friend std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser );
-
-        std::size_t m_count;
-        std::string m_label;
-    };
-}
-
-// end catch_string_manip.h
-#ifndef CATCH_CONFIG_DISABLE_MATCHERS
-// start catch_capture_matchers.h
-
-// start catch_matchers.h
-
-#include <string>
-#include <vector>
-
-namespace Catch {
-namespace Matchers {
-    namespace Impl {
-
-        template<typename ArgT> struct MatchAllOf;
-        template<typename ArgT> struct MatchAnyOf;
-        template<typename ArgT> struct MatchNotOf;
-
-        class MatcherUntypedBase {
-        public:
-            MatcherUntypedBase() = default;
-            MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
-            MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = delete;
-            std::string toString() const;
-
-        protected:
-            virtual ~MatcherUntypedBase();
-            virtual std::string describe() const = 0;
-            mutable std::string m_cachedToString;
-        };
-
-#ifdef __clang__
-#    pragma clang diagnostic push
-#    pragma clang diagnostic ignored "-Wnon-virtual-dtor"
-#endif
-
-        template<typename ObjectT>
-        struct MatcherMethod {
-            virtual bool match( ObjectT const& arg ) const = 0;
-        };
-
-#ifdef __clang__
-#    pragma clang diagnostic pop
-#endif
-
-        template<typename T>
-        struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
-
-            MatchAllOf<T> operator && ( MatcherBase const& other ) const;
-            MatchAnyOf<T> operator || ( MatcherBase const& other ) const;
-            MatchNotOf<T> operator ! () const;
-        };
-
-        template<typename ArgT>
-        struct MatchAllOf : MatcherBase<ArgT> {
-            bool match( ArgT const& arg ) const override {
-                for( auto matcher : m_matchers ) {
-                    if (!matcher->match(arg))
-                        return false;
-                }
-                return true;
-            }
-            std::string describe() const override {
-                std::string description;
-                description.reserve( 4 + m_matchers.size()*32 );
-                description += "( ";
-                bool first = true;
-                for( auto matcher : m_matchers ) {
-                    if( first )
-                        first = false;
-                    else
-                        description += " and ";
-                    description += matcher->toString();
-                }
-                description += " )";
-                return description;
-            }
-
-            MatchAllOf<ArgT>& operator && ( MatcherBase<ArgT> const& other ) {
-                m_matchers.push_back( &other );
-                return *this;
-            }
-
-            std::vector<MatcherBase<ArgT> const*> m_matchers;
-        };
-        template<typename ArgT>
-        struct MatchAnyOf : MatcherBase<ArgT> {
-
-            bool match( ArgT const& arg ) const override {
-                for( auto matcher : m_matchers ) {
-                    if (matcher->match(arg))
-                        return true;
-                }
-                return false;
-            }
-            std::string describe() const override {
-                std::string description;
-                description.reserve( 4 + m_matchers.size()*32 );
-                description += "( ";
-                bool first = true;
-                for( auto matcher : m_matchers ) {
-                    if( first )
-                        first = false;
-                    else
-                        description += " or ";
-                    description += matcher->toString();
-                }
-                description += " )";
-                return description;
-            }
-
-            MatchAnyOf<ArgT>& operator || ( MatcherBase<ArgT> const& other ) {
-                m_matchers.push_back( &other );
-                return *this;
-            }
-
-            std::vector<MatcherBase<ArgT> const*> m_matchers;
-        };
-
-        template<typename ArgT>
-        struct MatchNotOf : MatcherBase<ArgT> {
-
-            MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_underlyingMatcher( underlyingMatcher ) {}
-
-            bool match( ArgT const& arg ) const override {
-                return !m_underlyingMatcher.match( arg );
-            }
-
-            std::string describe() const override {
-                return "not " + m_underlyingMatcher.toString();
-            }
-            MatcherBase<ArgT> const& m_underlyingMatcher;
-        };
-
-        template<typename T>
-        MatchAllOf<T> MatcherBase<T>::operator && ( MatcherBase const& other ) const {
-            return MatchAllOf<T>() && *this && other;
-        }
-        template<typename T>
-        MatchAnyOf<T> MatcherBase<T>::operator || ( MatcherBase const& other ) const {
-            return MatchAnyOf<T>() || *this || other;
-        }
-        template<typename T>
-        MatchNotOf<T> MatcherBase<T>::operator ! () const {
-            return MatchNotOf<T>( *this );
-        }
-
-    } // namespace Impl
-
-} // namespace Matchers
-
-using namespace Matchers;
-using Matchers::Impl::MatcherBase;
-
-} // namespace Catch
-
-// end catch_matchers.h
-// start catch_matchers_floating.h
-
-#include <type_traits>
-#include <cmath>
-
-namespace Catch {
-namespace Matchers {
-
-    namespace Floating {
-
-        enum class FloatingPointKind : uint8_t;
-
-        struct WithinAbsMatcher : MatcherBase<double> {
-            WithinAbsMatcher(double target, double margin);
-            bool match(double const& matchee) const override;
-            std::string describe() const override;
-        private:
-            double m_target;
-            double m_margin;
-        };
-
-        struct WithinUlpsMatcher : MatcherBase<double> {
-            WithinUlpsMatcher(double target, int ulps, FloatingPointKind baseType);
-            bool match(double const& matchee) const override;
-            std::string describe() const override;
-        private:
-            double m_target;
-            int m_ulps;
-            FloatingPointKind m_type;
-        };
-
-    } // namespace Floating
-
-    // The following functions create the actual matcher objects.
-    // This allows the types to be inferred
-    Floating::WithinUlpsMatcher WithinULP(double target, int maxUlpDiff);
-    Floating::WithinUlpsMatcher WithinULP(float target, int maxUlpDiff);
-    Floating::WithinAbsMatcher WithinAbs(double target, double margin);
-
-} // namespace Matchers
-} // namespace Catch
-
-// end catch_matchers_floating.h
-// start catch_matchers_generic.hpp
-
-#include <functional>
-#include <string>
-
-namespace Catch {
-namespace Matchers {
-namespace Generic {
-
-namespace Detail {
-    std::string finalizeDescription(const std::string& desc);
-}
-
-template <typename T>
-class PredicateMatcher : public MatcherBase<T> {
-    std::function<bool(T const&)> m_predicate;
-    std::string m_description;
-public:
-
-    PredicateMatcher(std::function<bool(T const&)> const& elem, std::string const& descr)
-        :m_predicate(std::move(elem)),
-        m_description(Detail::finalizeDescription(descr))
-    {}
-
-    bool match( T const& item ) const override {
-        return m_predicate(item);
-    }
-
-    std::string describe() const override {
-        return m_description;
-    }
-};
-
-} // namespace Generic
-
-    // The following functions create the actual matcher objects.
-    // The user has to explicitly specify type to the function, because
-    // inferring std::function<bool(T const&)> is hard (but possible) and
-    // requires a lot of TMP.
-    template<typename T>
-    Generic::PredicateMatcher<T> Predicate(std::function<bool(T const&)> const& predicate, std::string const& description = "") {
-        return Generic::PredicateMatcher<T>(predicate, description);
-    }
-
-} // namespace Matchers
-} // namespace Catch
-
-// end catch_matchers_generic.hpp
-// start catch_matchers_string.h
-
-#include <string>
-
-namespace Catch {
-namespace Matchers {
-
-    namespace StdString {
-
-        struct CasedString
-        {
-            CasedString( std::string const& str, CaseSensitive::Choice caseSensitivity );
-            std::string adjustString( std::string const& str ) const;
-            std::string caseSensitivitySuffix() const;
-
-            CaseSensitive::Choice m_caseSensitivity;
-            std::string m_str;
-        };
-
-        struct StringMatcherBase : MatcherBase<std::string> {
-            StringMatcherBase( std::string const& operation, CasedString const& comparator );
-            std::string describe() const override;
-
-            CasedString m_comparator;
-            std::string m_operation;
-        };
-
-        struct EqualsMatcher : StringMatcherBase {
-            EqualsMatcher( CasedString const& comparator );
-            bool match( std::string const& source ) const override;
-        };
-        struct ContainsMatcher : StringMatcherBase {
-            ContainsMatcher( CasedString const& comparator );
-            bool match( std::string const& source ) const override;
-        };
-        struct StartsWithMatcher : StringMatcherBase {
-            StartsWithMatcher( CasedString const& comparator );
-            bool match( std::string const& source ) const override;
-        };
-        struct EndsWithMatcher : StringMatcherBase {
-            EndsWithMatcher( CasedString const& comparator );
-            bool match( std::string const& source ) const override;
-        };
-
-        struct RegexMatcher : MatcherBase<std::string> {
-            RegexMatcher( std::string regex, CaseSensitive::Choice caseSensitivity );
-            bool match( std::string const& matchee ) const override;
-            std::string describe() const override;
-
-        private:
-            std::string m_regex;
-            CaseSensitive::Choice m_caseSensitivity;
-        };
-
-    } // namespace StdString
-
-    // The following functions create the actual matcher objects.
-    // This allows the types to be inferred
-
-    StdString::EqualsMatcher Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
-    StdString::ContainsMatcher Contains( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
-    StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
-    StdString::StartsWithMatcher StartsWith( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
-    StdString::RegexMatcher Matches( std::string const& regex, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
-
-} // namespace Matchers
-} // namespace Catch
-
-// end catch_matchers_string.h
-// start catch_matchers_vector.h
-
-#include <algorithm>
-
-namespace Catch {
-namespace Matchers {
-
-    namespace Vector {
-        template<typename T>
-        struct ContainsElementMatcher : MatcherBase<std::vector<T>> {
-
-            ContainsElementMatcher(T const &comparator) : m_comparator( comparator) {}
-
-            bool match(std::vector<T> const &v) const override {
-                for (auto const& el : v) {
-                    if (el == m_comparator) {
-                        return true;
-                    }
-                }
-                return false;
-            }
-
-            std::string describe() const override {
-                return "Contains: " + ::Catch::Detail::stringify( m_comparator );
-            }
-
-            T const& m_comparator;
-        };
-
-        template<typename T>
-        struct ContainsMatcher : MatcherBase<std::vector<T>> {
-
-            ContainsMatcher(std::vector<T> const &comparator) : m_comparator( comparator ) {}
-
-            bool match(std::vector<T> const &v) const override {
-                // !TBD: see note in EqualsMatcher
-                if (m_comparator.size() > v.size())
-                    return false;
-                for (auto const& comparator : m_comparator) {
-                    auto present = false;
-                    for (const auto& el : v) {
-                        if (el == comparator) {
-                            present = true;
-                            break;
-                        }
-                    }
-                    if (!present) {
-                        return false;
-                    }
-                }
-                return true;
-            }
-            std::string describe() const override {
-                return "Contains: " + ::Catch::Detail::stringify( m_comparator );
-            }
-
-            std::vector<T> const& m_comparator;
-        };
-
-        template<typename T>
-        struct EqualsMatcher : MatcherBase<std::vector<T>> {
-
-            EqualsMatcher(std::vector<T> const &comparator) : m_comparator( comparator ) {}
-
-            bool match(std::vector<T> const &v) const override {
-                // !TBD: This currently works if all elements can be compared using !=
-                // - a more general approach would be via a compare template that defaults
-                // to using !=. but could be specialised for, e.g. std::vector<T> etc
-                // - then just call that directly
-                if (m_comparator.size() != v.size())
-                    return false;
-                for (std::size_t i = 0; i < v.size(); ++i)
-                    if (m_comparator[i] != v[i])
-                        return false;
-                return true;
-            }
-            std::string describe() const override {
-                return "Equals: " + ::Catch::Detail::stringify( m_comparator );
-            }
-            std::vector<T> const& m_comparator;
-        };
-
-        template<typename T>
-        struct ApproxMatcher : MatcherBase<std::vector<T>> {
-
-            ApproxMatcher(std::vector<T> const& comparator) : m_comparator( comparator ) {}
-
-            bool match(std::vector<T> const &v) const override {
-                if (m_comparator.size() != v.size())
-                    return false;
-                for (std::size_t i = 0; i < v.size(); ++i)
-                    if (m_comparator[i] != approx(v[i]))
-                        return false;
-                return true;
-            }
-            std::string describe() const override {
-                return "is approx: " + ::Catch::Detail::stringify( m_comparator );
-            }
-            template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-            ApproxMatcher& epsilon( T const& newEpsilon ) {
-                approx.epsilon(newEpsilon);
-                return *this;
-            }
-            template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-            ApproxMatcher& margin( T const& newMargin ) {
-                approx.margin(newMargin);
-                return *this;
-            }
-            template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-            ApproxMatcher& scale( T const& newScale ) {
-                approx.scale(newScale);
-                return *this;
-            }
-
-            std::vector<T> const& m_comparator;
-            mutable Catch::Detail::Approx approx = Catch::Detail::Approx::custom();
-        };
-
-        template<typename T>
-        struct UnorderedEqualsMatcher : MatcherBase<std::vector<T>> {
-            UnorderedEqualsMatcher(std::vector<T> const& target) : m_target(target) {}
-            bool match(std::vector<T> const& vec) const override {
-                // Note: This is a reimplementation of std::is_permutation,
-                //       because I don't want to include <algorithm> inside the common path
-                if (m_target.size() != vec.size()) {
-                    return false;
-                }
-                return std::is_permutation(m_target.begin(), m_target.end(), vec.begin());
-            }
-
-            std::string describe() const override {
-                return "UnorderedEquals: " + ::Catch::Detail::stringify(m_target);
-            }
-        private:
-            std::vector<T> const& m_target;
-        };
-
-    } // namespace Vector
-
-    // The following functions create the actual matcher objects.
-    // This allows the types to be inferred
-
-    template<typename T>
-    Vector::ContainsMatcher<T> Contains( std::vector<T> const& comparator ) {
-        return Vector::ContainsMatcher<T>( comparator );
-    }
-
-    template<typename T>
-    Vector::ContainsElementMatcher<T> VectorContains( T const& comparator ) {
-        return Vector::ContainsElementMatcher<T>( comparator );
-    }
-
-    template<typename T>
-    Vector::EqualsMatcher<T> Equals( std::vector<T> const& comparator ) {
-        return Vector::EqualsMatcher<T>( comparator );
-    }
-
-    template<typename T>
-    Vector::ApproxMatcher<T> Approx( std::vector<T> const& comparator ) {
-        return Vector::ApproxMatcher<T>( comparator );
-    }
-
-    template<typename T>
-    Vector::UnorderedEqualsMatcher<T> UnorderedEquals(std::vector<T> const& target) {
-        return Vector::UnorderedEqualsMatcher<T>(target);
-    }
-
-} // namespace Matchers
-} // namespace Catch
-
-// end catch_matchers_vector.h
-namespace Catch {
-
-    template<typename ArgT, typename MatcherT>
-    class MatchExpr : public ITransientExpression {
-        ArgT const& m_arg;
-        MatcherT m_matcher;
-        StringRef m_matcherString;
-    public:
-        MatchExpr( ArgT const& arg, MatcherT const& matcher, StringRef const& matcherString )
-        :   ITransientExpression{ true, matcher.match( arg ) },
-            m_arg( arg ),
-            m_matcher( matcher ),
-            m_matcherString( matcherString )
-        {}
-
-        void streamReconstructedExpression( std::ostream &os ) const override {
-            auto matcherAsString = m_matcher.toString();
-            os << Catch::Detail::stringify( m_arg ) << ' ';
-            if( matcherAsString == Detail::unprintableString )
-                os << m_matcherString;
-            else
-                os << matcherAsString;
-        }
-    };
-
-    using StringMatcher = Matchers::Impl::MatcherBase<std::string>;
-
-    void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher, StringRef const& matcherString  );
-
-    template<typename ArgT, typename MatcherT>
-    auto makeMatchExpr( ArgT const& arg, MatcherT const& matcher, StringRef const& matcherString  ) -> MatchExpr<ArgT, MatcherT> {
-        return MatchExpr<ArgT, MatcherT>( arg, matcher, matcherString );
-    }
-
-} // namespace Catch
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CHECK_THAT( macroName, matcher, resultDisposition, arg ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(arg) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
-        INTERNAL_CATCH_TRY { \
-            catchAssertionHandler.handleExpr( Catch::makeMatchExpr( arg, matcher, #matcher##_catch_sr ) ); \
-        } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_THROWS_MATCHES( macroName, exceptionType, resultDisposition, matcher, ... ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(exceptionType) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
-        if( catchAssertionHandler.allowThrows() ) \
-            try { \
-                static_cast<void>(__VA_ARGS__ ); \
-                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
-            } \
-            catch( exceptionType const& ex ) { \
-                catchAssertionHandler.handleExpr( Catch::makeMatchExpr( ex, matcher, #matcher##_catch_sr ) ); \
-            } \
-            catch( ... ) { \
-                catchAssertionHandler.handleUnexpectedInflightException(); \
-            } \
-        else \
-            catchAssertionHandler.handleThrowingCallSkipped(); \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
-
-// end catch_capture_matchers.h
-#endif
-// start catch_generators.hpp
-
-// start catch_interfaces_generatortracker.h
-
-
-#include <memory>
-
-namespace Catch {
-
-    namespace Generators {
-        class GeneratorUntypedBase {
-        public:
-            GeneratorUntypedBase() = default;
-            virtual ~GeneratorUntypedBase();
-            // Attempts to move the generator to the next element
-             //
-             // Returns true iff the move succeeded (and a valid element
-             // can be retrieved).
-            virtual bool next() = 0;
-        };
-        using GeneratorBasePtr = std::unique_ptr<GeneratorUntypedBase>;
-
-    } // namespace Generators
-
-    struct IGeneratorTracker {
-        virtual ~IGeneratorTracker();
-        virtual auto hasGenerator() const -> bool = 0;
-        virtual auto getGenerator() const -> Generators::GeneratorBasePtr const& = 0;
-        virtual void setGenerator( Generators::GeneratorBasePtr&& generator ) = 0;
-    };
-
-} // namespace Catch
-
-// end catch_interfaces_generatortracker.h
-// start catch_enforce.h
-
-#include <exception>
-
-namespace Catch {
-#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-    template <typename Ex>
-    [[noreturn]]
-    void throw_exception(Ex const& e) {
-        throw e;
-    }
-#else // ^^ Exceptions are enabled //  Exceptions are disabled vv
-    [[noreturn]]
-    void throw_exception(std::exception const& e);
-#endif
-
-    [[noreturn]]
-    void throw_logic_error(std::string const& msg);
-    [[noreturn]]
-    void throw_domain_error(std::string const& msg);
-    [[noreturn]]
-    void throw_runtime_error(std::string const& msg);
-
-} // namespace Catch;
-
-#define CATCH_MAKE_MSG(...) \
-    (Catch::ReusableStringStream() << __VA_ARGS__).str()
-
-#define CATCH_INTERNAL_ERROR(...) \
-    Catch::throw_logic_error(CATCH_MAKE_MSG( CATCH_INTERNAL_LINEINFO << ": Internal Catch2 error: " << __VA_ARGS__));
-
-#define CATCH_ERROR(...) \
-    Catch::throw_domain_error(CATCH_MAKE_MSG( __VA_ARGS__ ));
-
-#define CATCH_RUNTIME_ERROR(...) \
-    Catch::throw_runtime_error(CATCH_MAKE_MSG( __VA_ARGS__ ));
-
-#define CATCH_ENFORCE( condition, ... ) \
-    do{ if( !(condition) ) CATCH_ERROR( __VA_ARGS__ ); } while(false)
-
-// end catch_enforce.h
-#include <memory>
-#include <vector>
-#include <cassert>
-
-#include <utility>
-#include <exception>
-
-namespace Catch {
-
-class GeneratorException : public std::exception {
-    const char* const m_msg = "";
-
-public:
-    GeneratorException(const char* msg):
-        m_msg(msg)
-    {}
-
-    const char* what() const noexcept override final;
-};
-
-namespace Generators {
-
-    // !TBD move this into its own location?
-    namespace pf{
-        template<typename T, typename... Args>
-        std::unique_ptr<T> make_unique( Args&&... args ) {
-            return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
-        }
-    }
-
-    template<typename T>
-    struct IGenerator : GeneratorUntypedBase {
-        virtual ~IGenerator() = default;
-
-        // Returns the current element of the generator
-        //
-        // \Precondition The generator is either freshly constructed,
-        // or the last call to `next()` returned true
-        virtual T const& get() const = 0;
-        using type = T;
-    };
-
-    template<typename T>
-    class SingleValueGenerator final : public IGenerator<T> {
-        T m_value;
-    public:
-        SingleValueGenerator(T const& value) : m_value( value ) {}
-        SingleValueGenerator(T&& value) : m_value(std::move(value)) {}
-
-        T const& get() const override {
-            return m_value;
-        }
-        bool next() override {
-            return false;
-        }
-    };
-
-    template<typename T>
-    class FixedValuesGenerator final : public IGenerator<T> {
-        std::vector<T> m_values;
-        size_t m_idx = 0;
-    public:
-        FixedValuesGenerator( std::initializer_list<T> values ) : m_values( values ) {}
-
-        T const& get() const override {
-            return m_values[m_idx];
-        }
-        bool next() override {
-            ++m_idx;
-            return m_idx < m_values.size();
-        }
-    };
-
-    template <typename T>
-    class GeneratorWrapper final {
-        std::unique_ptr<IGenerator<T>> m_generator;
-    public:
-        GeneratorWrapper(std::unique_ptr<IGenerator<T>> generator):
-            m_generator(std::move(generator))
-        {}
-        T const& get() const {
-            return m_generator->get();
-        }
-        bool next() {
-            return m_generator->next();
-        }
-    };
-
-    template <typename T>
-    GeneratorWrapper<T> value(T&& value) {
-        return GeneratorWrapper<T>(pf::make_unique<SingleValueGenerator<T>>(std::forward<T>(value)));
-    }
-    template <typename T>
-    GeneratorWrapper<T> values(std::initializer_list<T> values) {
-        return GeneratorWrapper<T>(pf::make_unique<FixedValuesGenerator<T>>(values));
-    }
-
-    template<typename T>
-    class Generators : public IGenerator<T> {
-        std::vector<GeneratorWrapper<T>> m_generators;
-        size_t m_current = 0;
-
-        void populate(GeneratorWrapper<T>&& generator) {
-            m_generators.emplace_back(std::move(generator));
-        }
-        void populate(T&& val) {
-            m_generators.emplace_back(value(std::move(val)));
-        }
-        template<typename U>
-        void populate(U&& val) {
-            populate(T(std::move(val)));
-        }
-        template<typename U, typename... Gs>
-        void populate(U&& valueOrGenerator, Gs... moreGenerators) {
-            populate(std::forward<U>(valueOrGenerator));
-            populate(std::forward<Gs>(moreGenerators)...);
-        }
-
-    public:
-        template <typename... Gs>
-        Generators(Gs... moreGenerators) {
-            m_generators.reserve(sizeof...(Gs));
-            populate(std::forward<Gs>(moreGenerators)...);
-        }
-
-        T const& get() const override {
-            return m_generators[m_current].get();
-        }
-
-        bool next() override {
-            if (m_current >= m_generators.size()) {
-                return false;
-            }
-            const bool current_status = m_generators[m_current].next();
-            if (!current_status) {
-                ++m_current;
-            }
-            return m_current < m_generators.size();
-        }
-    };
-
-    template<typename... Ts>
-    GeneratorWrapper<std::tuple<Ts...>> table( std::initializer_list<std::tuple<typename std::decay<Ts>::type...>> tuples ) {
-        return values<std::tuple<Ts...>>( tuples );
-    }
-
-    // Tag type to signal that a generator sequence should convert arguments to a specific type
-    template <typename T>
-    struct as {};
-
-    template<typename T, typename... Gs>
-    auto makeGenerators( GeneratorWrapper<T>&& generator, Gs... moreGenerators ) -> Generators<T> {
-        return Generators<T>(std::move(generator), std::forward<Gs>(moreGenerators)...);
-    }
-    template<typename T>
-    auto makeGenerators( GeneratorWrapper<T>&& generator ) -> Generators<T> {
-        return Generators<T>(std::move(generator));
-    }
-    template<typename T, typename... Gs>
-    auto makeGenerators( T&& val, Gs... moreGenerators ) -> Generators<T> {
-        return makeGenerators( value( std::forward<T>( val ) ), std::forward<Gs>( moreGenerators )... );
-    }
-    template<typename T, typename U, typename... Gs>
-    auto makeGenerators( as<T>, U&& val, Gs... moreGenerators ) -> Generators<T> {
-        return makeGenerators( value( T( std::forward<U>( val ) ) ), std::forward<Gs>( moreGenerators )... );
-    }
-
-    auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker&;
-
-    template<typename L>
-    // Note: The type after -> is weird, because VS2015 cannot parse
-    //       the expression used in the typedef inside, when it is in
-    //       return type. Yeah.
-    auto generate( SourceLineInfo const& lineInfo, L const& generatorExpression ) -> decltype(std::declval<decltype(generatorExpression())>().get()) {
-        using UnderlyingType = typename decltype(generatorExpression())::type;
-
-        IGeneratorTracker& tracker = acquireGeneratorTracker( lineInfo );
-        if (!tracker.hasGenerator()) {
-            tracker.setGenerator(pf::make_unique<Generators<UnderlyingType>>(generatorExpression()));
-        }
-
-        auto const& generator = static_cast<IGenerator<UnderlyingType> const&>( *tracker.getGenerator() );
-        return generator.get();
-    }
-
-} // namespace Generators
-} // namespace Catch
-
-#define GENERATE( ... ) \
-    Catch::Generators::generate( CATCH_INTERNAL_LINEINFO, [ ]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } )
-#define GENERATE_COPY( ... ) \
-    Catch::Generators::generate( CATCH_INTERNAL_LINEINFO, [=]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } )
-#define GENERATE_REF( ... ) \
-    Catch::Generators::generate( CATCH_INTERNAL_LINEINFO, [&]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } )
-
-// end catch_generators.hpp
-// start catch_generators_generic.hpp
-
-namespace Catch {
-namespace Generators {
-
-    template <typename T>
-    class TakeGenerator : public IGenerator<T> {
-        GeneratorWrapper<T> m_generator;
-        size_t m_returned = 0;
-        size_t m_target;
-    public:
-        TakeGenerator(size_t target, GeneratorWrapper<T>&& generator):
-            m_generator(std::move(generator)),
-            m_target(target)
-        {
-            assert(target != 0 && "Empty generators are not allowed");
-        }
-        T const& get() const override {
-            return m_generator.get();
-        }
-        bool next() override {
-            ++m_returned;
-            if (m_returned >= m_target) {
-                return false;
-            }
-
-            const auto success = m_generator.next();
-            // If the underlying generator does not contain enough values
-            // then we cut short as well
-            if (!success) {
-                m_returned = m_target;
-            }
-            return success;
-        }
-    };
-
-    template <typename T>
-    GeneratorWrapper<T> take(size_t target, GeneratorWrapper<T>&& generator) {
-        return GeneratorWrapper<T>(pf::make_unique<TakeGenerator<T>>(target, std::move(generator)));
-    }
-
-    template <typename T, typename Predicate>
-    class FilterGenerator : public IGenerator<T> {
-        GeneratorWrapper<T> m_generator;
-        Predicate m_predicate;
-    public:
-        template <typename P = Predicate>
-        FilterGenerator(P&& pred, GeneratorWrapper<T>&& generator):
-            m_generator(std::move(generator)),
-            m_predicate(std::forward<P>(pred))
-        {
-            if (!m_predicate(m_generator.get())) {
-                // It might happen that there are no values that pass the
-                // filter. In that case we throw an exception.
-                auto has_initial_value = next();
-                if (!has_initial_value) {
-                    Catch::throw_exception(GeneratorException("No valid value found in filtered generator"));
-                }
-            }
-        }
-
-        T const& get() const override {
-            return m_generator.get();
-        }
-
-        bool next() override {
-            bool success = m_generator.next();
-            if (!success) {
-                return false;
-            }
-            while (!m_predicate(m_generator.get()) && (success = m_generator.next()) == true);
-            return success;
-        }
-    };
-
-    template <typename T, typename Predicate>
-    GeneratorWrapper<T> filter(Predicate&& pred, GeneratorWrapper<T>&& generator) {
-        return GeneratorWrapper<T>(std::unique_ptr<IGenerator<T>>(pf::make_unique<FilterGenerator<T, Predicate>>(std::forward<Predicate>(pred), std::move(generator))));
-    }
-
-    template <typename T>
-    class RepeatGenerator : public IGenerator<T> {
-        GeneratorWrapper<T> m_generator;
-        mutable std::vector<T> m_returned;
-        size_t m_target_repeats;
-        size_t m_current_repeat = 0;
-        size_t m_repeat_index = 0;
-    public:
-        RepeatGenerator(size_t repeats, GeneratorWrapper<T>&& generator):
-            m_generator(std::move(generator)),
-            m_target_repeats(repeats)
-        {
-            assert(m_target_repeats > 0 && "Repeat generator must repeat at least once");
-        }
-
-        T const& get() const override {
-            if (m_current_repeat == 0) {
-                m_returned.push_back(m_generator.get());
-                return m_returned.back();
-            }
-            return m_returned[m_repeat_index];
-        }
-
-        bool next() override {
-            // There are 2 basic cases:
-            // 1) We are still reading the generator
-            // 2) We are reading our own cache
-
-            // In the first case, we need to poke the underlying generator.
-            // If it happily moves, we are left in that state, otherwise it is time to start reading from our cache
-            if (m_current_repeat == 0) {
-                const auto success = m_generator.next();
-                if (!success) {
-                    ++m_current_repeat;
-                }
-                return m_current_repeat < m_target_repeats;
-            }
-
-            // In the second case, we need to move indices forward and check that we haven't run up against the end
-            ++m_repeat_index;
-            if (m_repeat_index == m_returned.size()) {
-                m_repeat_index = 0;
-                ++m_current_repeat;
-            }
-            return m_current_repeat < m_target_repeats;
-        }
-    };
-
-    template <typename T>
-    GeneratorWrapper<T> repeat(size_t repeats, GeneratorWrapper<T>&& generator) {
-        return GeneratorWrapper<T>(pf::make_unique<RepeatGenerator<T>>(repeats, std::move(generator)));
-    }
-
-    template <typename T, typename U, typename Func>
-    class MapGenerator : public IGenerator<T> {
-        // TBD: provide static assert for mapping function, for friendly error message
-        GeneratorWrapper<U> m_generator;
-        Func m_function;
-        // To avoid returning dangling reference, we have to save the values
-        T m_cache;
-    public:
-        template <typename F2 = Func>
-        MapGenerator(F2&& function, GeneratorWrapper<U>&& generator) :
-            m_generator(std::move(generator)),
-            m_function(std::forward<F2>(function)),
-            m_cache(m_function(m_generator.get()))
-        {}
-
-        T const& get() const override {
-            return m_cache;
-        }
-        bool next() override {
-            const auto success = m_generator.next();
-            if (success) {
-                m_cache = m_function(m_generator.get());
-            }
-            return success;
-        }
-    };
-
-#if defined(__cpp_lib_is_invocable) && __cpp_lib_is_invocable >= 201703
-    // std::result_of is deprecated in C++17 and removed in C++20. Hence, it is
-    // replaced with std::invoke_result here. Also *_t format is preferred over
-    // typename *::type format.
-    template <typename Func, typename U>
-    using MapFunctionReturnType = std::remove_reference_t<std::remove_cv_t<std::invoke_result_t<Func, U>>>;
-#else
-    template <typename Func, typename U>
-    using MapFunctionReturnType = typename std::remove_reference<typename std::remove_cv<typename std::result_of<Func(U)>::type>::type>::type;
-#endif
-
-    template <typename Func, typename U, typename T = MapFunctionReturnType<Func, U>>
-    GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& generator) {
-        return GeneratorWrapper<T>(
-            pf::make_unique<MapGenerator<T, U, Func>>(std::forward<Func>(function), std::move(generator))
-        );
-    }
-
-    template <typename T, typename U, typename Func>
-    GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& generator) {
-        return GeneratorWrapper<T>(
-            pf::make_unique<MapGenerator<T, U, Func>>(std::forward<Func>(function), std::move(generator))
-        );
-    }
-
-    template <typename T>
-    class ChunkGenerator final : public IGenerator<std::vector<T>> {
-        std::vector<T> m_chunk;
-        size_t m_chunk_size;
-        GeneratorWrapper<T> m_generator;
-        bool m_used_up = false;
-    public:
-        ChunkGenerator(size_t size, GeneratorWrapper<T> generator) :
-            m_chunk_size(size), m_generator(std::move(generator))
-        {
-            m_chunk.reserve(m_chunk_size);
-            m_chunk.push_back(m_generator.get());
-            for (size_t i = 1; i < m_chunk_size; ++i) {
-                if (!m_generator.next()) {
-                    Catch::throw_exception(GeneratorException("Not enough values to initialize the first chunk"));
-                }
-                m_chunk.push_back(m_generator.get());
-            }
-        }
-        std::vector<T> const& get() const override {
-            return m_chunk;
-        }
-        bool next() override {
-            m_chunk.clear();
-            for (size_t idx = 0; idx < m_chunk_size; ++idx) {
-                if (!m_generator.next()) {
-                    return false;
-                }
-                m_chunk.push_back(m_generator.get());
-            }
-            return true;
-        }
-    };
-
-    template <typename T>
-    GeneratorWrapper<std::vector<T>> chunk(size_t size, GeneratorWrapper<T>&& generator) {
-        return GeneratorWrapper<std::vector<T>>(
-            pf::make_unique<ChunkGenerator<T>>(size, std::move(generator))
-        );
-    }
-
-} // namespace Generators
-} // namespace Catch
-
-// end catch_generators_generic.hpp
-// start catch_generators_specific.hpp
-
-// start catch_context.h
-
-#include <memory>
-
-namespace Catch {
-
-    struct IResultCapture;
-    struct IRunner;
-    struct IConfig;
-    struct IMutableContext;
-
-    using IConfigPtr = std::shared_ptr<IConfig const>;
-
-    struct IContext
-    {
-        virtual ~IContext();
-
-        virtual IResultCapture* getResultCapture() = 0;
-        virtual IRunner* getRunner() = 0;
-        virtual IConfigPtr const& getConfig() const = 0;
-    };
-
-    struct IMutableContext : IContext
-    {
-        virtual ~IMutableContext();
-        virtual void setResultCapture( IResultCapture* resultCapture ) = 0;
-        virtual void setRunner( IRunner* runner ) = 0;
-        virtual void setConfig( IConfigPtr const& config ) = 0;
-
-    private:
-        static IMutableContext *currentContext;
-        friend IMutableContext& getCurrentMutableContext();
-        friend void cleanUpContext();
-        static void createContext();
-    };
-
-    inline IMutableContext& getCurrentMutableContext()
-    {
-        if( !IMutableContext::currentContext )
-            IMutableContext::createContext();
-        return *IMutableContext::currentContext;
-    }
-
-    inline IContext& getCurrentContext()
-    {
-        return getCurrentMutableContext();
-    }
-
-    void cleanUpContext();
-}
-
-// end catch_context.h
-// start catch_interfaces_config.h
-
-// start catch_option.hpp
-
-namespace Catch {
-
-    // An optional type
-    template<typename T>
-    class Option {
-    public:
-        Option() : nullableValue( nullptr ) {}
-        Option( T const& _value )
-        : nullableValue( new( storage ) T( _value ) )
-        {}
-        Option( Option const& _other )
-        : nullableValue( _other ? new( storage ) T( *_other ) : nullptr )
-        {}
-
-        ~Option() {
-            reset();
-        }
-
-        Option& operator= ( Option const& _other ) {
-            if( &_other != this ) {
-                reset();
-                if( _other )
-                    nullableValue = new( storage ) T( *_other );
-            }
-            return *this;
-        }
-        Option& operator = ( T const& _value ) {
-            reset();
-            nullableValue = new( storage ) T( _value );
-            return *this;
-        }
-
-        void reset() {
-            if( nullableValue )
-                nullableValue->~T();
-            nullableValue = nullptr;
-        }
-
-        T& operator*() { return *nullableValue; }
-        T const& operator*() const { return *nullableValue; }
-        T* operator->() { return nullableValue; }
-        const T* operator->() const { return nullableValue; }
-
-        T valueOr( T const& defaultValue ) const {
-            return nullableValue ? *nullableValue : defaultValue;
-        }
-
-        bool some() const { return nullableValue != nullptr; }
-        bool none() const { return nullableValue == nullptr; }
-
-        bool operator !() const { return nullableValue == nullptr; }
-        explicit operator bool() const {
-            return some();
-        }
-
-    private:
-        T *nullableValue;
-        alignas(alignof(T)) char storage[sizeof(T)];
-    };
-
-} // end namespace Catch
-
-// end catch_option.hpp
-#include <iosfwd>
-#include <string>
-#include <vector>
-#include <memory>
-
-namespace Catch {
-
-    enum class Verbosity {
-        Quiet = 0,
-        Normal,
-        High
-    };
-
-    struct WarnAbout { enum What {
-        Nothing = 0x00,
-        NoAssertions = 0x01,
-        NoTests = 0x02
-    }; };
-
-    struct ShowDurations { enum OrNot {
-        DefaultForReporter,
-        Always,
-        Never
-    }; };
-    struct RunTests { enum InWhatOrder {
-        InDeclarationOrder,
-        InLexicographicalOrder,
-        InRandomOrder
-    }; };
-    struct UseColour { enum YesOrNo {
-        Auto,
-        Yes,
-        No
-    }; };
-    struct WaitForKeypress { enum When {
-        Never,
-        BeforeStart = 1,
-        BeforeExit = 2,
-        BeforeStartAndExit = BeforeStart | BeforeExit
-    }; };
-
-    class TestSpec;
-
-    struct IConfig : NonCopyable {
-
-        virtual ~IConfig();
-
-        virtual bool allowThrows() const = 0;
-        virtual std::ostream& stream() const = 0;
-        virtual std::string name() const = 0;
-        virtual bool includeSuccessfulResults() const = 0;
-        virtual bool shouldDebugBreak() const = 0;
-        virtual bool warnAboutMissingAssertions() const = 0;
-        virtual bool warnAboutNoTests() const = 0;
-        virtual int abortAfter() const = 0;
-        virtual bool showInvisibles() const = 0;
-        virtual ShowDurations::OrNot showDurations() const = 0;
-        virtual TestSpec const& testSpec() const = 0;
-        virtual bool hasTestFilters() const = 0;
-        virtual std::vector<std::string> const& getTestsOrTags() const = 0;
-        virtual RunTests::InWhatOrder runOrder() const = 0;
-        virtual unsigned int rngSeed() const = 0;
-        virtual UseColour::YesOrNo useColour() const = 0;
-        virtual std::vector<std::string> const& getSectionsToRun() const = 0;
-        virtual Verbosity verbosity() const = 0;
-
-        virtual bool benchmarkNoAnalysis() const = 0;
-        virtual int benchmarkSamples() const = 0;
-        virtual double benchmarkConfidenceInterval() const = 0;
-        virtual unsigned int benchmarkResamples() const = 0;
-    };
-
-    using IConfigPtr = std::shared_ptr<IConfig const>;
-}
-
-// end catch_interfaces_config.h
-#include <random>
-
-namespace Catch {
-namespace Generators {
-
-template <typename Float>
-class RandomFloatingGenerator final : public IGenerator<Float> {
-    // FIXME: What is the right seed?
-    std::minstd_rand m_rand;
-    std::uniform_real_distribution<Float> m_dist;
-    Float m_current_number;
-public:
-
-    RandomFloatingGenerator(Float a, Float b):
-        m_rand(getCurrentContext().getConfig()->rngSeed()),
-        m_dist(a, b) {
-        static_cast<void>(next());
-    }
-
-    Float const& get() const override {
-        return m_current_number;
-    }
-    bool next() override {
-        m_current_number = m_dist(m_rand);
-        return true;
-    }
-};
-
-template <typename Integer>
-class RandomIntegerGenerator final : public IGenerator<Integer> {
-    std::minstd_rand m_rand;
-    std::uniform_int_distribution<Integer> m_dist;
-    Integer m_current_number;
-public:
-
-    RandomIntegerGenerator(Integer a, Integer b):
-        m_rand(getCurrentContext().getConfig()->rngSeed()),
-        m_dist(a, b) {
-        static_cast<void>(next());
-    }
-
-    Integer const& get() const override {
-        return m_current_number;
-    }
-    bool next() override {
-        m_current_number = m_dist(m_rand);
-        return true;
-    }
-};
-
-// TODO: Ideally this would be also constrained against the various char types,
-//       but I don't expect users to run into that in practice.
-template <typename T>
-typename std::enable_if<std::is_integral<T>::value && !std::is_same<T, bool>::value,
-GeneratorWrapper<T>>::type
-random(T a, T b) {
-    return GeneratorWrapper<T>(
-        pf::make_unique<RandomIntegerGenerator<T>>(a, b)
-    );
-}
-
-template <typename T>
-typename std::enable_if<std::is_floating_point<T>::value,
-GeneratorWrapper<T>>::type
-random(T a, T b) {
-    return GeneratorWrapper<T>(
-        pf::make_unique<RandomFloatingGenerator<T>>(a, b)
-    );
-}
-
-template <typename T>
-class RangeGenerator final : public IGenerator<T> {
-    T m_current;
-    T m_end;
-    T m_step;
-    bool m_positive;
-
-public:
-    RangeGenerator(T const& start, T const& end, T const& step):
-        m_current(start),
-        m_end(end),
-        m_step(step),
-        m_positive(m_step > T(0))
-    {
-        assert(m_current != m_end && "Range start and end cannot be equal");
-        assert(m_step != T(0) && "Step size cannot be zero");
-        assert(((m_positive && m_current <= m_end) || (!m_positive && m_current >= m_end)) && "Step moves away from end");
-    }
-
-    RangeGenerator(T const& start, T const& end):
-        RangeGenerator(start, end, (start < end) ? T(1) : T(-1))
-    {}
-
-    T const& get() const override {
-        return m_current;
-    }
-
-    bool next() override {
-        m_current += m_step;
-        return (m_positive) ? (m_current < m_end) : (m_current > m_end);
-    }
-};
-
-template <typename T>
-GeneratorWrapper<T> range(T const& start, T const& end, T const& step) {
-    static_assert(std::is_integral<T>::value && !std::is_same<T, bool>::value, "Type must be an integer");
-    return GeneratorWrapper<T>(pf::make_unique<RangeGenerator<T>>(start, end, step));
-}
-
-template <typename T>
-GeneratorWrapper<T> range(T const& start, T const& end) {
-    static_assert(std::is_integral<T>::value && !std::is_same<T, bool>::value, "Type must be an integer");
-    return GeneratorWrapper<T>(pf::make_unique<RangeGenerator<T>>(start, end));
-}
-
-} // namespace Generators
-} // namespace Catch
-
-// end catch_generators_specific.hpp
-
-// These files are included here so the single_include script doesn't put them
-// in the conditionally compiled sections
-// start catch_test_case_info.h
-
-#include <string>
-#include <vector>
-#include <memory>
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wpadded"
-#endif
-
-namespace Catch {
-
-    struct ITestInvoker;
-
-    struct TestCaseInfo {
-        enum SpecialProperties{
-            None = 0,
-            IsHidden = 1 << 1,
-            ShouldFail = 1 << 2,
-            MayFail = 1 << 3,
-            Throws = 1 << 4,
-            NonPortable = 1 << 5,
-            Benchmark = 1 << 6
-        };
-
-        TestCaseInfo(   std::string const& _name,
-                        std::string const& _className,
-                        std::string const& _description,
-                        std::vector<std::string> const& _tags,
-                        SourceLineInfo const& _lineInfo );
-
-        friend void setTags( TestCaseInfo& testCaseInfo, std::vector<std::string> tags );
-
-        bool isHidden() const;
-        bool throws() const;
-        bool okToFail() const;
-        bool expectedToFail() const;
-
-        std::string tagsAsString() const;
-
-        std::string name;
-        std::string className;
-        std::string description;
-        std::vector<std::string> tags;
-        std::vector<std::string> lcaseTags;
-        SourceLineInfo lineInfo;
-        SpecialProperties properties;
-    };
-
-    class TestCase : public TestCaseInfo {
-    public:
-
-        TestCase( ITestInvoker* testCase, TestCaseInfo&& info );
-
-        TestCase withName( std::string const& _newName ) const;
-
-        void invoke() const;
-
-        TestCaseInfo const& getTestCaseInfo() const;
-
-        bool operator == ( TestCase const& other ) const;
-        bool operator < ( TestCase const& other ) const;
-
-    private:
-        std::shared_ptr<ITestInvoker> test;
-    };
-
-    TestCase makeTestCase(  ITestInvoker* testCase,
-                            std::string const& className,
-                            NameAndTags const& nameAndTags,
-                            SourceLineInfo const& lineInfo );
-}
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
-// end catch_test_case_info.h
-// start catch_interfaces_runner.h
-
-namespace Catch {
-
-    struct IRunner {
-        virtual ~IRunner();
-        virtual bool aborting() const = 0;
-    };
-}
-
-// end catch_interfaces_runner.h
-
-#ifdef __OBJC__
-// start catch_objc.hpp
-
-#import <objc/runtime.h>
-
-#include <string>
-
-// NB. Any general catch headers included here must be included
-// in catch.hpp first to make sure they are included by the single
-// header for non obj-usage
-
-///////////////////////////////////////////////////////////////////////////////
-// This protocol is really only here for (self) documenting purposes, since
-// all its methods are optional.
-@protocol OcFixture
-
-@optional
-
--(void) setUp;
--(void) tearDown;
-
-@end
-
-namespace Catch {
-
-    class OcMethod : public ITestInvoker {
-
-    public:
-        OcMethod( Class cls, SEL sel ) : m_cls( cls ), m_sel( sel ) {}
-
-        virtual void invoke() const {
-            id obj = [[m_cls alloc] init];
-
-            performOptionalSelector( obj, @selector(setUp)  );
-            performOptionalSelector( obj, m_sel );
-            performOptionalSelector( obj, @selector(tearDown)  );
-
-            arcSafeRelease( obj );
-        }
-    private:
-        virtual ~OcMethod() {}
-
-        Class m_cls;
-        SEL m_sel;
-    };
-
-    namespace Detail{
-
-        inline std::string getAnnotation(   Class cls,
-                                            std::string const& annotationName,
-                                            std::string const& testCaseName ) {
-            NSString* selStr = [[NSString alloc] initWithFormat:@"Catch_%s_%s", annotationName.c_str(), testCaseName.c_str()];
-            SEL sel = NSSelectorFromString( selStr );
-            arcSafeRelease( selStr );
-            id value = performOptionalSelector( cls, sel );
-            if( value )
-                return [(NSString*)value UTF8String];
-            return "";
-        }
-    }
-
-    inline std::size_t registerTestMethods() {
-        std::size_t noTestMethods = 0;
-        int noClasses = objc_getClassList( nullptr, 0 );
-
-        Class* classes = (CATCH_UNSAFE_UNRETAINED Class *)malloc( sizeof(Class) * noClasses);
-        objc_getClassList( classes, noClasses );
-
-        for( int c = 0; c < noClasses; c++ ) {
-            Class cls = classes[c];
-            {
-                u_int count;
-                Method* methods = class_copyMethodList( cls, &count );
-                for( u_int m = 0; m < count ; m++ ) {
-                    SEL selector = method_getName(methods[m]);
-                    std::string methodName = sel_getName(selector);
-                    if( startsWith( methodName, "Catch_TestCase_" ) ) {
-                        std::string testCaseName = methodName.substr( 15 );
-                        std::string name = Detail::getAnnotation( cls, "Name", testCaseName );
-                        std::string desc = Detail::getAnnotation( cls, "Description", testCaseName );
-                        const char* className = class_getName( cls );
-
-                        getMutableRegistryHub().registerTest( makeTestCase( new OcMethod( cls, selector ), className, NameAndTags( name.c_str(), desc.c_str() ), SourceLineInfo("",0) ) );
-                        noTestMethods++;
-                    }
-                }
-                free(methods);
-            }
-        }
-        return noTestMethods;
-    }
-
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-
-    namespace Matchers {
-        namespace Impl {
-        namespace NSStringMatchers {
-
-            struct StringHolder : MatcherBase<NSString*>{
-                StringHolder( NSString* substr ) : m_substr( [substr copy] ){}
-                StringHolder( StringHolder const& other ) : m_substr( [other.m_substr copy] ){}
-                StringHolder() {
-                    arcSafeRelease( m_substr );
-                }
-
-                bool match( NSString* const& str ) const override {
-                    return false;
-                }
-
-                NSString* CATCH_ARC_STRONG m_substr;
-            };
-
-            struct Equals : StringHolder {
-                Equals( NSString* substr ) : StringHolder( substr ){}
-
-                bool match( NSString* const& str ) const override {
-                    return  (str != nil || m_substr == nil ) &&
-                            [str isEqualToString:m_substr];
-                }
-
-                std::string describe() const override {
-                    return "equals string: " + Catch::Detail::stringify( m_substr );
-                }
-            };
-
-            struct Contains : StringHolder {
-                Contains( NSString* substr ) : StringHolder( substr ){}
-
-                bool match( NSString* const& str ) const override {
-                    return  (str != nil || m_substr == nil ) &&
-                            [str rangeOfString:m_substr].location != NSNotFound;
-                }
-
-                std::string describe() const override {
-                    return "contains string: " + Catch::Detail::stringify( m_substr );
-                }
-            };
-
-            struct StartsWith : StringHolder {
-                StartsWith( NSString* substr ) : StringHolder( substr ){}
-
-                bool match( NSString* const& str ) const override {
-                    return  (str != nil || m_substr == nil ) &&
-                            [str rangeOfString:m_substr].location == 0;
-                }
-
-                std::string describe() const override {
-                    return "starts with: " + Catch::Detail::stringify( m_substr );
-                }
-            };
-            struct EndsWith : StringHolder {
-                EndsWith( NSString* substr ) : StringHolder( substr ){}
-
-                bool match( NSString* const& str ) const override {
-                    return  (str != nil || m_substr == nil ) &&
-                            [str rangeOfString:m_substr].location == [str length] - [m_substr length];
-                }
-
-                std::string describe() const override {
-                    return "ends with: " + Catch::Detail::stringify( m_substr );
-                }
-            };
-
-        } // namespace NSStringMatchers
-        } // namespace Impl
-
-        inline Impl::NSStringMatchers::Equals
-            Equals( NSString* substr ){ return Impl::NSStringMatchers::Equals( substr ); }
-
-        inline Impl::NSStringMatchers::Contains
-            Contains( NSString* substr ){ return Impl::NSStringMatchers::Contains( substr ); }
-
-        inline Impl::NSStringMatchers::StartsWith
-            StartsWith( NSString* substr ){ return Impl::NSStringMatchers::StartsWith( substr ); }
-
-        inline Impl::NSStringMatchers::EndsWith
-            EndsWith( NSString* substr ){ return Impl::NSStringMatchers::EndsWith( substr ); }
-
-    } // namespace Matchers
-
-    using namespace Matchers;
-
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-
-} // namespace Catch
-
-///////////////////////////////////////////////////////////////////////////////
-#define OC_MAKE_UNIQUE_NAME( root, uniqueSuffix ) root##uniqueSuffix
-#define OC_TEST_CASE2( name, desc, uniqueSuffix ) \
-+(NSString*) OC_MAKE_UNIQUE_NAME( Catch_Name_test_, uniqueSuffix ) \
-{ \
-return @ name; \
-} \
-+(NSString*) OC_MAKE_UNIQUE_NAME( Catch_Description_test_, uniqueSuffix ) \
-{ \
-return @ desc; \
-} \
--(void) OC_MAKE_UNIQUE_NAME( Catch_TestCase_test_, uniqueSuffix )
-
-#define OC_TEST_CASE( name, desc ) OC_TEST_CASE2( name, desc, __LINE__ )
-
-// end catch_objc.hpp
-#endif
-
-// Benchmarking needs the externally-facing parts of reporters to work
-#if defined(CATCH_CONFIG_EXTERNAL_INTERFACES) || defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-// start catch_external_interfaces.h
-
-// start catch_reporter_bases.hpp
-
-// start catch_interfaces_reporter.h
-
-// start catch_config.hpp
-
-// start catch_test_spec_parser.h
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wpadded"
-#endif
-
-// start catch_test_spec.h
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wpadded"
-#endif
-
-// start catch_wildcard_pattern.h
-
-namespace Catch
-{
-    class WildcardPattern {
-        enum WildcardPosition {
-            NoWildcard = 0,
-            WildcardAtStart = 1,
-            WildcardAtEnd = 2,
-            WildcardAtBothEnds = WildcardAtStart | WildcardAtEnd
-        };
-
-    public:
-
-        WildcardPattern( std::string const& pattern, CaseSensitive::Choice caseSensitivity );
-        virtual ~WildcardPattern() = default;
-        virtual bool matches( std::string const& str ) const;
-
-    private:
-        std::string adjustCase( std::string const& str ) const;
-        CaseSensitive::Choice m_caseSensitivity;
-        WildcardPosition m_wildcard = NoWildcard;
-        std::string m_pattern;
-    };
-}
-
-// end catch_wildcard_pattern.h
-#include <string>
-#include <vector>
-#include <memory>
-
-namespace Catch {
-
-    class TestSpec {
-        struct Pattern {
-            virtual ~Pattern();
-            virtual bool matches( TestCaseInfo const& testCase ) const = 0;
-        };
-        using PatternPtr = std::shared_ptr<Pattern>;
-
-        class NamePattern : public Pattern {
-        public:
-            NamePattern( std::string const& name );
-            virtual ~NamePattern();
-            bool matches( TestCaseInfo const& testCase ) const override;
-        private:
-            WildcardPattern m_wildcardPattern;
-        };
-
-        class TagPattern : public Pattern {
-        public:
-            TagPattern( std::string const& tag );
-            virtual ~TagPattern();
-            bool matches( TestCaseInfo const& testCase ) const override;
-        private:
-            std::string m_tag;
-        };
-
-        class ExcludedPattern : public Pattern {
-        public:
-            ExcludedPattern( PatternPtr const& underlyingPattern );
-            virtual ~ExcludedPattern();
-            bool matches( TestCaseInfo const& testCase ) const override;
-        private:
-            PatternPtr m_underlyingPattern;
-        };
-
-        struct Filter {
-            std::vector<PatternPtr> m_patterns;
-
-            bool matches( TestCaseInfo const& testCase ) const;
-        };
-
-    public:
-        bool hasFilters() const;
-        bool matches( TestCaseInfo const& testCase ) const;
-
-    private:
-        std::vector<Filter> m_filters;
-
-        friend class TestSpecParser;
-    };
-}
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
-// end catch_test_spec.h
-// start catch_interfaces_tag_alias_registry.h
-
-#include <string>
-
-namespace Catch {
-
-    struct TagAlias;
-
-    struct ITagAliasRegistry {
-        virtual ~ITagAliasRegistry();
-        // Nullptr if not present
-        virtual TagAlias const* find( std::string const& alias ) const = 0;
-        virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const = 0;
-
-        static ITagAliasRegistry const& get();
-    };
-
-} // end namespace Catch
-
-// end catch_interfaces_tag_alias_registry.h
-namespace Catch {
-
-    class TestSpecParser {
-        enum Mode{ None, Name, QuotedName, Tag, EscapedName };
-        Mode m_mode = None;
-        bool m_exclusion = false;
-        std::size_t m_start = std::string::npos, m_pos = 0;
-        std::string m_arg;
-        std::vector<std::size_t> m_escapeChars;
-        TestSpec::Filter m_currentFilter;
-        TestSpec m_testSpec;
-        ITagAliasRegistry const* m_tagAliases = nullptr;
-
-    public:
-        TestSpecParser( ITagAliasRegistry const& tagAliases );
-
-        TestSpecParser& parse( std::string const& arg );
-        TestSpec testSpec();
-
-    private:
-        void visitChar( char c );
-        void startNewMode( Mode mode, std::size_t start );
-        void escape();
-        std::string subString() const;
-
-        template<typename T>
-        void addPattern() {
-            std::string token = subString();
-            for( std::size_t i = 0; i < m_escapeChars.size(); ++i )
-                token = token.substr( 0, m_escapeChars[i]-m_start-i ) + token.substr( m_escapeChars[i]-m_start-i+1 );
-            m_escapeChars.clear();
-            if( startsWith( token, "exclude:" ) ) {
-                m_exclusion = true;
-                token = token.substr( 8 );
-            }
-            if( !token.empty() ) {
-                TestSpec::PatternPtr pattern = std::make_shared<T>( token );
-                if( m_exclusion )
-                    pattern = std::make_shared<TestSpec::ExcludedPattern>( pattern );
-                m_currentFilter.m_patterns.push_back( pattern );
-            }
-            m_exclusion = false;
-            m_mode = None;
-        }
-
-        void addFilter();
-    };
-    TestSpec parseTestSpec( std::string const& arg );
-
-} // namespace Catch
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
-// end catch_test_spec_parser.h
-// Libstdc++ doesn't like incomplete classes for unique_ptr
-
-#include <memory>
-#include <vector>
-#include <string>
-
-#ifndef CATCH_CONFIG_CONSOLE_WIDTH
-#define CATCH_CONFIG_CONSOLE_WIDTH 80
-#endif
-
-namespace Catch {
-
-    struct IStream;
-
-    struct ConfigData {
-        bool listTests = false;
-        bool listTags = false;
-        bool listReporters = false;
-        bool listTestNamesOnly = false;
-
-        bool showSuccessfulTests = false;
-        bool shouldDebugBreak = false;
-        bool noThrow = false;
-        bool showHelp = false;
-        bool showInvisibles = false;
-        bool filenamesAsTags = false;
-        bool libIdentify = false;
-
-        int abortAfter = -1;
-        unsigned int rngSeed = 0;
-
-        bool benchmarkNoAnalysis = false;
-        unsigned int benchmarkSamples = 100;
-        double benchmarkConfidenceInterval = 0.95;
-        unsigned int benchmarkResamples = 100000;
-
-        Verbosity verbosity = Verbosity::Normal;
-        WarnAbout::What warnings = WarnAbout::Nothing;
-        ShowDurations::OrNot showDurations = ShowDurations::DefaultForReporter;
-        RunTests::InWhatOrder runOrder = RunTests::InDeclarationOrder;
-        UseColour::YesOrNo useColour = UseColour::Auto;
-        WaitForKeypress::When waitForKeypress = WaitForKeypress::Never;
-
-        std::string outputFilename;
-        std::string name;
-        std::string processName;
-#ifndef CATCH_CONFIG_DEFAULT_REPORTER
-#define CATCH_CONFIG_DEFAULT_REPORTER "console"
-#endif
-        std::string reporterName = CATCH_CONFIG_DEFAULT_REPORTER;
-#undef CATCH_CONFIG_DEFAULT_REPORTER
-
-        std::vector<std::string> testsOrTags;
-        std::vector<std::string> sectionsToRun;
-    };
-
-    class Config : public IConfig {
-    public:
-
-        Config() = default;
-        Config( ConfigData const& data );
-        virtual ~Config() = default;
-
-        std::string const& getFilename() const;
-
-        bool listTests() const;
-        bool listTestNamesOnly() const;
-        bool listTags() const;
-        bool listReporters() const;
-
-        std::string getProcessName() const;
-        std::string const& getReporterName() const;
-
-        std::vector<std::string> const& getTestsOrTags() const override;
-        std::vector<std::string> const& getSectionsToRun() const override;
-
-        TestSpec const& testSpec() const override;
-        bool hasTestFilters() const override;
-
-        bool showHelp() const;
-
-        // IConfig interface
-        bool allowThrows() const override;
-        std::ostream& stream() const override;
-        std::string name() const override;
-        bool includeSuccessfulResults() const override;
-        bool warnAboutMissingAssertions() const override;
-        bool warnAboutNoTests() const override;
-        ShowDurations::OrNot showDurations() const override;
-        RunTests::InWhatOrder runOrder() const override;
-        unsigned int rngSeed() const override;
-        UseColour::YesOrNo useColour() const override;
-        bool shouldDebugBreak() const override;
-        int abortAfter() const override;
-        bool showInvisibles() const override;
-        Verbosity verbosity() const override;
-        bool benchmarkNoAnalysis() const override;
-        int benchmarkSamples() const override;
-        double benchmarkConfidenceInterval() const override;
-        unsigned int benchmarkResamples() const override;
-
-    private:
-
-        IStream const* openStream();
-        ConfigData m_data;
-
-        std::unique_ptr<IStream const> m_stream;
-        TestSpec m_testSpec;
-        bool m_hasTestFilters = false;
-    };
-
-} // end namespace Catch
-
-// end catch_config.hpp
-// start catch_assertionresult.h
-
-#include <string>
-
-namespace Catch {
-
-    struct AssertionResultData
-    {
-        AssertionResultData() = delete;
-
-        AssertionResultData( ResultWas::OfType _resultType, LazyExpression const& _lazyExpression );
-
-        std::string message;
-        mutable std::string reconstructedExpression;
-        LazyExpression lazyExpression;
-        ResultWas::OfType resultType;
-
-        std::string reconstructExpression() const;
-    };
-
-    class AssertionResult {
-    public:
-        AssertionResult() = delete;
-        AssertionResult( AssertionInfo const& info, AssertionResultData const& data );
-
-        bool isOk() const;
-        bool succeeded() const;
-        ResultWas::OfType getResultType() const;
-        bool hasExpression() const;
-        bool hasMessage() const;
-        std::string getExpression() const;
-        std::string getExpressionInMacro() const;
-        bool hasExpandedExpression() const;
-        std::string getExpandedExpression() const;
-        std::string getMessage() const;
-        SourceLineInfo getSourceInfo() const;
-        StringRef getTestMacroName() const;
-
-    //protected:
-        AssertionInfo m_info;
-        AssertionResultData m_resultData;
-    };
-
-} // end namespace Catch
-
-// end catch_assertionresult.h
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-// start catch_estimate.hpp
-
- // Statistics estimates
-
-
-namespace Catch {
-    namespace Benchmark {
-        template <typename Duration>
-        struct Estimate {
-            Duration point;
-            Duration lower_bound;
-            Duration upper_bound;
-            double confidence_interval;
-
-            template <typename Duration2>
-            operator Estimate<Duration2>() const {
-                return { point, lower_bound, upper_bound, confidence_interval };
-            }
-        };
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_estimate.hpp
-// start catch_outlier_classification.hpp
-
-// Outlier information
-
-namespace Catch {
-    namespace Benchmark {
-        struct OutlierClassification {
-            int samples_seen = 0;
-            int low_severe = 0;     // more than 3 times IQR below Q1
-            int low_mild = 0;       // 1.5 to 3 times IQR below Q1
-            int high_mild = 0;      // 1.5 to 3 times IQR above Q3
-            int high_severe = 0;    // more than 3 times IQR above Q3
-
-            int total() const {
-                return low_severe + low_mild + high_mild + high_severe;
-            }
-        };
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_outlier_classification.hpp
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-#include <string>
-#include <iosfwd>
-#include <map>
-#include <set>
-#include <memory>
-#include <algorithm>
-
-namespace Catch {
-
-    struct ReporterConfig {
-        explicit ReporterConfig( IConfigPtr const& _fullConfig );
-
-        ReporterConfig( IConfigPtr const& _fullConfig, std::ostream& _stream );
-
-        std::ostream& stream() const;
-        IConfigPtr fullConfig() const;
-
-    private:
-        std::ostream* m_stream;
-        IConfigPtr m_fullConfig;
-    };
-
-    struct ReporterPreferences {
-        bool shouldRedirectStdOut = false;
-        bool shouldReportAllAssertions = false;
-    };
-
-    template<typename T>
-    struct LazyStat : Option<T> {
-        LazyStat& operator=( T const& _value ) {
-            Option<T>::operator=( _value );
-            used = false;
-            return *this;
-        }
-        void reset() {
-            Option<T>::reset();
-            used = false;
-        }
-        bool used = false;
-    };
-
-    struct TestRunInfo {
-        TestRunInfo( std::string const& _name );
-        std::string name;
-    };
-    struct GroupInfo {
-        GroupInfo(  std::string const& _name,
-                    std::size_t _groupIndex,
-                    std::size_t _groupsCount );
-
-        std::string name;
-        std::size_t groupIndex;
-        std::size_t groupsCounts;
-    };
-
-    struct AssertionStats {
-        AssertionStats( AssertionResult const& _assertionResult,
-                        std::vector<MessageInfo> const& _infoMessages,
-                        Totals const& _totals );
-
-        AssertionStats( AssertionStats const& )              = default;
-        AssertionStats( AssertionStats && )                  = default;
-        AssertionStats& operator = ( AssertionStats const& ) = delete;
-        AssertionStats& operator = ( AssertionStats && )     = delete;
-        virtual ~AssertionStats();
-
-        AssertionResult assertionResult;
-        std::vector<MessageInfo> infoMessages;
-        Totals totals;
-    };
-
-    struct SectionStats {
-        SectionStats(   SectionInfo const& _sectionInfo,
-                        Counts const& _assertions,
-                        double _durationInSeconds,
-                        bool _missingAssertions );
-        SectionStats( SectionStats const& )              = default;
-        SectionStats( SectionStats && )                  = default;
-        SectionStats& operator = ( SectionStats const& ) = default;
-        SectionStats& operator = ( SectionStats && )     = default;
-        virtual ~SectionStats();
-
-        SectionInfo sectionInfo;
-        Counts assertions;
-        double durationInSeconds;
-        bool missingAssertions;
-    };
-
-    struct TestCaseStats {
-        TestCaseStats(  TestCaseInfo const& _testInfo,
-                        Totals const& _totals,
-                        std::string const& _stdOut,
-                        std::string const& _stdErr,
-                        bool _aborting );
-
-        TestCaseStats( TestCaseStats const& )              = default;
-        TestCaseStats( TestCaseStats && )                  = default;
-        TestCaseStats& operator = ( TestCaseStats const& ) = default;
-        TestCaseStats& operator = ( TestCaseStats && )     = default;
-        virtual ~TestCaseStats();
-
-        TestCaseInfo testInfo;
-        Totals totals;
-        std::string stdOut;
-        std::string stdErr;
-        bool aborting;
-    };
-
-    struct TestGroupStats {
-        TestGroupStats( GroupInfo const& _groupInfo,
-                        Totals const& _totals,
-                        bool _aborting );
-        TestGroupStats( GroupInfo const& _groupInfo );
-
-        TestGroupStats( TestGroupStats const& )              = default;
-        TestGroupStats( TestGroupStats && )                  = default;
-        TestGroupStats& operator = ( TestGroupStats const& ) = default;
-        TestGroupStats& operator = ( TestGroupStats && )     = default;
-        virtual ~TestGroupStats();
-
-        GroupInfo groupInfo;
-        Totals totals;
-        bool aborting;
-    };
-
-    struct TestRunStats {
-        TestRunStats(   TestRunInfo const& _runInfo,
-                        Totals const& _totals,
-                        bool _aborting );
-
-        TestRunStats( TestRunStats const& )              = default;
-        TestRunStats( TestRunStats && )                  = default;
-        TestRunStats& operator = ( TestRunStats const& ) = default;
-        TestRunStats& operator = ( TestRunStats && )     = default;
-        virtual ~TestRunStats();
-
-        TestRunInfo runInfo;
-        Totals totals;
-        bool aborting;
-    };
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-    struct BenchmarkInfo {
-        std::string name;
-        double estimatedDuration;
-        int iterations;
-        int samples;
-        unsigned int resamples;
-        double clockResolution;
-        double clockCost;
-    };
-
-    template <class Duration>
-    struct BenchmarkStats {
-        BenchmarkInfo info;
-
-        std::vector<Duration> samples;
-        Benchmark::Estimate<Duration> mean;
-        Benchmark::Estimate<Duration> standardDeviation;
-        Benchmark::OutlierClassification outliers;
-        double outlierVariance;
-
-        template <typename Duration2>
-        operator BenchmarkStats<Duration2>() const {
-            std::vector<Duration2> samples2;
-            samples2.reserve(samples.size());
-            std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](Duration d) { return Duration2(d); });
-            return {
-                info,
-                std::move(samples2),
-                mean,
-                standardDeviation,
-                outliers,
-                outlierVariance,
-            };
-        }
-    };
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-    struct IStreamingReporter {
-        virtual ~IStreamingReporter() = default;
-
-        // Implementing class must also provide the following static methods:
-        // static std::string getDescription();
-        // static std::set<Verbosity> getSupportedVerbosities()
-
-        virtual ReporterPreferences getPreferences() const = 0;
-
-        virtual void noMatchingTestCases( std::string const& spec ) = 0;
-
-        virtual void testRunStarting( TestRunInfo const& testRunInfo ) = 0;
-        virtual void testGroupStarting( GroupInfo const& groupInfo ) = 0;
-
-        virtual void testCaseStarting( TestCaseInfo const& testInfo ) = 0;
-        virtual void sectionStarting( SectionInfo const& sectionInfo ) = 0;
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-        virtual void benchmarkPreparing( std::string const& ) {}
-        virtual void benchmarkStarting( BenchmarkInfo const& ) {}
-        virtual void benchmarkEnded( BenchmarkStats<> const& ) {}
-        virtual void benchmarkFailed( std::string const& ) {}
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-        virtual void assertionStarting( AssertionInfo const& assertionInfo ) = 0;
-
-        // The return value indicates if the messages buffer should be cleared:
-        virtual bool assertionEnded( AssertionStats const& assertionStats ) = 0;
-
-        virtual void sectionEnded( SectionStats const& sectionStats ) = 0;
-        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) = 0;
-        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) = 0;
-        virtual void testRunEnded( TestRunStats const& testRunStats ) = 0;
-
-        virtual void skipTest( TestCaseInfo const& testInfo ) = 0;
-
-        // Default empty implementation provided
-        virtual void fatalErrorEncountered( StringRef name );
-
-        virtual bool isMulti() const;
-    };
-    using IStreamingReporterPtr = std::unique_ptr<IStreamingReporter>;
-
-    struct IReporterFactory {
-        virtual ~IReporterFactory();
-        virtual IStreamingReporterPtr create( ReporterConfig const& config ) const = 0;
-        virtual std::string getDescription() const = 0;
-    };
-    using IReporterFactoryPtr = std::shared_ptr<IReporterFactory>;
-
-    struct IReporterRegistry {
-        using FactoryMap = std::map<std::string, IReporterFactoryPtr>;
-        using Listeners = std::vector<IReporterFactoryPtr>;
-
-        virtual ~IReporterRegistry();
-        virtual IStreamingReporterPtr create( std::string const& name, IConfigPtr const& config ) const = 0;
-        virtual FactoryMap const& getFactories() const = 0;
-        virtual Listeners const& getListeners() const = 0;
-    };
-
-} // end namespace Catch
-
-// end catch_interfaces_reporter.h
-#include <algorithm>
-#include <cstring>
-#include <cfloat>
-#include <cstdio>
-#include <cassert>
-#include <memory>
-#include <ostream>
-
-namespace Catch {
-    void prepareExpandedExpression(AssertionResult& result);
-
-    // Returns double formatted as %.3f (format expected on output)
-    std::string getFormattedDuration( double duration );
-
-    std::string serializeFilters( std::vector<std::string> const& container );
-
-    template<typename DerivedT>
-    struct StreamingReporterBase : IStreamingReporter {
-
-        StreamingReporterBase( ReporterConfig const& _config )
-        :   m_config( _config.fullConfig() ),
-            stream( _config.stream() )
-        {
-            m_reporterPrefs.shouldRedirectStdOut = false;
-            if( !DerivedT::getSupportedVerbosities().count( m_config->verbosity() ) )
-                CATCH_ERROR( "Verbosity level not supported by this reporter" );
-        }
-
-        ReporterPreferences getPreferences() const override {
-            return m_reporterPrefs;
-        }
-
-        static std::set<Verbosity> getSupportedVerbosities() {
-            return { Verbosity::Normal };
-        }
-
-        ~StreamingReporterBase() override = default;
-
-        void noMatchingTestCases(std::string const&) override {}
-
-        void testRunStarting(TestRunInfo const& _testRunInfo) override {
-            currentTestRunInfo = _testRunInfo;
-        }
-
-        void testGroupStarting(GroupInfo const& _groupInfo) override {
-            currentGroupInfo = _groupInfo;
-        }
-
-        void testCaseStarting(TestCaseInfo const& _testInfo) override  {
-            currentTestCaseInfo = _testInfo;
-        }
-        void sectionStarting(SectionInfo const& _sectionInfo) override {
-            m_sectionStack.push_back(_sectionInfo);
-        }
-
-        void sectionEnded(SectionStats const& /* _sectionStats */) override {
-            m_sectionStack.pop_back();
-        }
-        void testCaseEnded(TestCaseStats const& /* _testCaseStats */) override {
-            currentTestCaseInfo.reset();
-        }
-        void testGroupEnded(TestGroupStats const& /* _testGroupStats */) override {
-            currentGroupInfo.reset();
-        }
-        void testRunEnded(TestRunStats const& /* _testRunStats */) override {
-            currentTestCaseInfo.reset();
-            currentGroupInfo.reset();
-            currentTestRunInfo.reset();
-        }
-
-        void skipTest(TestCaseInfo const&) override {
-            // Don't do anything with this by default.
-            // It can optionally be overridden in the derived class.
-        }
-
-        IConfigPtr m_config;
-        std::ostream& stream;
-
-        LazyStat<TestRunInfo> currentTestRunInfo;
-        LazyStat<GroupInfo> currentGroupInfo;
-        LazyStat<TestCaseInfo> currentTestCaseInfo;
-
-        std::vector<SectionInfo> m_sectionStack;
-        ReporterPreferences m_reporterPrefs;
-    };
-
-    template<typename DerivedT>
-    struct CumulativeReporterBase : IStreamingReporter {
-        template<typename T, typename ChildNodeT>
-        struct Node {
-            explicit Node( T const& _value ) : value( _value ) {}
-            virtual ~Node() {}
-
-            using ChildNodes = std::vector<std::shared_ptr<ChildNodeT>>;
-            T value;
-            ChildNodes children;
-        };
-        struct SectionNode {
-            explicit SectionNode(SectionStats const& _stats) : stats(_stats) {}
-            virtual ~SectionNode() = default;
-
-            bool operator == (SectionNode const& other) const {
-                return stats.sectionInfo.lineInfo == other.stats.sectionInfo.lineInfo;
-            }
-            bool operator == (std::shared_ptr<SectionNode> const& other) const {
-                return operator==(*other);
-            }
-
-            SectionStats stats;
-            using ChildSections = std::vector<std::shared_ptr<SectionNode>>;
-            using Assertions = std::vector<AssertionStats>;
-            ChildSections childSections;
-            Assertions assertions;
-            std::string stdOut;
-            std::string stdErr;
-        };
-
-        struct BySectionInfo {
-            BySectionInfo( SectionInfo const& other ) : m_other( other ) {}
-            BySectionInfo( BySectionInfo const& other ) : m_other( other.m_other ) {}
-            bool operator() (std::shared_ptr<SectionNode> const& node) const {
-                return ((node->stats.sectionInfo.name == m_other.name) &&
-                        (node->stats.sectionInfo.lineInfo == m_other.lineInfo));
-            }
-            void operator=(BySectionInfo const&) = delete;
-
-        private:
-            SectionInfo const& m_other;
-        };
-
-        using TestCaseNode = Node<TestCaseStats, SectionNode>;
-        using TestGroupNode = Node<TestGroupStats, TestCaseNode>;
-        using TestRunNode = Node<TestRunStats, TestGroupNode>;
-
-        CumulativeReporterBase( ReporterConfig const& _config )
-        :   m_config( _config.fullConfig() ),
-            stream( _config.stream() )
-        {
-            m_reporterPrefs.shouldRedirectStdOut = false;
-            if( !DerivedT::getSupportedVerbosities().count( m_config->verbosity() ) )
-                CATCH_ERROR( "Verbosity level not supported by this reporter" );
-        }
-        ~CumulativeReporterBase() override = default;
-
-        ReporterPreferences getPreferences() const override {
-            return m_reporterPrefs;
-        }
-
-        static std::set<Verbosity> getSupportedVerbosities() {
-            return { Verbosity::Normal };
-        }
-
-        void testRunStarting( TestRunInfo const& ) override {}
-        void testGroupStarting( GroupInfo const& ) override {}
-
-        void testCaseStarting( TestCaseInfo const& ) override {}
-
-        void sectionStarting( SectionInfo const& sectionInfo ) override {
-            SectionStats incompleteStats( sectionInfo, Counts(), 0, false );
-            std::shared_ptr<SectionNode> node;
-            if( m_sectionStack.empty() ) {
-                if( !m_rootSection )
-                    m_rootSection = std::make_shared<SectionNode>( incompleteStats );
-                node = m_rootSection;
-            }
-            else {
-                SectionNode& parentNode = *m_sectionStack.back();
-                auto it =
-                    std::find_if(   parentNode.childSections.begin(),
-                                    parentNode.childSections.end(),
-                                    BySectionInfo( sectionInfo ) );
-                if( it == parentNode.childSections.end() ) {
-                    node = std::make_shared<SectionNode>( incompleteStats );
-                    parentNode.childSections.push_back( node );
-                }
-                else
-                    node = *it;
-            }
-            m_sectionStack.push_back( node );
-            m_deepestSection = std::move(node);
-        }
-
-        void assertionStarting(AssertionInfo const&) override {}
-
-        bool assertionEnded(AssertionStats const& assertionStats) override {
-            assert(!m_sectionStack.empty());
-            // AssertionResult holds a pointer to a temporary DecomposedExpression,
-            // which getExpandedExpression() calls to build the expression string.
-            // Our section stack copy of the assertionResult will likely outlive the
-            // temporary, so it must be expanded or discarded now to avoid calling
-            // a destroyed object later.
-            prepareExpandedExpression(const_cast<AssertionResult&>( assertionStats.assertionResult ) );
-            SectionNode& sectionNode = *m_sectionStack.back();
-            sectionNode.assertions.push_back(assertionStats);
-            return true;
-        }
-        void sectionEnded(SectionStats const& sectionStats) override {
-            assert(!m_sectionStack.empty());
-            SectionNode& node = *m_sectionStack.back();
-            node.stats = sectionStats;
-            m_sectionStack.pop_back();
-        }
-        void testCaseEnded(TestCaseStats const& testCaseStats) override {
-            auto node = std::make_shared<TestCaseNode>(testCaseStats);
-            assert(m_sectionStack.size() == 0);
-            node->children.push_back(m_rootSection);
-            m_testCases.push_back(node);
-            m_rootSection.reset();
-
-            assert(m_deepestSection);
-            m_deepestSection->stdOut = testCaseStats.stdOut;
-            m_deepestSection->stdErr = testCaseStats.stdErr;
-        }
-        void testGroupEnded(TestGroupStats const& testGroupStats) override {
-            auto node = std::make_shared<TestGroupNode>(testGroupStats);
-            node->children.swap(m_testCases);
-            m_testGroups.push_back(node);
-        }
-        void testRunEnded(TestRunStats const& testRunStats) override {
-            auto node = std::make_shared<TestRunNode>(testRunStats);
-            node->children.swap(m_testGroups);
-            m_testRuns.push_back(node);
-            testRunEndedCumulative();
-        }
-        virtual void testRunEndedCumulative() = 0;
-
-        void skipTest(TestCaseInfo const&) override {}
-
-        IConfigPtr m_config;
-        std::ostream& stream;
-        std::vector<AssertionStats> m_assertions;
-        std::vector<std::vector<std::shared_ptr<SectionNode>>> m_sections;
-        std::vector<std::shared_ptr<TestCaseNode>> m_testCases;
-        std::vector<std::shared_ptr<TestGroupNode>> m_testGroups;
-
-        std::vector<std::shared_ptr<TestRunNode>> m_testRuns;
-
-        std::shared_ptr<SectionNode> m_rootSection;
-        std::shared_ptr<SectionNode> m_deepestSection;
-        std::vector<std::shared_ptr<SectionNode>> m_sectionStack;
-        ReporterPreferences m_reporterPrefs;
-    };
-
-    template<char C>
-    char const* getLineOfChars() {
-        static char line[CATCH_CONFIG_CONSOLE_WIDTH] = {0};
-        if( !*line ) {
-            std::memset( line, C, CATCH_CONFIG_CONSOLE_WIDTH-1 );
-            line[CATCH_CONFIG_CONSOLE_WIDTH-1] = 0;
-        }
-        return line;
-    }
-
-    struct TestEventListenerBase : StreamingReporterBase<TestEventListenerBase> {
-        TestEventListenerBase( ReporterConfig const& _config );
-
-        static std::set<Verbosity> getSupportedVerbosities();
-
-        void assertionStarting(AssertionInfo const&) override;
-        bool assertionEnded(AssertionStats const&) override;
-    };
-
-} // end namespace Catch
-
-// end catch_reporter_bases.hpp
-// start catch_console_colour.h
-
-namespace Catch {
-
-    struct Colour {
-        enum Code {
-            None = 0,
-
-            White,
-            Red,
-            Green,
-            Blue,
-            Cyan,
-            Yellow,
-            Grey,
-
-            Bright = 0x10,
-
-            BrightRed = Bright | Red,
-            BrightGreen = Bright | Green,
-            LightGrey = Bright | Grey,
-            BrightWhite = Bright | White,
-            BrightYellow = Bright | Yellow,
-
-            // By intention
-            FileName = LightGrey,
-            Warning = BrightYellow,
-            ResultError = BrightRed,
-            ResultSuccess = BrightGreen,
-            ResultExpectedFailure = Warning,
-
-            Error = BrightRed,
-            Success = Green,
-
-            OriginalExpression = Cyan,
-            ReconstructedExpression = BrightYellow,
-
-            SecondaryText = LightGrey,
-            Headers = White
-        };
-
-        // Use constructed object for RAII guard
-        Colour( Code _colourCode );
-        Colour( Colour&& other ) noexcept;
-        Colour& operator=( Colour&& other ) noexcept;
-        ~Colour();
-
-        // Use static method for one-shot changes
-        static void use( Code _colourCode );
-
-    private:
-        bool m_moved = false;
-    };
-
-    std::ostream& operator << ( std::ostream& os, Colour const& );
-
-} // end namespace Catch
-
-// end catch_console_colour.h
-// start catch_reporter_registrars.hpp
-
-
-namespace Catch {
-
-    template<typename T>
-    class ReporterRegistrar {
-
-        class ReporterFactory : public IReporterFactory {
-
-            IStreamingReporterPtr create( ReporterConfig const& config ) const override {
-                return std::unique_ptr<T>( new T( config ) );
-            }
-
-            std::string getDescription() const override {
-                return T::getDescription();
-            }
-        };
-
-    public:
-
-        explicit ReporterRegistrar( std::string const& name ) {
-            getMutableRegistryHub().registerReporter( name, std::make_shared<ReporterFactory>() );
-        }
-    };
-
-    template<typename T>
-    class ListenerRegistrar {
-
-        class ListenerFactory : public IReporterFactory {
-
-            IStreamingReporterPtr create( ReporterConfig const& config ) const override {
-                return std::unique_ptr<T>( new T( config ) );
-            }
-            std::string getDescription() const override {
-                return std::string();
-            }
-        };
-
-    public:
-
-        ListenerRegistrar() {
-            getMutableRegistryHub().registerListener( std::make_shared<ListenerFactory>() );
-        }
-    };
-}
-
-#if !defined(CATCH_CONFIG_DISABLE)
-
-#define CATCH_REGISTER_REPORTER( name, reporterType ) \
-    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS          \
-    namespace{ Catch::ReporterRegistrar<reporterType> catch_internal_RegistrarFor##reporterType( name ); } \
-    CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS
-
-#define CATCH_REGISTER_LISTENER( listenerType ) \
-     CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS   \
-     namespace{ Catch::ListenerRegistrar<listenerType> catch_internal_RegistrarFor##listenerType; } \
-     CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
-#else // CATCH_CONFIG_DISABLE
-
-#define CATCH_REGISTER_REPORTER(name, reporterType)
-#define CATCH_REGISTER_LISTENER(listenerType)
-
-#endif // CATCH_CONFIG_DISABLE
-
-// end catch_reporter_registrars.hpp
-// Allow users to base their work off existing reporters
-// start catch_reporter_compact.h
-
-namespace Catch {
-
-    struct CompactReporter : StreamingReporterBase<CompactReporter> {
-
-        using StreamingReporterBase::StreamingReporterBase;
-
-        ~CompactReporter() override;
-
-        static std::string getDescription();
-
-        ReporterPreferences getPreferences() const override;
-
-        void noMatchingTestCases(std::string const& spec) override;
-
-        void assertionStarting(AssertionInfo const&) override;
-
-        bool assertionEnded(AssertionStats const& _assertionStats) override;
-
-        void sectionEnded(SectionStats const& _sectionStats) override;
-
-        void testRunEnded(TestRunStats const& _testRunStats) override;
-
-    };
-
-} // end namespace Catch
-
-// end catch_reporter_compact.h
-// start catch_reporter_console.h
-
-#if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
-                              // Note that 4062 (not all labels are handled
-                              // and default is missing) is enabled
-#endif
-
-namespace Catch {
-    // Fwd decls
-    struct SummaryColumn;
-    class TablePrinter;
-
-    struct ConsoleReporter : StreamingReporterBase<ConsoleReporter> {
-        std::unique_ptr<TablePrinter> m_tablePrinter;
-
-        ConsoleReporter(ReporterConfig const& config);
-        ~ConsoleReporter() override;
-        static std::string getDescription();
-
-        void noMatchingTestCases(std::string const& spec) override;
-
-        void assertionStarting(AssertionInfo const&) override;
-
-        bool assertionEnded(AssertionStats const& _assertionStats) override;
-
-        void sectionStarting(SectionInfo const& _sectionInfo) override;
-        void sectionEnded(SectionStats const& _sectionStats) override;
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-        void benchmarkPreparing(std::string const& name) override;
-        void benchmarkStarting(BenchmarkInfo const& info) override;
-        void benchmarkEnded(BenchmarkStats<> const& stats) override;
-        void benchmarkFailed(std::string const& error) override;
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-        void testCaseEnded(TestCaseStats const& _testCaseStats) override;
-        void testGroupEnded(TestGroupStats const& _testGroupStats) override;
-        void testRunEnded(TestRunStats const& _testRunStats) override;
-        void testRunStarting(TestRunInfo const& _testRunInfo) override;
-    private:
-
-        void lazyPrint();
-
-        void lazyPrintWithoutClosingBenchmarkTable();
-        void lazyPrintRunInfo();
-        void lazyPrintGroupInfo();
-        void printTestCaseAndSectionHeader();
-
-        void printClosedHeader(std::string const& _name);
-        void printOpenHeader(std::string const& _name);
-
-        // if string has a : in first line will set indent to follow it on
-        // subsequent lines
-        void printHeaderString(std::string const& _string, std::size_t indent = 0);
-
-        void printTotals(Totals const& totals);
-        void printSummaryRow(std::string const& label, std::vector<SummaryColumn> const& cols, std::size_t row);
-
-        void printTotalsDivider(Totals const& totals);
-        void printSummaryDivider();
-        void printTestFilters();
-
-    private:
-        bool m_headerPrinted = false;
-    };
-
-} // end namespace Catch
-
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
-
-// end catch_reporter_console.h
-// start catch_reporter_junit.h
-
-// start catch_xmlwriter.h
-
-#include <vector>
-
-namespace Catch {
-
-    class XmlEncode {
-    public:
-        enum ForWhat { ForTextNodes, ForAttributes };
-
-        XmlEncode( std::string const& str, ForWhat forWhat = ForTextNodes );
-
-        void encodeTo( std::ostream& os ) const;
-
-        friend std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode );
-
-    private:
-        std::string m_str;
-        ForWhat m_forWhat;
-    };
-
-    class XmlWriter {
-    public:
-
-        class ScopedElement {
-        public:
-            ScopedElement( XmlWriter* writer );
-
-            ScopedElement( ScopedElement&& other ) noexcept;
-            ScopedElement& operator=( ScopedElement&& other ) noexcept;
-
-            ~ScopedElement();
-
-            ScopedElement& writeText( std::string const& text, bool indent = true );
-
-            template<typename T>
-            ScopedElement& writeAttribute( std::string const& name, T const& attribute ) {
-                m_writer->writeAttribute( name, attribute );
-                return *this;
-            }
-
-        private:
-            mutable XmlWriter* m_writer = nullptr;
-        };
-
-        XmlWriter( std::ostream& os = Catch::cout() );
-        ~XmlWriter();
-
-        XmlWriter( XmlWriter const& ) = delete;
-        XmlWriter& operator=( XmlWriter const& ) = delete;
-
-        XmlWriter& startElement( std::string const& name );
-
-        ScopedElement scopedElement( std::string const& name );
-
-        XmlWriter& endElement();
-
-        XmlWriter& writeAttribute( std::string const& name, std::string const& attribute );
-
-        XmlWriter& writeAttribute( std::string const& name, bool attribute );
-
-        template<typename T>
-        XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
-            ReusableStringStream rss;
-            rss << attribute;
-            return writeAttribute( name, rss.str() );
-        }
-
-        XmlWriter& writeText( std::string const& text, bool indent = true );
-
-        XmlWriter& writeComment( std::string const& text );
-
-        void writeStylesheetRef( std::string const& url );
-
-        XmlWriter& writeBlankLine();
-
-        void ensureTagClosed();
-
-    private:
-
-        void writeDeclaration();
-
-        void newlineIfNecessary();
-
-        bool m_tagIsOpen = false;
-        bool m_needsNewline = false;
-        std::vector<std::string> m_tags;
-        std::string m_indent;
-        std::ostream& m_os;
-    };
-
-}
-
-// end catch_xmlwriter.h
-namespace Catch {
-
-    class JunitReporter : public CumulativeReporterBase<JunitReporter> {
-    public:
-        JunitReporter(ReporterConfig const& _config);
-
-        ~JunitReporter() override;
-
-        static std::string getDescription();
-
-        void noMatchingTestCases(std::string const& /*spec*/) override;
-
-        void testRunStarting(TestRunInfo const& runInfo) override;
-
-        void testGroupStarting(GroupInfo const& groupInfo) override;
-
-        void testCaseStarting(TestCaseInfo const& testCaseInfo) override;
-        bool assertionEnded(AssertionStats const& assertionStats) override;
-
-        void testCaseEnded(TestCaseStats const& testCaseStats) override;
-
-        void testGroupEnded(TestGroupStats const& testGroupStats) override;
-
-        void testRunEndedCumulative() override;
-
-        void writeGroup(TestGroupNode const& groupNode, double suiteTime);
-
-        void writeTestCase(TestCaseNode const& testCaseNode);
-
-        void writeSection(std::string const& className,
-                          std::string const& rootName,
-                          SectionNode const& sectionNode);
-
-        void writeAssertions(SectionNode const& sectionNode);
-        void writeAssertion(AssertionStats const& stats);
-
-        XmlWriter xml;
-        Timer suiteTimer;
-        std::string stdOutForSuite;
-        std::string stdErrForSuite;
-        unsigned int unexpectedExceptions = 0;
-        bool m_okToFail = false;
-    };
-
-} // end namespace Catch
-
-// end catch_reporter_junit.h
-// start catch_reporter_xml.h
-
-namespace Catch {
-    class XmlReporter : public StreamingReporterBase<XmlReporter> {
-    public:
-        XmlReporter(ReporterConfig const& _config);
-
-        ~XmlReporter() override;
-
-        static std::string getDescription();
-
-        virtual std::string getStylesheetRef() const;
-
-        void writeSourceInfo(SourceLineInfo const& sourceInfo);
-
-    public: // StreamingReporterBase
-
-        void noMatchingTestCases(std::string const& s) override;
-
-        void testRunStarting(TestRunInfo const& testInfo) override;
-
-        void testGroupStarting(GroupInfo const& groupInfo) override;
-
-        void testCaseStarting(TestCaseInfo const& testInfo) override;
-
-        void sectionStarting(SectionInfo const& sectionInfo) override;
-
-        void assertionStarting(AssertionInfo const&) override;
-
-        bool assertionEnded(AssertionStats const& assertionStats) override;
-
-        void sectionEnded(SectionStats const& sectionStats) override;
-
-        void testCaseEnded(TestCaseStats const& testCaseStats) override;
-
-        void testGroupEnded(TestGroupStats const& testGroupStats) override;
-
-        void testRunEnded(TestRunStats const& testRunStats) override;
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-        void benchmarkStarting(BenchmarkInfo const&) override;
-        void benchmarkEnded(BenchmarkStats<> const&) override;
-        void benchmarkFailed(std::string const&) override;
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-    private:
-        Timer m_testCaseTimer;
-        XmlWriter m_xml;
-        int m_sectionDepth = 0;
-    };
-
-} // end namespace Catch
-
-// end catch_reporter_xml.h
-
-// end catch_external_interfaces.h
-#endif
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-// start catch_benchmark.hpp
-
- // Benchmark
-
-// start catch_chronometer.hpp
-
-// User-facing chronometer
-
-
-// start catch_clock.hpp
-
-// Clocks
-
-
-#include <chrono>
-#include <ratio>
-
-namespace Catch {
-    namespace Benchmark {
-        template <typename Clock>
-        using ClockDuration = typename Clock::duration;
-        template <typename Clock>
-        using FloatDuration = std::chrono::duration<double, typename Clock::period>;
-
-        template <typename Clock>
-        using TimePoint = typename Clock::time_point;
-
-        using default_clock = std::chrono::steady_clock;
-
-        template <typename Clock>
-        struct now {
-            TimePoint<Clock> operator()() const {
-                return Clock::now();
-            }
-        };
-
-        using fp_seconds = std::chrono::duration<double, std::ratio<1>>;
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_clock.hpp
-// start catch_optimizer.hpp
-
- // Hinting the optimizer
-
-
-#if defined(_MSC_VER)
-#   include <atomic> // atomic_thread_fence
-#endif
-
-namespace Catch {
-    namespace Benchmark {
-#if defined(__GNUC__) || defined(__clang__)
-        template <typename T>
-        inline void keep_memory(T* p) {
-            asm volatile("" : : "g"(p) : "memory");
-        }
-        inline void keep_memory() {
-            asm volatile("" : : : "memory");
-        }
-
-        namespace Detail {
-            inline void optimizer_barrier() { keep_memory(); }
-        } // namespace Detail
-#elif defined(_MSC_VER)
-
-#pragma optimize("", off)
-        template <typename T>
-        inline void keep_memory(T* p) {
-            // thanks @milleniumbug
-            *reinterpret_cast<char volatile*>(p) = *reinterpret_cast<char const volatile*>(p);
-        }
-        // TODO equivalent keep_memory()
-#pragma optimize("", on)
-
-        namespace Detail {
-            inline void optimizer_barrier() {
-                std::atomic_thread_fence(std::memory_order_seq_cst);
-            }
-        } // namespace Detail
-
-#endif
-
-        template <typename T>
-        inline void deoptimize_value(T&& x) {
-            keep_memory(&x);
-        }
-
-        template <typename Fn, typename... Args>
-        inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> typename std::enable_if<!std::is_same<void, decltype(fn(args...))>::value>::type {
-            deoptimize_value(std::forward<Fn>(fn) (std::forward<Args...>(args...)));
-        }
-
-        template <typename Fn, typename... Args>
-        inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> typename std::enable_if<std::is_same<void, decltype(fn(args...))>::value>::type {
-            std::forward<Fn>(fn) (std::forward<Args...>(args...));
-        }
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_optimizer.hpp
-// start catch_complete_invoke.hpp
-
-// Invoke with a special case for void
-
-
-#include <type_traits>
-#include <utility>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename T>
-            struct CompleteType { using type = T; };
-            template <>
-            struct CompleteType<void> { struct type {}; };
-
-            template <typename T>
-            using CompleteType_t = typename CompleteType<T>::type;
-
-            template <typename Result>
-            struct CompleteInvoker {
-                template <typename Fun, typename... Args>
-                static Result invoke(Fun&& fun, Args&&... args) {
-                    return std::forward<Fun>(fun)(std::forward<Args>(args)...);
-                }
-            };
-            template <>
-            struct CompleteInvoker<void> {
-                template <typename Fun, typename... Args>
-                static CompleteType_t<void> invoke(Fun&& fun, Args&&... args) {
-                    std::forward<Fun>(fun)(std::forward<Args>(args)...);
-                    return {};
-                }
-            };
-            template <typename Sig>
-            using ResultOf_t = typename std::result_of<Sig>::type;
-
-            // invoke and not return void :(
-            template <typename Fun, typename... Args>
-            CompleteType_t<ResultOf_t<Fun(Args...)>> complete_invoke(Fun&& fun, Args&&... args) {
-                return CompleteInvoker<ResultOf_t<Fun(Args...)>>::invoke(std::forward<Fun>(fun), std::forward<Args>(args)...);
-            }
-
-            const std::string benchmarkErrorMsg = "a benchmark failed to run successfully";
-        } // namespace Detail
-
-        template <typename Fun>
-        Detail::CompleteType_t<Detail::ResultOf_t<Fun()>> user_code(Fun&& fun) {
-            CATCH_TRY{
-                return Detail::complete_invoke(std::forward<Fun>(fun));
-            } CATCH_CATCH_ALL{
-                getResultCapture().benchmarkFailed(translateActiveException());
-                CATCH_RUNTIME_ERROR(Detail::benchmarkErrorMsg);
-            }
-        }
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_complete_invoke.hpp
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            struct ChronometerConcept {
-                virtual void start() = 0;
-                virtual void finish() = 0;
-                virtual ~ChronometerConcept() = default;
-            };
-            template <typename Clock>
-            struct ChronometerModel final : public ChronometerConcept {
-                void start() override { started = Clock::now(); }
-                void finish() override { finished = Clock::now(); }
-
-                ClockDuration<Clock> elapsed() const { return finished - started; }
-
-                TimePoint<Clock> started;
-                TimePoint<Clock> finished;
-            };
-        } // namespace Detail
-
-        struct Chronometer {
-        public:
-            template <typename Fun>
-            void measure(Fun&& fun) { measure(std::forward<Fun>(fun), is_callable<Fun(int)>()); }
-
-            int runs() const { return k; }
-
-            Chronometer(Detail::ChronometerConcept& meter, int k)
-                : impl(&meter)
-                , k(k) {}
-
-        private:
-            template <typename Fun>
-            void measure(Fun&& fun, std::false_type) {
-                measure([&fun](int) { return fun(); }, std::true_type());
-            }
-
-            template <typename Fun>
-            void measure(Fun&& fun, std::true_type) {
-                Detail::optimizer_barrier();
-                impl->start();
-                for (int i = 0; i < k; ++i) invoke_deoptimized(fun, i);
-                impl->finish();
-                Detail::optimizer_barrier();
-            }
-
-            Detail::ChronometerConcept* impl;
-            int k;
-        };
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_chronometer.hpp
-// start catch_environment.hpp
-
-// Environment information
-
-
-namespace Catch {
-    namespace Benchmark {
-        template <typename Duration>
-        struct EnvironmentEstimate {
-            Duration mean;
-            OutlierClassification outliers;
-
-            template <typename Duration2>
-            operator EnvironmentEstimate<Duration2>() const {
-                return { mean, outliers };
-            }
-        };
-        template <typename Clock>
-        struct Environment {
-            using clock_type = Clock;
-            EnvironmentEstimate<FloatDuration<Clock>> clock_resolution;
-            EnvironmentEstimate<FloatDuration<Clock>> clock_cost;
-        };
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_environment.hpp
-// start catch_execution_plan.hpp
-
- // Execution plan
-
-
-// start catch_benchmark_function.hpp
-
- // Dumb std::function implementation for consistent call overhead
-
-
-#include <cassert>
-#include <type_traits>
-#include <utility>
-#include <memory>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename T>
-            using Decay = typename std::decay<T>::type;
-            template <typename T, typename U>
-            struct is_related
-                : std::is_same<Decay<T>, Decay<U>> {};
-
-            /// We need to reinvent std::function because every piece of code that might add overhead
-            /// in a measurement context needs to have consistent performance characteristics so that we
-            /// can account for it in the measurement.
-            /// Implementations of std::function with optimizations that aren't always applicable, like
-            /// small buffer optimizations, are not uncommon.
-            /// This is effectively an implementation of std::function without any such optimizations;
-            /// it may be slow, but it is consistently slow.
-            struct BenchmarkFunction {
-            private:
-                struct callable {
-                    virtual void call(Chronometer meter) const = 0;
-                    virtual callable* clone() const = 0;
-                    virtual ~callable() = default;
-                };
-                template <typename Fun>
-                struct model : public callable {
-                    model(Fun&& fun) : fun(std::move(fun)) {}
-                    model(Fun const& fun) : fun(fun) {}
-
-                    model<Fun>* clone() const override { return new model<Fun>(*this); }
-
-                    void call(Chronometer meter) const override {
-                        call(meter, is_callable<Fun(Chronometer)>());
-                    }
-                    void call(Chronometer meter, std::true_type) const {
-                        fun(meter);
-                    }
-                    void call(Chronometer meter, std::false_type) const {
-                        meter.measure(fun);
-                    }
-
-                    Fun fun;
-                };
-
-                struct do_nothing { void operator()() const {} };
-
-                template <typename T>
-                BenchmarkFunction(model<T>* c) : f(c) {}
-
-            public:
-                BenchmarkFunction()
-                    : f(new model<do_nothing>{ {} }) {}
-
-                template <typename Fun,
-                    typename std::enable_if<!is_related<Fun, BenchmarkFunction>::value, int>::type = 0>
-                    BenchmarkFunction(Fun&& fun)
-                    : f(new model<typename std::decay<Fun>::type>(std::forward<Fun>(fun))) {}
-
-                BenchmarkFunction(BenchmarkFunction&& that)
-                    : f(std::move(that.f)) {}
-
-                BenchmarkFunction(BenchmarkFunction const& that)
-                    : f(that.f->clone()) {}
-
-                BenchmarkFunction& operator=(BenchmarkFunction&& that) {
-                    f = std::move(that.f);
-                    return *this;
-                }
-
-                BenchmarkFunction& operator=(BenchmarkFunction const& that) {
-                    f.reset(that.f->clone());
-                    return *this;
-                }
-
-                void operator()(Chronometer meter) const { f->call(meter); }
-
-            private:
-                std::unique_ptr<callable> f;
-            };
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_benchmark_function.hpp
-// start catch_repeat.hpp
-
-// repeat algorithm
-
-
-#include <type_traits>
-#include <utility>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename Fun>
-            struct repeater {
-                void operator()(int k) const {
-                    for (int i = 0; i < k; ++i) {
-                        fun();
-                    }
-                }
-                Fun fun;
-            };
-            template <typename Fun>
-            repeater<typename std::decay<Fun>::type> repeat(Fun&& fun) {
-                return { std::forward<Fun>(fun) };
-            }
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_repeat.hpp
-// start catch_run_for_at_least.hpp
-
-// Run a function for a minimum amount of time
-
-
-// start catch_measure.hpp
-
-// Measure
-
-
-// start catch_timing.hpp
-
-// Timing
-
-
-#include <tuple>
-#include <type_traits>
-
-namespace Catch {
-    namespace Benchmark {
-        template <typename Duration, typename Result>
-        struct Timing {
-            Duration elapsed;
-            Result result;
-            int iterations;
-        };
-        template <typename Clock, typename Sig>
-        using TimingOf = Timing<ClockDuration<Clock>, Detail::CompleteType_t<Detail::ResultOf_t<Sig>>>;
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_timing.hpp
-#include <utility>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename Clock, typename Fun, typename... Args>
-            TimingOf<Clock, Fun(Args...)> measure(Fun&& fun, Args&&... args) {
-                auto start = Clock::now();
-                auto&& r = Detail::complete_invoke(fun, std::forward<Args>(args)...);
-                auto end = Clock::now();
-                auto delta = end - start;
-                return { delta, std::forward<decltype(r)>(r), 1 };
-            }
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_measure.hpp
-#include <utility>
-#include <type_traits>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename Clock, typename Fun>
-            TimingOf<Clock, Fun(int)> measure_one(Fun&& fun, int iters, std::false_type) {
-                return Detail::measure<Clock>(fun, iters);
-            }
-            template <typename Clock, typename Fun>
-            TimingOf<Clock, Fun(Chronometer)> measure_one(Fun&& fun, int iters, std::true_type) {
-                Detail::ChronometerModel<Clock> meter;
-                auto&& result = Detail::complete_invoke(fun, Chronometer(meter, iters));
-
-                return { meter.elapsed(), std::move(result), iters };
-            }
-
-            template <typename Clock, typename Fun>
-            using run_for_at_least_argument_t = typename std::conditional<is_callable<Fun(Chronometer)>::value, Chronometer, int>::type;
-
-            struct optimized_away_error : std::exception {
-                const char* what() const noexcept override {
-                    return "could not measure benchmark, maybe it was optimized away";
-                }
-            };
-
-            template <typename Clock, typename Fun>
-            TimingOf<Clock, Fun(run_for_at_least_argument_t<Clock, Fun>)> run_for_at_least(ClockDuration<Clock> how_long, int seed, Fun&& fun) {
-                auto iters = seed;
-                while (iters < (1 << 30)) {
-                    auto&& Timing = measure_one<Clock>(fun, iters, is_callable<Fun(Chronometer)>());
-
-                    if (Timing.elapsed >= how_long) {
-                        return { Timing.elapsed, std::move(Timing.result), iters };
-                    }
-                    iters *= 2;
-                }
-                throw optimized_away_error{};
-            }
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_run_for_at_least.hpp
-#include <algorithm>
-
-namespace Catch {
-    namespace Benchmark {
-        template <typename Duration>
-        struct ExecutionPlan {
-            int iterations_per_sample;
-            Duration estimated_duration;
-            Detail::BenchmarkFunction benchmark;
-            Duration warmup_time;
-            int warmup_iterations;
-
-            template <typename Duration2>
-            operator ExecutionPlan<Duration2>() const {
-                return { iterations_per_sample, estimated_duration, benchmark, warmup_time, warmup_iterations };
-            }
-
-            template <typename Clock>
-            std::vector<FloatDuration<Clock>> run(const IConfig &cfg, Environment<FloatDuration<Clock>> env) const {
-                // warmup a bit
-                Detail::run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(warmup_time), warmup_iterations, Detail::repeat(now<Clock>{}));
-
-                std::vector<FloatDuration<Clock>> times;
-                times.reserve(cfg.benchmarkSamples());
-                std::generate_n(std::back_inserter(times), cfg.benchmarkSamples(), [this, env] {
-                    Detail::ChronometerModel<Clock> model;
-                    this->benchmark(Chronometer(model, iterations_per_sample));
-                    auto sample_time = model.elapsed() - env.clock_cost.mean;
-                    if (sample_time < FloatDuration<Clock>::zero()) sample_time = FloatDuration<Clock>::zero();
-                    return sample_time / iterations_per_sample;
-                });
-                return times;
-            }
-        };
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_execution_plan.hpp
-// start catch_estimate_clock.hpp
-
- // Environment measurement
-
-
-// start catch_stats.hpp
-
-// Statistical analysis tools
-
-
-#include <algorithm>
-#include <functional>
-#include <vector>
-#include <numeric>
-#include <tuple>
-#include <cmath>
-#include <utility>
-#include <cstddef>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            using sample = std::vector<double>;
-
-            double weighted_average_quantile(int k, int q, std::vector<double>::iterator first, std::vector<double>::iterator last);
-
-            template <typename Iterator>
-            OutlierClassification classify_outliers(Iterator first, Iterator last) {
-                std::vector<double> copy(first, last);
-
-                auto q1 = weighted_average_quantile(1, 4, copy.begin(), copy.end());
-                auto q3 = weighted_average_quantile(3, 4, copy.begin(), copy.end());
-                auto iqr = q3 - q1;
-                auto los = q1 - (iqr * 3.);
-                auto lom = q1 - (iqr * 1.5);
-                auto him = q3 + (iqr * 1.5);
-                auto his = q3 + (iqr * 3.);
-
-                OutlierClassification o;
-                for (; first != last; ++first) {
-                    auto&& t = *first;
-                    if (t < los) ++o.low_severe;
-                    else if (t < lom) ++o.low_mild;
-                    else if (t > his) ++o.high_severe;
-                    else if (t > him) ++o.high_mild;
-                    ++o.samples_seen;
-                }
-                return o;
-            }
-
-            template <typename Iterator>
-            double mean(Iterator first, Iterator last) {
-                auto count = last - first;
-                double sum = std::accumulate(first, last, 0.);
-                return sum / count;
-            }
-
-            template <typename URng, typename Iterator, typename Estimator>
-            sample resample(URng& rng, int resamples, Iterator first, Iterator last, Estimator& estimator) {
-                auto n = last - first;
-                std::uniform_int_distribution<decltype(n)> dist(0, n - 1);
-
-                sample out;
-                out.reserve(resamples);
-                std::generate_n(std::back_inserter(out), resamples, [n, first, &estimator, &dist, &rng] {
-                    std::vector<double> resampled;
-                    resampled.reserve(n);
-                    std::generate_n(std::back_inserter(resampled), n, [first, &dist, &rng] { return first[dist(rng)]; });
-                    return estimator(resampled.begin(), resampled.end());
-                });
-                std::sort(out.begin(), out.end());
-                return out;
-            }
-
-            template <typename Estimator, typename Iterator>
-            sample jackknife(Estimator&& estimator, Iterator first, Iterator last) {
-                auto n = last - first;
-                auto second = std::next(first);
-                sample results;
-                results.reserve(n);
-
-                for (auto it = first; it != last; ++it) {
-                    std::iter_swap(it, first);
-                    results.push_back(estimator(second, last));
-                }
-
-                return results;
-            }
-
-            inline double normal_cdf(double x) {
-                return std::erfc(-x / std::sqrt(2.0)) / 2.0;
-            }
-
-            double erfc_inv(double x);
-
-            double normal_quantile(double p);
-
-            template <typename Iterator, typename Estimator>
-            Estimate<double> bootstrap(double confidence_level, Iterator first, Iterator last, sample const& resample, Estimator&& estimator) {
-                auto n_samples = last - first;
-
-                double point = estimator(first, last);
-                // Degenerate case with a single sample
-                if (n_samples == 1) return { point, point, point, confidence_level };
-
-                sample jack = jackknife(estimator, first, last);
-                double jack_mean = mean(jack.begin(), jack.end());
-                double sum_squares, sum_cubes;
-                std::tie(sum_squares, sum_cubes) = std::accumulate(jack.begin(), jack.end(), std::make_pair(0., 0.), [jack_mean](std::pair<double, double> sqcb, double x) -> std::pair<double, double> {
-                    auto d = jack_mean - x;
-                    auto d2 = d * d;
-                    auto d3 = d2 * d;
-                    return { sqcb.first + d2, sqcb.second + d3 };
-                });
-
-                double accel = sum_cubes / (6 * std::pow(sum_squares, 1.5));
-                int n = static_cast<int>(resample.size());
-                double prob_n = std::count_if(resample.begin(), resample.end(), [point](double x) { return x < point; }) / (double)n;
-                // degenerate case with uniform samples
-                if (prob_n == 0) return { point, point, point, confidence_level };
-
-                double bias = normal_quantile(prob_n);
-                double z1 = normal_quantile((1. - confidence_level) / 2.);
-
-                auto cumn = [n](double x) -> int {
-                    return std::lround(normal_cdf(x) * n); };
-                auto a = [bias, accel](double b) { return bias + b / (1. - accel * b); };
-                double b1 = bias + z1;
-                double b2 = bias - z1;
-                double a1 = a(b1);
-                double a2 = a(b2);
-                auto lo = std::max(cumn(a1), 0);
-                auto hi = std::min(cumn(a2), n - 1);
-
-                return { point, resample[lo], resample[hi], confidence_level };
-            }
-
-            double outlier_variance(Estimate<double> mean, Estimate<double> stddev, int n);
-
-            struct bootstrap_analysis {
-                Estimate<double> mean;
-                Estimate<double> standard_deviation;
-                double outlier_variance;
-            };
-
-            bootstrap_analysis analyse_samples(double confidence_level, int n_resamples, std::vector<double>::iterator first, std::vector<double>::iterator last);
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_stats.hpp
-#include <algorithm>
-#include <iterator>
-#include <tuple>
-#include <vector>
-#include <cmath>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename Clock>
-            std::vector<double> resolution(int k) {
-                std::vector<TimePoint<Clock>> times;
-                times.reserve(k + 1);
-                std::generate_n(std::back_inserter(times), k + 1, now<Clock>{});
-
-                std::vector<double> deltas;
-                deltas.reserve(k);
-                std::transform(std::next(times.begin()), times.end(), times.begin(),
-                    std::back_inserter(deltas),
-                    [](TimePoint<Clock> a, TimePoint<Clock> b) { return static_cast<double>((a - b).count()); });
-
-                return deltas;
-            }
-
-            const auto warmup_iterations = 10000;
-            const auto warmup_time = std::chrono::milliseconds(100);
-            const auto minimum_ticks = 1000;
-            const auto warmup_seed = 10000;
-            const auto clock_resolution_estimation_time = std::chrono::milliseconds(500);
-            const auto clock_cost_estimation_time_limit = std::chrono::seconds(1);
-            const auto clock_cost_estimation_tick_limit = 100000;
-            const auto clock_cost_estimation_time = std::chrono::milliseconds(10);
-            const auto clock_cost_estimation_iterations = 10000;
-
-            template <typename Clock>
-            int warmup() {
-                return run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(warmup_time), warmup_seed, &resolution<Clock>)
-                    .iterations;
-            }
-            template <typename Clock>
-            EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_resolution(int iterations) {
-                auto r = run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(clock_resolution_estimation_time), iterations, &resolution<Clock>)
-                    .result;
-                return {
-                    FloatDuration<Clock>(mean(r.begin(), r.end())),
-                    classify_outliers(r.begin(), r.end()),
-                };
-            }
-            template <typename Clock>
-            EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_cost(FloatDuration<Clock> resolution) {
-                auto time_limit = std::min(resolution * clock_cost_estimation_tick_limit, FloatDuration<Clock>(clock_cost_estimation_time_limit));
-                auto time_clock = [](int k) {
-                    return Detail::measure<Clock>([k] {
-                        for (int i = 0; i < k; ++i) {
-                            volatile auto ignored = Clock::now();
-                            (void)ignored;
-                        }
-                    }).elapsed;
-                };
-                time_clock(1);
-                int iters = clock_cost_estimation_iterations;
-                auto&& r = run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(clock_cost_estimation_time), iters, time_clock);
-                std::vector<double> times;
-                int nsamples = static_cast<int>(std::ceil(time_limit / r.elapsed));
-                times.reserve(nsamples);
-                std::generate_n(std::back_inserter(times), nsamples, [time_clock, &r] {
-                    return static_cast<double>((time_clock(r.iterations) / r.iterations).count());
-                });
-                return {
-                    FloatDuration<Clock>(mean(times.begin(), times.end())),
-                    classify_outliers(times.begin(), times.end()),
-                };
-            }
-
-            template <typename Clock>
-            Environment<FloatDuration<Clock>> measure_environment() {
-                static Environment<FloatDuration<Clock>>* env = nullptr;
-                if (env) {
-                    return *env;
-                }
-
-                auto iters = Detail::warmup<Clock>();
-                auto resolution = Detail::estimate_clock_resolution<Clock>(iters);
-                auto cost = Detail::estimate_clock_cost<Clock>(resolution.mean);
-
-                env = new Environment<FloatDuration<Clock>>{ resolution, cost };
-                return *env;
-            }
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_estimate_clock.hpp
-// start catch_analyse.hpp
-
- // Run and analyse one benchmark
-
-
-// start catch_sample_analysis.hpp
-
-// Benchmark results
-
-
-#include <algorithm>
-#include <vector>
-#include <string>
-#include <iterator>
-
-namespace Catch {
-    namespace Benchmark {
-        template <typename Duration>
-        struct SampleAnalysis {
-            std::vector<Duration> samples;
-            Estimate<Duration> mean;
-            Estimate<Duration> standard_deviation;
-            OutlierClassification outliers;
-            double outlier_variance;
-
-            template <typename Duration2>
-            operator SampleAnalysis<Duration2>() const {
-                std::vector<Duration2> samples2;
-                samples2.reserve(samples.size());
-                std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](Duration d) { return Duration2(d); });
-                return {
-                    std::move(samples2),
-                    mean,
-                    standard_deviation,
-                    outliers,
-                    outlier_variance,
-                };
-            }
-        };
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_sample_analysis.hpp
-#include <algorithm>
-#include <iterator>
-#include <vector>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename Duration, typename Iterator>
-            SampleAnalysis<Duration> analyse(const IConfig &cfg, Environment<Duration>, Iterator first, Iterator last) {
-                if (!cfg.benchmarkNoAnalysis()) {
-                    std::vector<double> samples;
-                    samples.reserve(last - first);
-                    std::transform(first, last, std::back_inserter(samples), [](Duration d) { return d.count(); });
-
-                    auto analysis = Catch::Benchmark::Detail::analyse_samples(cfg.benchmarkConfidenceInterval(), cfg.benchmarkResamples(), samples.begin(), samples.end());
-                    auto outliers = Catch::Benchmark::Detail::classify_outliers(samples.begin(), samples.end());
-
-                    auto wrap_estimate = [](Estimate<double> e) {
-                        return Estimate<Duration> {
-                            Duration(e.point),
-                                Duration(e.lower_bound),
-                                Duration(e.upper_bound),
-                                e.confidence_interval,
-                        };
-                    };
-                    std::vector<Duration> samples2;
-                    samples2.reserve(samples.size());
-                    std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](double d) { return Duration(d); });
-                    return {
-                        std::move(samples2),
-                        wrap_estimate(analysis.mean),
-                        wrap_estimate(analysis.standard_deviation),
-                        outliers,
-                        analysis.outlier_variance,
-                    };
-                } else {
-                    std::vector<Duration> samples;
-                    samples.reserve(last - first);
-
-                    Duration mean = Duration(0);
-                    int i = 0;
-                    for (auto it = first; it < last; ++it, ++i) {
-                        samples.push_back(Duration(*it));
-                        mean += Duration(*it);
-                    }
-                    mean /= i;
-
-                    return {
-                        std::move(samples),
-                        Estimate<Duration>{mean, mean, mean, 0.0},
-                        Estimate<Duration>{Duration(0), Duration(0), Duration(0), 0.0},
-                        OutlierClassification{},
-                        0.0
-                    };
-                }
-            }
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_analyse.hpp
-#include <algorithm>
-#include <functional>
-#include <string>
-#include <vector>
-#include <cmath>
-
-namespace Catch {
-    namespace Benchmark {
-        struct Benchmark {
-            Benchmark(std::string &&name)
-                : name(std::move(name)) {}
-
-            template <class FUN>
-            Benchmark(std::string &&name, FUN &&func)
-                : fun(std::move(func)), name(std::move(name)) {}
-
-            template <typename Clock>
-            ExecutionPlan<FloatDuration<Clock>> prepare(const IConfig &cfg, Environment<FloatDuration<Clock>> env) const {
-                auto min_time = env.clock_resolution.mean * Detail::minimum_ticks;
-                auto run_time = std::max(min_time, std::chrono::duration_cast<decltype(min_time)>(Detail::warmup_time));
-                auto&& test = Detail::run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(run_time), 1, fun);
-                int new_iters = static_cast<int>(std::ceil(min_time * test.iterations / test.elapsed));
-                return { new_iters, test.elapsed / test.iterations * new_iters * cfg.benchmarkSamples(), fun, std::chrono::duration_cast<FloatDuration<Clock>>(Detail::warmup_time), Detail::warmup_iterations };
-            }
-
-            template <typename Clock = default_clock>
-            void run() {
-                IConfigPtr cfg = getCurrentContext().getConfig();
-
-                auto env = Detail::measure_environment<Clock>();
-
-                getResultCapture().benchmarkPreparing(name);
-                CATCH_TRY{
-                    auto plan = user_code([&] {
-                        return prepare<Clock>(*cfg, env);
-                    });
-
-                    BenchmarkInfo info {
-                        name,
-                        plan.estimated_duration.count(),
-                        plan.iterations_per_sample,
-                        cfg->benchmarkSamples(),
-                        cfg->benchmarkResamples(),
-                        env.clock_resolution.mean.count(),
-                        env.clock_cost.mean.count()
-                    };
-
-                    getResultCapture().benchmarkStarting(info);
-
-                    auto samples = user_code([&] {
-                        return plan.template run<Clock>(*cfg, env);
-                    });
-
-                    auto analysis = Detail::analyse(*cfg, env, samples.begin(), samples.end());
-                    BenchmarkStats<std::chrono::duration<double, std::nano>> stats{ info, analysis.samples, analysis.mean, analysis.standard_deviation, analysis.outliers, analysis.outlier_variance };
-                    getResultCapture().benchmarkEnded(stats);
-
-                } CATCH_CATCH_ALL{
-                    if (translateActiveException() != Detail::benchmarkErrorMsg) // benchmark errors have been reported, otherwise rethrow.
-                        std::rethrow_exception(std::current_exception());
-                }
-            }
-
-            // sets lambda to be used in fun *and* executes benchmark!
-            template <typename Fun,
-                typename std::enable_if<!Detail::is_related<Fun, Benchmark>::value, int>::type = 0>
-                Benchmark & operator=(Fun func) {
-                fun = Detail::BenchmarkFunction(func);
-                run();
-                return *this;
-            }
-
-            explicit operator bool() {
-                return true;
-            }
-
-        private:
-            Detail::BenchmarkFunction fun;
-            std::string name;
-        };
-    }
-} // namespace Catch
-
-#define INTERNAL_CATCH_GET_1_ARG(arg1, arg2, ...) arg1
-#define INTERNAL_CATCH_GET_2_ARG(arg1, arg2, ...) arg2
-
-#define INTERNAL_CATCH_BENCHMARK(BenchmarkName, name, benchmarkIndex)\
-    if( Catch::Benchmark::Benchmark BenchmarkName{name} ) \
-        BenchmarkName = [&](int benchmarkIndex)
-
-#define INTERNAL_CATCH_BENCHMARK_ADVANCED(BenchmarkName, name)\
-    if( Catch::Benchmark::Benchmark BenchmarkName{name} ) \
-        BenchmarkName = [&]
-
-// end catch_benchmark.hpp
-#endif
-
-#endif // ! CATCH_CONFIG_IMPL_ONLY
-
-#ifdef CATCH_IMPL
-// start catch_impl.hpp
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wweak-vtables"
-#endif
-
-// Keep these here for external reporters
-// start catch_test_case_tracker.h
-
-#include <string>
-#include <vector>
-#include <memory>
-
-namespace Catch {
-namespace TestCaseTracking {
-
-    struct NameAndLocation {
-        std::string name;
-        SourceLineInfo location;
-
-        NameAndLocation( std::string const& _name, SourceLineInfo const& _location );
-    };
-
-    struct ITracker;
-
-    using ITrackerPtr = std::shared_ptr<ITracker>;
-
-    struct ITracker {
-        virtual ~ITracker();
-
-        // static queries
-        virtual NameAndLocation const& nameAndLocation() const = 0;
-
-        // dynamic queries
-        virtual bool isComplete() const = 0; // Successfully completed or failed
-        virtual bool isSuccessfullyCompleted() const = 0;
-        virtual bool isOpen() const = 0; // Started but not complete
-        virtual bool hasChildren() const = 0;
-
-        virtual ITracker& parent() = 0;
-
-        // actions
-        virtual void close() = 0; // Successfully complete
-        virtual void fail() = 0;
-        virtual void markAsNeedingAnotherRun() = 0;
-
-        virtual void addChild( ITrackerPtr const& child ) = 0;
-        virtual ITrackerPtr findChild( NameAndLocation const& nameAndLocation ) = 0;
-        virtual void openChild() = 0;
-
-        // Debug/ checking
-        virtual bool isSectionTracker() const = 0;
-        virtual bool isGeneratorTracker() const = 0;
-    };
-
-    class TrackerContext {
-
-        enum RunState {
-            NotStarted,
-            Executing,
-            CompletedCycle
-        };
-
-        ITrackerPtr m_rootTracker;
-        ITracker* m_currentTracker = nullptr;
-        RunState m_runState = NotStarted;
-
-    public:
-
-        ITracker& startRun();
-        void endRun();
-
-        void startCycle();
-        void completeCycle();
-
-        bool completedCycle() const;
-        ITracker& currentTracker();
-        void setCurrentTracker( ITracker* tracker );
-    };
-
-    class TrackerBase : public ITracker {
-    protected:
-        enum CycleState {
-            NotStarted,
-            Executing,
-            ExecutingChildren,
-            NeedsAnotherRun,
-            CompletedSuccessfully,
-            Failed
-        };
-
-        using Children = std::vector<ITrackerPtr>;
-        NameAndLocation m_nameAndLocation;
-        TrackerContext& m_ctx;
-        ITracker* m_parent;
-        Children m_children;
-        CycleState m_runState = NotStarted;
-
-    public:
-        TrackerBase( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent );
-
-        NameAndLocation const& nameAndLocation() const override;
-        bool isComplete() const override;
-        bool isSuccessfullyCompleted() const override;
-        bool isOpen() const override;
-        bool hasChildren() const override;
-
-        void addChild( ITrackerPtr const& child ) override;
-
-        ITrackerPtr findChild( NameAndLocation const& nameAndLocation ) override;
-        ITracker& parent() override;
-
-        void openChild() override;
-
-        bool isSectionTracker() const override;
-        bool isGeneratorTracker() const override;
-
-        void open();
-
-        void close() override;
-        void fail() override;
-        void markAsNeedingAnotherRun() override;
-
-    private:
-        void moveToParent();
-        void moveToThis();
-    };
-
-    class SectionTracker : public TrackerBase {
-        std::vector<std::string> m_filters;
-    public:
-        SectionTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent );
-
-        bool isSectionTracker() const override;
-
-        bool isComplete() const override;
-
-        static SectionTracker& acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation );
-
-        void tryOpen();
-
-        void addInitialFilters( std::vector<std::string> const& filters );
-        void addNextFilters( std::vector<std::string> const& filters );
-    };
-
-} // namespace TestCaseTracking
-
-using TestCaseTracking::ITracker;
-using TestCaseTracking::TrackerContext;
-using TestCaseTracking::SectionTracker;
-
-} // namespace Catch
-
-// end catch_test_case_tracker.h
-
-// start catch_leak_detector.h
-
-namespace Catch {
-
-    struct LeakDetector {
-        LeakDetector();
-        ~LeakDetector();
-    };
-
-}
-// end catch_leak_detector.h
-// Cpp files will be included in the single-header file here
-// start catch_stats.cpp
-
-// Statistical analysis tools
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-
-#include <cassert>
-#include <random>
-
-#if defined(CATCH_CONFIG_USE_ASYNC)
-#include <future>
-#endif
-
-namespace {
-    double erf_inv(double x) {
-        // Code accompanying the article "Approximating the erfinv function" in GPU Computing Gems, Volume 2
-        double w, p;
-
-        w = -log((1.0 - x) * (1.0 + x));
-
-        if (w < 6.250000) {
-            w = w - 3.125000;
-            p = -3.6444120640178196996e-21;
-            p = -1.685059138182016589e-19 + p * w;
-            p = 1.2858480715256400167e-18 + p * w;
-            p = 1.115787767802518096e-17 + p * w;
-            p = -1.333171662854620906e-16 + p * w;
-            p = 2.0972767875968561637e-17 + p * w;
-            p = 6.6376381343583238325e-15 + p * w;
-            p = -4.0545662729752068639e-14 + p * w;
-            p = -8.1519341976054721522e-14 + p * w;
-            p = 2.6335093153082322977e-12 + p * w;
-            p = -1.2975133253453532498e-11 + p * w;
-            p = -5.4154120542946279317e-11 + p * w;
-            p = 1.051212273321532285e-09 + p * w;
-            p = -4.1126339803469836976e-09 + p * w;
-            p = -2.9070369957882005086e-08 + p * w;
-            p = 4.2347877827932403518e-07 + p * w;
-            p = -1.3654692000834678645e-06 + p * w;
-            p = -1.3882523362786468719e-05 + p * w;
-            p = 0.0001867342080340571352 + p * w;
-            p = -0.00074070253416626697512 + p * w;
-            p = -0.0060336708714301490533 + p * w;
-            p = 0.24015818242558961693 + p * w;
-            p = 1.6536545626831027356 + p * w;
-        } else if (w < 16.000000) {
-            w = sqrt(w) - 3.250000;
-            p = 2.2137376921775787049e-09;
-            p = 9.0756561938885390979e-08 + p * w;
-            p = -2.7517406297064545428e-07 + p * w;
-            p = 1.8239629214389227755e-08 + p * w;
-            p = 1.5027403968909827627e-06 + p * w;
-            p = -4.013867526981545969e-06 + p * w;
-            p = 2.9234449089955446044e-06 + p * w;
-            p = 1.2475304481671778723e-05 + p * w;
-            p = -4.7318229009055733981e-05 + p * w;
-            p = 6.8284851459573175448e-05 + p * w;
-            p = 2.4031110387097893999e-05 + p * w;
-            p = -0.0003550375203628474796 + p * w;
-            p = 0.00095328937973738049703 + p * w;
-            p = -0.0016882755560235047313 + p * w;
-            p = 0.0024914420961078508066 + p * w;
-            p = -0.0037512085075692412107 + p * w;
-            p = 0.005370914553590063617 + p * w;
-            p = 1.0052589676941592334 + p * w;
-            p = 3.0838856104922207635 + p * w;
-        } else {
-            w = sqrt(w) - 5.000000;
-            p = -2.7109920616438573243e-11;
-            p = -2.5556418169965252055e-10 + p * w;
-            p = 1.5076572693500548083e-09 + p * w;
-            p = -3.7894654401267369937e-09 + p * w;
-            p = 7.6157012080783393804e-09 + p * w;
-            p = -1.4960026627149240478e-08 + p * w;
-            p = 2.9147953450901080826e-08 + p * w;
-            p = -6.7711997758452339498e-08 + p * w;
-            p = 2.2900482228026654717e-07 + p * w;
-            p = -9.9298272942317002539e-07 + p * w;
-            p = 4.5260625972231537039e-06 + p * w;
-            p = -1.9681778105531670567e-05 + p * w;
-            p = 7.5995277030017761139e-05 + p * w;
-            p = -0.00021503011930044477347 + p * w;
-            p = -0.00013871931833623122026 + p * w;
-            p = 1.0103004648645343977 + p * w;
-            p = 4.8499064014085844221 + p * w;
-        }
-        return p * x;
-    }
-
-    double standard_deviation(std::vector<double>::iterator first, std::vector<double>::iterator last) {
-        auto m = Catch::Benchmark::Detail::mean(first, last);
-        double variance = std::accumulate(first, last, 0., [m](double a, double b) {
-            double diff = b - m;
-            return a + diff * diff;
-            }) / (last - first);
-            return std::sqrt(variance);
-    }
-
-}
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-
-            double weighted_average_quantile(int k, int q, std::vector<double>::iterator first, std::vector<double>::iterator last) {
-                auto count = last - first;
-                double idx = (count - 1) * k / static_cast<double>(q);
-                int j = static_cast<int>(idx);
-                double g = idx - j;
-                std::nth_element(first, first + j, last);
-                auto xj = first[j];
-                if (g == 0) return xj;
-
-                auto xj1 = *std::min_element(first + (j + 1), last);
-                return xj + g * (xj1 - xj);
-            }
-
-            double erfc_inv(double x) {
-                return erf_inv(1.0 - x);
-            }
-
-            double normal_quantile(double p) {
-                static const double ROOT_TWO = std::sqrt(2.0);
-
-                double result = 0.0;
-                assert(p >= 0 && p <= 1);
-                if (p < 0 || p > 1) {
-                    return result;
-                }
-
-                result = -erfc_inv(2.0 * p);
-                // result *= normal distribution standard deviation (1.0) * sqrt(2)
-                result *= /*sd * */ ROOT_TWO;
-                // result += normal disttribution mean (0)
-                return result;
-            }
-
-            double outlier_variance(Estimate<double> mean, Estimate<double> stddev, int n) {
-                double sb = stddev.point;
-                double mn = mean.point / n;
-                double mg_min = mn / 2.;
-                double sg = std::min(mg_min / 4., sb / std::sqrt(n));
-                double sg2 = sg * sg;
-                double sb2 = sb * sb;
-
-                auto c_max = [n, mn, sb2, sg2](double x) -> double {
-                    double k = mn - x;
-                    double d = k * k;
-                    double nd = n * d;
-                    double k0 = -n * nd;
-                    double k1 = sb2 - n * sg2 + nd;
-                    double det = k1 * k1 - 4 * sg2 * k0;
-                    return (int)(-2. * k0 / (k1 + std::sqrt(det)));
-                };
-
-                auto var_out = [n, sb2, sg2](double c) {
-                    double nc = n - c;
-                    return (nc / n) * (sb2 - nc * sg2);
-                };
-
-                return std::min(var_out(1), var_out(std::min(c_max(0.), c_max(mg_min)))) / sb2;
-            }
-
-            bootstrap_analysis analyse_samples(double confidence_level, int n_resamples, std::vector<double>::iterator first, std::vector<double>::iterator last) {
-                CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
-                static std::random_device entropy;
-                CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS
-
-                auto n = static_cast<int>(last - first); // seriously, one can't use integral types without hell in C++
-
-                auto mean = &Detail::mean<std::vector<double>::iterator>;
-                auto stddev = &standard_deviation;
-
-#if defined(CATCH_CONFIG_USE_ASYNC)
-                auto Estimate = [=](double(*f)(std::vector<double>::iterator, std::vector<double>::iterator)) {
-                    auto seed = entropy();
-                    return std::async(std::launch::async, [=] {
-                        std::mt19937 rng(seed);
-                        auto resampled = resample(rng, n_resamples, first, last, f);
-                        return bootstrap(confidence_level, first, last, resampled, f);
-                    });
-                };
-
-                auto mean_future = Estimate(mean);
-                auto stddev_future = Estimate(stddev);
-
-                auto mean_estimate = mean_future.get();
-                auto stddev_estimate = stddev_future.get();
-#else
-                auto Estimate = [=](double(*f)(std::vector<double>::iterator, std::vector<double>::iterator)) {
-                    auto seed = entropy();
-                    std::mt19937 rng(seed);
-                    auto resampled = resample(rng, n_resamples, first, last, f);
-                    return bootstrap(confidence_level, first, last, resampled, f);
-                };
-
-                auto mean_estimate = Estimate(mean);
-                auto stddev_estimate = Estimate(stddev);
-#endif // CATCH_USE_ASYNC
-
-                double outlier_variance = Detail::outlier_variance(mean_estimate, stddev_estimate, n);
-
-                return { mean_estimate, stddev_estimate, outlier_variance };
-            }
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-// end catch_stats.cpp
-// start catch_approx.cpp
-
-#include <cmath>
-#include <limits>
-
-namespace {
-
-// Performs equivalent check of std::fabs(lhs - rhs) <= margin
-// But without the subtraction to allow for INFINITY in comparison
-bool marginComparison(double lhs, double rhs, double margin) {
-    return (lhs + margin >= rhs) && (rhs + margin >= lhs);
-}
-
-}
-
-namespace Catch {
-namespace Detail {
-
-    Approx::Approx ( double value )
-    :   m_epsilon( std::numeric_limits<float>::epsilon()*100 ),
-        m_margin( 0.0 ),
-        m_scale( 0.0 ),
-        m_value( value )
-    {}
-
-    Approx Approx::custom() {
-        return Approx( 0 );
-    }
-
-    Approx Approx::operator-() const {
-        auto temp(*this);
-        temp.m_value = -temp.m_value;
-        return temp;
-    }
-
-    std::string Approx::toString() const {
-        ReusableStringStream rss;
-        rss << "Approx( " << ::Catch::Detail::stringify( m_value ) << " )";
-        return rss.str();
-    }
-
-    bool Approx::equalityComparisonImpl(const double other) const {
-        // First try with fixed margin, then compute margin based on epsilon, scale and Approx's value
-        // Thanks to Richard Harris for his help refining the scaled margin value
-        return marginComparison(m_value, other, m_margin) || marginComparison(m_value, other, m_epsilon * (m_scale + std::fabs(m_value)));
-    }
-
-    void Approx::setMargin(double newMargin) {
-        CATCH_ENFORCE(newMargin >= 0,
-            "Invalid Approx::margin: " << newMargin << '.'
-            << " Approx::Margin has to be non-negative.");
-        m_margin = newMargin;
-    }
-
-    void Approx::setEpsilon(double newEpsilon) {
-        CATCH_ENFORCE(newEpsilon >= 0 && newEpsilon <= 1.0,
-            "Invalid Approx::epsilon: " << newEpsilon << '.'
-            << " Approx::epsilon has to be in [0, 1]");
-        m_epsilon = newEpsilon;
-    }
-
-} // end namespace Detail
-
-namespace literals {
-    Detail::Approx operator "" _a(long double val) {
-        return Detail::Approx(val);
-    }
-    Detail::Approx operator "" _a(unsigned long long val) {
-        return Detail::Approx(val);
-    }
-} // end namespace literals
-
-std::string StringMaker<Catch::Detail::Approx>::convert(Catch::Detail::Approx const& value) {
-    return value.toString();
-}
-
-} // end namespace Catch
-// end catch_approx.cpp
-// start catch_assertionhandler.cpp
-
-// start catch_debugger.h
-
-namespace Catch {
-    bool isDebuggerActive();
-}
-
-#ifdef CATCH_PLATFORM_MAC
-
-    #define CATCH_TRAP() __asm__("int $3\n" : : ) /* NOLINT */
-
-#elif defined(CATCH_PLATFORM_LINUX)
-    // If we can use inline assembler, do it because this allows us to break
-    // directly at the location of the failing check instead of breaking inside
-    // raise() called from it, i.e. one stack frame below.
-    #if defined(__GNUC__) && (defined(__i386) || defined(__x86_64))
-        #define CATCH_TRAP() asm volatile ("int $3") /* NOLINT */
-    #else // Fall back to the generic way.
-        #include <signal.h>
-
-        #define CATCH_TRAP() raise(SIGTRAP)
-    #endif
-#elif defined(_MSC_VER)
-    #define CATCH_TRAP() __debugbreak()
-#elif defined(__MINGW32__)
-    extern "C" __declspec(dllimport) void __stdcall DebugBreak();
-    #define CATCH_TRAP() DebugBreak()
-#endif
-
-#ifdef CATCH_TRAP
-    #define CATCH_BREAK_INTO_DEBUGGER() []{ if( Catch::isDebuggerActive() ) { CATCH_TRAP(); } }()
-#else
-    #define CATCH_BREAK_INTO_DEBUGGER() []{}()
-#endif
-
-// end catch_debugger.h
-// start catch_run_context.h
-
-// start catch_fatal_condition.h
-
-// start catch_windows_h_proxy.h
-
-
-#if defined(CATCH_PLATFORM_WINDOWS)
-
-#if !defined(NOMINMAX) && !defined(CATCH_CONFIG_NO_NOMINMAX)
-#  define CATCH_DEFINED_NOMINMAX
-#  define NOMINMAX
-#endif
-#if !defined(WIN32_LEAN_AND_MEAN) && !defined(CATCH_CONFIG_NO_WIN32_LEAN_AND_MEAN)
-#  define CATCH_DEFINED_WIN32_LEAN_AND_MEAN
-#  define WIN32_LEAN_AND_MEAN
-#endif
-
-#ifdef __AFXDLL
-#include <AfxWin.h>
-#else
-#include <windows.h>
-#endif
-
-#ifdef CATCH_DEFINED_NOMINMAX
-#  undef NOMINMAX
-#endif
-#ifdef CATCH_DEFINED_WIN32_LEAN_AND_MEAN
-#  undef WIN32_LEAN_AND_MEAN
-#endif
-
-#endif // defined(CATCH_PLATFORM_WINDOWS)
-
-// end catch_windows_h_proxy.h
-#if defined( CATCH_CONFIG_WINDOWS_SEH )
-
-namespace Catch {
-
-    struct FatalConditionHandler {
-
-        static LONG CALLBACK handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo);
-        FatalConditionHandler();
-        static void reset();
-        ~FatalConditionHandler();
-
-    private:
-        static bool isSet;
-        static ULONG guaranteeSize;
-        static PVOID exceptionHandlerHandle;
-    };
-
-} // namespace Catch
-
-#elif defined ( CATCH_CONFIG_POSIX_SIGNALS )
-
-#include <signal.h>
-
-namespace Catch {
-
-    struct FatalConditionHandler {
-
-        static bool isSet;
-        static struct sigaction oldSigActions[];
-        static stack_t oldSigStack;
-        static char altStackMem[];
-
-        static void handleSignal( int sig );
-
-        FatalConditionHandler();
-        ~FatalConditionHandler();
-        static void reset();
-    };
-
-} // namespace Catch
-
-#else
-
-namespace Catch {
-    struct FatalConditionHandler {
-        void reset();
-    };
-}
-
-#endif
-
-// end catch_fatal_condition.h
-#include <string>
-
-namespace Catch {
-
-    struct IMutableContext;
-
-    ///////////////////////////////////////////////////////////////////////////
-
-    class RunContext : public IResultCapture, public IRunner {
-
-    public:
-        RunContext( RunContext const& ) = delete;
-        RunContext& operator =( RunContext const& ) = delete;
-
-        explicit RunContext( IConfigPtr const& _config, IStreamingReporterPtr&& reporter );
-
-        ~RunContext() override;
-
-        void testGroupStarting( std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount );
-        void testGroupEnded( std::string const& testSpec, Totals const& totals, std::size_t groupIndex, std::size_t groupsCount );
-
-        Totals runTest(TestCase const& testCase);
-
-        IConfigPtr config() const;
-        IStreamingReporter& reporter() const;
-
-    public: // IResultCapture
-
-        // Assertion handlers
-        void handleExpr
-                (   AssertionInfo const& info,
-                    ITransientExpression const& expr,
-                    AssertionReaction& reaction ) override;
-        void handleMessage
-                (   AssertionInfo const& info,
-                    ResultWas::OfType resultType,
-                    StringRef const& message,
-                    AssertionReaction& reaction ) override;
-        void handleUnexpectedExceptionNotThrown
-                (   AssertionInfo const& info,
-                    AssertionReaction& reaction ) override;
-        void handleUnexpectedInflightException
-                (   AssertionInfo const& info,
-                    std::string const& message,
-                    AssertionReaction& reaction ) override;
-        void handleIncomplete
-                (   AssertionInfo const& info ) override;
-        void handleNonExpr
-                (   AssertionInfo const &info,
-                    ResultWas::OfType resultType,
-                    AssertionReaction &reaction ) override;
-
-        bool sectionStarted( SectionInfo const& sectionInfo, Counts& assertions ) override;
-
-        void sectionEnded( SectionEndInfo const& endInfo ) override;
-        void sectionEndedEarly( SectionEndInfo const& endInfo ) override;
-
-        auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& override;
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-        void benchmarkPreparing( std::string const& name ) override;
-        void benchmarkStarting( BenchmarkInfo const& info ) override;
-        void benchmarkEnded( BenchmarkStats<> const& stats ) override;
-        void benchmarkFailed( std::string const& error ) override;
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-        void pushScopedMessage( MessageInfo const& message ) override;
-        void popScopedMessage( MessageInfo const& message ) override;
-
-        void emplaceUnscopedMessage( MessageBuilder const& builder ) override;
-
-        std::string getCurrentTestName() const override;
-
-        const AssertionResult* getLastResult() const override;
-
-        void exceptionEarlyReported() override;
-
-        void handleFatalErrorCondition( StringRef message ) override;
-
-        bool lastAssertionPassed() override;
-
-        void assertionPassed() override;
-
-    public:
-        // !TBD We need to do this another way!
-        bool aborting() const final;
-
-    private:
-
-        void runCurrentTest( std::string& redirectedCout, std::string& redirectedCerr );
-        void invokeActiveTestCase();
-
-        void resetAssertionInfo();
-        bool testForMissingAssertions( Counts& assertions );
-
-        void assertionEnded( AssertionResult const& result );
-        void reportExpr
-                (   AssertionInfo const &info,
-                    ResultWas::OfType resultType,
-                    ITransientExpression const *expr,
-                    bool negated );
-
-        void populateReaction( AssertionReaction& reaction );
-
-    private:
-
-        void handleUnfinishedSections();
-
-        TestRunInfo m_runInfo;
-        IMutableContext& m_context;
-        TestCase const* m_activeTestCase = nullptr;
-        ITracker* m_testCaseTracker = nullptr;
-        Option<AssertionResult> m_lastResult;
-
-        IConfigPtr m_config;
-        Totals m_totals;
-        IStreamingReporterPtr m_reporter;
-        std::vector<MessageInfo> m_messages;
-        std::vector<ScopedMessage> m_messageScopes; /* Keeps owners of so-called unscoped messages. */
-        AssertionInfo m_lastAssertionInfo;
-        std::vector<SectionEndInfo> m_unfinishedSections;
-        std::vector<ITracker*> m_activeSections;
-        TrackerContext m_trackerContext;
-        bool m_lastAssertionPassed = false;
-        bool m_shouldReportUnexpected = true;
-        bool m_includeSuccessfulResults;
-    };
-
-} // end namespace Catch
-
-// end catch_run_context.h
-namespace Catch {
-
-    namespace {
-        auto operator <<( std::ostream& os, ITransientExpression const& expr ) -> std::ostream& {
-            expr.streamReconstructedExpression( os );
-            return os;
-        }
-    }
-
-    LazyExpression::LazyExpression( bool isNegated )
-    :   m_isNegated( isNegated )
-    {}
-
-    LazyExpression::LazyExpression( LazyExpression const& other ) : m_isNegated( other.m_isNegated ) {}
-
-    LazyExpression::operator bool() const {
-        return m_transientExpression != nullptr;
-    }
-
-    auto operator << ( std::ostream& os, LazyExpression const& lazyExpr ) -> std::ostream& {
-        if( lazyExpr.m_isNegated )
-            os << "!";
-
-        if( lazyExpr ) {
-            if( lazyExpr.m_isNegated && lazyExpr.m_transientExpression->isBinaryExpression() )
-                os << "(" << *lazyExpr.m_transientExpression << ")";
-            else
-                os << *lazyExpr.m_transientExpression;
-        }
-        else {
-            os << "{** error - unchecked empty expression requested **}";
-        }
-        return os;
-    }
-
-    AssertionHandler::AssertionHandler
-        (   StringRef const& macroName,
-            SourceLineInfo const& lineInfo,
-            StringRef capturedExpression,
-            ResultDisposition::Flags resultDisposition )
-    :   m_assertionInfo{ macroName, lineInfo, capturedExpression, resultDisposition },
-        m_resultCapture( getResultCapture() )
-    {}
-
-    void AssertionHandler::handleExpr( ITransientExpression const& expr ) {
-        m_resultCapture.handleExpr( m_assertionInfo, expr, m_reaction );
-    }
-    void AssertionHandler::handleMessage(ResultWas::OfType resultType, StringRef const& message) {
-        m_resultCapture.handleMessage( m_assertionInfo, resultType, message, m_reaction );
-    }
-
-    auto AssertionHandler::allowThrows() const -> bool {
-        return getCurrentContext().getConfig()->allowThrows();
-    }
-
-    void AssertionHandler::complete() {
-        setCompleted();
-        if( m_reaction.shouldDebugBreak ) {
-
-            // If you find your debugger stopping you here then go one level up on the
-            // call-stack for the code that caused it (typically a failed assertion)
-
-            // (To go back to the test and change execution, jump over the throw, next)
-            CATCH_BREAK_INTO_DEBUGGER();
-        }
-        if (m_reaction.shouldThrow) {
-#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-            throw Catch::TestFailureException();
-#else
-            CATCH_ERROR( "Test failure requires aborting test!" );
-#endif
-        }
-    }
-    void AssertionHandler::setCompleted() {
-        m_completed = true;
-    }
-
-    void AssertionHandler::handleUnexpectedInflightException() {
-        m_resultCapture.handleUnexpectedInflightException( m_assertionInfo, Catch::translateActiveException(), m_reaction );
-    }
-
-    void AssertionHandler::handleExceptionThrownAsExpected() {
-        m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
-    }
-    void AssertionHandler::handleExceptionNotThrownAsExpected() {
-        m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
-    }
-
-    void AssertionHandler::handleUnexpectedExceptionNotThrown() {
-        m_resultCapture.handleUnexpectedExceptionNotThrown( m_assertionInfo, m_reaction );
-    }
-
-    void AssertionHandler::handleThrowingCallSkipped() {
-        m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
-    }
-
-    // This is the overload that takes a string and infers the Equals matcher from it
-    // The more general overload, that takes any string matcher, is in catch_capture_matchers.cpp
-    void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str, StringRef const& matcherString  ) {
-        handleExceptionMatchExpr( handler, Matchers::Equals( str ), matcherString );
-    }
-
-} // namespace Catch
-// end catch_assertionhandler.cpp
-// start catch_assertionresult.cpp
-
-namespace Catch {
-    AssertionResultData::AssertionResultData(ResultWas::OfType _resultType, LazyExpression const & _lazyExpression):
-        lazyExpression(_lazyExpression),
-        resultType(_resultType) {}
-
-    std::string AssertionResultData::reconstructExpression() const {
-
-        if( reconstructedExpression.empty() ) {
-            if( lazyExpression ) {
-                ReusableStringStream rss;
-                rss << lazyExpression;
-                reconstructedExpression = rss.str();
-            }
-        }
-        return reconstructedExpression;
-    }
-
-    AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData const& data )
-    :   m_info( info ),
-        m_resultData( data )
-    {}
-
-    // Result was a success
-    bool AssertionResult::succeeded() const {
-        return Catch::isOk( m_resultData.resultType );
-    }
-
-    // Result was a success, or failure is suppressed
-    bool AssertionResult::isOk() const {
-        return Catch::isOk( m_resultData.resultType ) || shouldSuppressFailure( m_info.resultDisposition );
-    }
-
-    ResultWas::OfType AssertionResult::getResultType() const {
-        return m_resultData.resultType;
-    }
-
-    bool AssertionResult::hasExpression() const {
-        return m_info.capturedExpression[0] != 0;
-    }
-
-    bool AssertionResult::hasMessage() const {
-        return !m_resultData.message.empty();
-    }
-
-    std::string AssertionResult::getExpression() const {
-        if( isFalseTest( m_info.resultDisposition ) )
-            return "!(" + m_info.capturedExpression + ")";
-        else
-            return m_info.capturedExpression;
-    }
-
-    std::string AssertionResult::getExpressionInMacro() const {
-        std::string expr;
-        if( m_info.macroName[0] == 0 )
-            expr = m_info.capturedExpression;
-        else {
-            expr.reserve( m_info.macroName.size() + m_info.capturedExpression.size() + 4 );
-            expr += m_info.macroName;
-            expr += "( ";
-            expr += m_info.capturedExpression;
-            expr += " )";
-        }
-        return expr;
-    }
-
-    bool AssertionResult::hasExpandedExpression() const {
-        return hasExpression() && getExpandedExpression() != getExpression();
-    }
-
-    std::string AssertionResult::getExpandedExpression() const {
-        std::string expr = m_resultData.reconstructExpression();
-        return expr.empty()
-                ? getExpression()
-                : expr;
-    }
-
-    std::string AssertionResult::getMessage() const {
-        return m_resultData.message;
-    }
-    SourceLineInfo AssertionResult::getSourceInfo() const {
-        return m_info.lineInfo;
-    }
-
-    StringRef AssertionResult::getTestMacroName() const {
-        return m_info.macroName;
-    }
-
-} // end namespace Catch
-// end catch_assertionresult.cpp
-// start catch_capture_matchers.cpp
-
-namespace Catch {
-
-    using StringMatcher = Matchers::Impl::MatcherBase<std::string>;
-
-    // This is the general overload that takes a any string matcher
-    // There is another overload, in catch_assertionhandler.h/.cpp, that only takes a string and infers
-    // the Equals matcher (so the header does not mention matchers)
-    void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher, StringRef const& matcherString  ) {
-        std::string exceptionMessage = Catch::translateActiveException();
-        MatchExpr<std::string, StringMatcher const&> expr( exceptionMessage, matcher, matcherString );
-        handler.handleExpr( expr );
-    }
-
-} // namespace Catch
-// end catch_capture_matchers.cpp
-// start catch_commandline.cpp
-
-// start catch_commandline.h
-
-// start catch_clara.h
-
-// Use Catch's value for console width (store Clara's off to the side, if present)
-#ifdef CLARA_CONFIG_CONSOLE_WIDTH
-#define CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
-#undef CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
-#endif
-#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH-1
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wweak-vtables"
-#pragma clang diagnostic ignored "-Wexit-time-destructors"
-#pragma clang diagnostic ignored "-Wshadow"
-#endif
-
-// start clara.hpp
-// Copyright 2017 Two Blue Cubes Ltd. All rights reserved.
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-// See https://github.com/philsquared/Clara for more details
-
-// Clara v1.1.5
-
-
-#ifndef CATCH_CLARA_CONFIG_CONSOLE_WIDTH
-#define CATCH_CLARA_CONFIG_CONSOLE_WIDTH 80
-#endif
-
-#ifndef CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
-#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_CLARA_CONFIG_CONSOLE_WIDTH
-#endif
-
-#ifndef CLARA_CONFIG_OPTIONAL_TYPE
-#ifdef __has_include
-#if __has_include(<optional>) && __cplusplus >= 201703L
-#include <optional>
-#define CLARA_CONFIG_OPTIONAL_TYPE std::optional
-#endif
-#endif
-#endif
-
-// ----------- #included from clara_textflow.hpp -----------
-
-// TextFlowCpp
-//
-// A single-header library for wrapping and laying out basic text, by Phil Nash
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-// This project is hosted at https://github.com/philsquared/textflowcpp
-
-
-#include <cassert>
-#include <ostream>
-#include <sstream>
-#include <vector>
-
-#ifndef CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
-#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH 80
-#endif
-
-namespace Catch {
-namespace clara {
-namespace TextFlow {
-
-inline auto isWhitespace(char c) -> bool {
-	static std::string chars = " \t\n\r";
-	return chars.find(c) != std::string::npos;
-}
-inline auto isBreakableBefore(char c) -> bool {
-	static std::string chars = "[({<|";
-	return chars.find(c) != std::string::npos;
-}
-inline auto isBreakableAfter(char c) -> bool {
-	static std::string chars = "])}>.,:;*+-=&/\\";
-	return chars.find(c) != std::string::npos;
-}
-
-class Columns;
-
-class Column {
-	std::vector<std::string> m_strings;
-	size_t m_width = CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH;
-	size_t m_indent = 0;
-	size_t m_initialIndent = std::string::npos;
-
-public:
-	class iterator {
-		friend Column;
-
-		Column const& m_column;
-		size_t m_stringIndex = 0;
-		size_t m_pos = 0;
-
-		size_t m_len = 0;
-		size_t m_end = 0;
-		bool m_suffix = false;
-
-		iterator(Column const& column, size_t stringIndex)
-			: m_column(column),
-			m_stringIndex(stringIndex) {}
-
-		auto line() const -> std::string const& { return m_column.m_strings[m_stringIndex]; }
-
-		auto isBoundary(size_t at) const -> bool {
-			assert(at > 0);
-			assert(at <= line().size());
-
-			return at == line().size() ||
-				(isWhitespace(line()[at]) && !isWhitespace(line()[at - 1])) ||
-				isBreakableBefore(line()[at]) ||
-				isBreakableAfter(line()[at - 1]);
-		}
-
-		void calcLength() {
-			assert(m_stringIndex < m_column.m_strings.size());
-
-			m_suffix = false;
-			auto width = m_column.m_width - indent();
-			m_end = m_pos;
-			if (line()[m_pos] == '\n') {
-				++m_end;
-			}
-			while (m_end < line().size() && line()[m_end] != '\n')
-				++m_end;
-
-			if (m_end < m_pos + width) {
-				m_len = m_end - m_pos;
-			} else {
-				size_t len = width;
-				while (len > 0 && !isBoundary(m_pos + len))
-					--len;
-				while (len > 0 && isWhitespace(line()[m_pos + len - 1]))
-					--len;
-
-				if (len > 0) {
-					m_len = len;
-				} else {
-					m_suffix = true;
-					m_len = width - 1;
-				}
-			}
-		}
-
-		auto indent() const -> size_t {
-			auto initial = m_pos == 0 && m_stringIndex == 0 ? m_column.m_initialIndent : std::string::npos;
-			return initial == std::string::npos ? m_column.m_indent : initial;
-		}
-
-		auto addIndentAndSuffix(std::string const &plain) const -> std::string {
-			return std::string(indent(), ' ') + (m_suffix ? plain + "-" : plain);
-		}
-
-	public:
-		using difference_type = std::ptrdiff_t;
-		using value_type = std::string;
-		using pointer = value_type * ;
-		using reference = value_type & ;
-		using iterator_category = std::forward_iterator_tag;
-
-		explicit iterator(Column const& column) : m_column(column) {
-			assert(m_column.m_width > m_column.m_indent);
-			assert(m_column.m_initialIndent == std::string::npos || m_column.m_width > m_column.m_initialIndent);
-			calcLength();
-			if (m_len == 0)
-				m_stringIndex++; // Empty string
-		}
-
-		auto operator *() const -> std::string {
-			assert(m_stringIndex < m_column.m_strings.size());
-			assert(m_pos <= m_end);
-			return addIndentAndSuffix(line().substr(m_pos, m_len));
-		}
-
-		auto operator ++() -> iterator& {
-			m_pos += m_len;
-			if (m_pos < line().size() && line()[m_pos] == '\n')
-				m_pos += 1;
-			else
-				while (m_pos < line().size() && isWhitespace(line()[m_pos]))
-					++m_pos;
-
-			if (m_pos == line().size()) {
-				m_pos = 0;
-				++m_stringIndex;
-			}
-			if (m_stringIndex < m_column.m_strings.size())
-				calcLength();
-			return *this;
-		}
-		auto operator ++(int) -> iterator {
-			iterator prev(*this);
-			operator++();
-			return prev;
-		}
-
-		auto operator ==(iterator const& other) const -> bool {
-			return
-				m_pos == other.m_pos &&
-				m_stringIndex == other.m_stringIndex &&
-				&m_column == &other.m_column;
-		}
-		auto operator !=(iterator const& other) const -> bool {
-			return !operator==(other);
-		}
-	};
-	using const_iterator = iterator;
-
-	explicit Column(std::string const& text) { m_strings.push_back(text); }
-
-	auto width(size_t newWidth) -> Column& {
-		assert(newWidth > 0);
-		m_width = newWidth;
-		return *this;
-	}
-	auto indent(size_t newIndent) -> Column& {
-		m_indent = newIndent;
-		return *this;
-	}
-	auto initialIndent(size_t newIndent) -> Column& {
-		m_initialIndent = newIndent;
-		return *this;
-	}
-
-	auto width() const -> size_t { return m_width; }
-	auto begin() const -> iterator { return iterator(*this); }
-	auto end() const -> iterator { return { *this, m_strings.size() }; }
-
-	inline friend std::ostream& operator << (std::ostream& os, Column const& col) {
-		bool first = true;
-		for (auto line : col) {
-			if (first)
-				first = false;
-			else
-				os << "\n";
-			os << line;
-		}
-		return os;
-	}
-
-	auto operator + (Column const& other)->Columns;
-
-	auto toString() const -> std::string {
-		std::ostringstream oss;
-		oss << *this;
-		return oss.str();
-	}
-};
-
-class Spacer : public Column {
-
-public:
-	explicit Spacer(size_t spaceWidth) : Column("") {
-		width(spaceWidth);
-	}
-};
-
-class Columns {
-	std::vector<Column> m_columns;
-
-public:
-
-	class iterator {
-		friend Columns;
-		struct EndTag {};
-
-		std::vector<Column> const& m_columns;
-		std::vector<Column::iterator> m_iterators;
-		size_t m_activeIterators;
-
-		iterator(Columns const& columns, EndTag)
-			: m_columns(columns.m_columns),
-			m_activeIterators(0) {
-			m_iterators.reserve(m_columns.size());
-
-			for (auto const& col : m_columns)
-				m_iterators.push_back(col.end());
-		}
-
-	public:
-		using difference_type = std::ptrdiff_t;
-		using value_type = std::string;
-		using pointer = value_type * ;
-		using reference = value_type & ;
-		using iterator_category = std::forward_iterator_tag;
-
-		explicit iterator(Columns const& columns)
-			: m_columns(columns.m_columns),
-			m_activeIterators(m_columns.size()) {
-			m_iterators.reserve(m_columns.size());
-
-			for (auto const& col : m_columns)
-				m_iterators.push_back(col.begin());
-		}
-
-		auto operator ==(iterator const& other) const -> bool {
-			return m_iterators == other.m_iterators;
-		}
-		auto operator !=(iterator const& other) const -> bool {
-			return m_iterators != other.m_iterators;
-		}
-		auto operator *() const -> std::string {
-			std::string row, padding;
-
-			for (size_t i = 0; i < m_columns.size(); ++i) {
-				auto width = m_columns[i].width();
-				if (m_iterators[i] != m_columns[i].end()) {
-					std::string col = *m_iterators[i];
-					row += padding + col;
-					if (col.size() < width)
-						padding = std::string(width - col.size(), ' ');
-					else
-						padding = "";
-				} else {
-					padding += std::string(width, ' ');
-				}
-			}
-			return row;
-		}
-		auto operator ++() -> iterator& {
-			for (size_t i = 0; i < m_columns.size(); ++i) {
-				if (m_iterators[i] != m_columns[i].end())
-					++m_iterators[i];
-			}
-			return *this;
-		}
-		auto operator ++(int) -> iterator {
-			iterator prev(*this);
-			operator++();
-			return prev;
-		}
-	};
-	using const_iterator = iterator;
-
-	auto begin() const -> iterator { return iterator(*this); }
-	auto end() const -> iterator { return { *this, iterator::EndTag() }; }
-
-	auto operator += (Column const& col) -> Columns& {
-		m_columns.push_back(col);
-		return *this;
-	}
-	auto operator + (Column const& col) -> Columns {
-		Columns combined = *this;
-		combined += col;
-		return combined;
-	}
-
-	inline friend std::ostream& operator << (std::ostream& os, Columns const& cols) {
-
-		bool first = true;
-		for (auto line : cols) {
-			if (first)
-				first = false;
-			else
-				os << "\n";
-			os << line;
-		}
-		return os;
-	}
-
-	auto toString() const -> std::string {
-		std::ostringstream oss;
-		oss << *this;
-		return oss.str();
-	}
-};
-
-inline auto Column::operator + (Column const& other) -> Columns {
-	Columns cols;
-	cols += *this;
-	cols += other;
-	return cols;
-}
-}
-
-}
-}
-
-// ----------- end of #include from clara_textflow.hpp -----------
-// ........... back in clara.hpp
-
-#include <cctype>
-#include <string>
-#include <memory>
-#include <set>
-#include <algorithm>
-
-#if !defined(CATCH_PLATFORM_WINDOWS) && ( defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) )
-#define CATCH_PLATFORM_WINDOWS
-#endif
-
-namespace Catch { namespace clara {
-namespace detail {
-
-    // Traits for extracting arg and return type of lambdas (for single argument lambdas)
-    template<typename L>
-    struct UnaryLambdaTraits : UnaryLambdaTraits<decltype( &L::operator() )> {};
-
-    template<typename ClassT, typename ReturnT, typename... Args>
-    struct UnaryLambdaTraits<ReturnT( ClassT::* )( Args... ) const> {
-        static const bool isValid = false;
-    };
-
-    template<typename ClassT, typename ReturnT, typename ArgT>
-    struct UnaryLambdaTraits<ReturnT( ClassT::* )( ArgT ) const> {
-        static const bool isValid = true;
-        using ArgType = typename std::remove_const<typename std::remove_reference<ArgT>::type>::type;
-        using ReturnType = ReturnT;
-    };
-
-    class TokenStream;
-
-    // Transport for raw args (copied from main args, or supplied via init list for testing)
-    class Args {
-        friend TokenStream;
-        std::string m_exeName;
-        std::vector<std::string> m_args;
-
-    public:
-        Args( int argc, char const* const* argv )
-            : m_exeName(argv[0]),
-              m_args(argv + 1, argv + argc) {}
-
-        Args( std::initializer_list<std::string> args )
-        :   m_exeName( *args.begin() ),
-            m_args( args.begin()+1, args.end() )
-        {}
-
-        auto exeName() const -> std::string {
-            return m_exeName;
-        }
-    };
-
-    // Wraps a token coming from a token stream. These may not directly correspond to strings as a single string
-    // may encode an option + its argument if the : or = form is used
-    enum class TokenType {
-        Option, Argument
-    };
-    struct Token {
-        TokenType type;
-        std::string token;
-    };
-
-    inline auto isOptPrefix( char c ) -> bool {
-        return c == '-'
-#ifdef CATCH_PLATFORM_WINDOWS
-            || c == '/'
-#endif
-        ;
-    }
-
-    // Abstracts iterators into args as a stream of tokens, with option arguments uniformly handled
-    class TokenStream {
-        using Iterator = std::vector<std::string>::const_iterator;
-        Iterator it;
-        Iterator itEnd;
-        std::vector<Token> m_tokenBuffer;
-
-        void loadBuffer() {
-            m_tokenBuffer.resize( 0 );
-
-            // Skip any empty strings
-            while( it != itEnd && it->empty() )
-                ++it;
-
-            if( it != itEnd ) {
-                auto const &next = *it;
-                if( isOptPrefix( next[0] ) ) {
-                    auto delimiterPos = next.find_first_of( " :=" );
-                    if( delimiterPos != std::string::npos ) {
-                        m_tokenBuffer.push_back( { TokenType::Option, next.substr( 0, delimiterPos ) } );
-                        m_tokenBuffer.push_back( { TokenType::Argument, next.substr( delimiterPos + 1 ) } );
-                    } else {
-                        if( next[1] != '-' && next.size() > 2 ) {
-                            std::string opt = "- ";
-                            for( size_t i = 1; i < next.size(); ++i ) {
-                                opt[1] = next[i];
-                                m_tokenBuffer.push_back( { TokenType::Option, opt } );
-                            }
-                        } else {
-                            m_tokenBuffer.push_back( { TokenType::Option, next } );
-                        }
-                    }
-                } else {
-                    m_tokenBuffer.push_back( { TokenType::Argument, next } );
-                }
-            }
-        }
-
-    public:
-        explicit TokenStream( Args const &args ) : TokenStream( args.m_args.begin(), args.m_args.end() ) {}
-
-        TokenStream( Iterator it, Iterator itEnd ) : it( it ), itEnd( itEnd ) {
-            loadBuffer();
-        }
-
-        explicit operator bool() const {
-            return !m_tokenBuffer.empty() || it != itEnd;
-        }
-
-        auto count() const -> size_t { return m_tokenBuffer.size() + (itEnd - it); }
-
-        auto operator*() const -> Token {
-            assert( !m_tokenBuffer.empty() );
-            return m_tokenBuffer.front();
-        }
-
-        auto operator->() const -> Token const * {
-            assert( !m_tokenBuffer.empty() );
-            return &m_tokenBuffer.front();
-        }
-
-        auto operator++() -> TokenStream & {
-            if( m_tokenBuffer.size() >= 2 ) {
-                m_tokenBuffer.erase( m_tokenBuffer.begin() );
-            } else {
-                if( it != itEnd )
-                    ++it;
-                loadBuffer();
-            }
-            return *this;
-        }
-    };
-
-    class ResultBase {
-    public:
-        enum Type {
-            Ok, LogicError, RuntimeError
-        };
-
-    protected:
-        ResultBase( Type type ) : m_type( type ) {}
-        virtual ~ResultBase() = default;
-
-        virtual void enforceOk() const = 0;
-
-        Type m_type;
-    };
-
-    template<typename T>
-    class ResultValueBase : public ResultBase {
-    public:
-        auto value() const -> T const & {
-            enforceOk();
-            return m_value;
-        }
-
-    protected:
-        ResultValueBase( Type type ) : ResultBase( type ) {}
-
-        ResultValueBase( ResultValueBase const &other ) : ResultBase( other ) {
-            if( m_type == ResultBase::Ok )
-                new( &m_value ) T( other.m_value );
-        }
-
-        ResultValueBase( Type, T const &value ) : ResultBase( Ok ) {
-            new( &m_value ) T( value );
-        }
-
-        auto operator=( ResultValueBase const &other ) -> ResultValueBase & {
-            if( m_type == ResultBase::Ok )
-                m_value.~T();
-            ResultBase::operator=(other);
-            if( m_type == ResultBase::Ok )
-                new( &m_value ) T( other.m_value );
-            return *this;
-        }
-
-        ~ResultValueBase() override {
-            if( m_type == Ok )
-                m_value.~T();
-        }
-
-        union {
-            T m_value;
-        };
-    };
-
-    template<>
-    class ResultValueBase<void> : public ResultBase {
-    protected:
-        using ResultBase::ResultBase;
-    };
-
-    template<typename T = void>
-    class BasicResult : public ResultValueBase<T> {
-    public:
-        template<typename U>
-        explicit BasicResult( BasicResult<U> const &other )
-        :   ResultValueBase<T>( other.type() ),
-            m_errorMessage( other.errorMessage() )
-        {
-            assert( type() != ResultBase::Ok );
-        }
-
-        template<typename U>
-        static auto ok( U const &value ) -> BasicResult { return { ResultBase::Ok, value }; }
-        static auto ok() -> BasicResult { return { ResultBase::Ok }; }
-        static auto logicError( std::string const &message ) -> BasicResult { return { ResultBase::LogicError, message }; }
-        static auto runtimeError( std::string const &message ) -> BasicResult { return { ResultBase::RuntimeError, message }; }
-
-        explicit operator bool() const { return m_type == ResultBase::Ok; }
-        auto type() const -> ResultBase::Type { return m_type; }
-        auto errorMessage() const -> std::string { return m_errorMessage; }
-
-    protected:
-        void enforceOk() const override {
-
-            // Errors shouldn't reach this point, but if they do
-            // the actual error message will be in m_errorMessage
-            assert( m_type != ResultBase::LogicError );
-            assert( m_type != ResultBase::RuntimeError );
-            if( m_type != ResultBase::Ok )
-                std::abort();
-        }
-
-        std::string m_errorMessage; // Only populated if resultType is an error
-
-        BasicResult( ResultBase::Type type, std::string const &message )
-        :   ResultValueBase<T>(type),
-            m_errorMessage(message)
-        {
-            assert( m_type != ResultBase::Ok );
-        }
-
-        using ResultValueBase<T>::ResultValueBase;
-        using ResultBase::m_type;
-    };
-
-    enum class ParseResultType {
-        Matched, NoMatch, ShortCircuitAll, ShortCircuitSame
-    };
-
-    class ParseState {
-    public:
-
-        ParseState( ParseResultType type, TokenStream const &remainingTokens )
-        : m_type(type),
-          m_remainingTokens( remainingTokens )
-        {}
-
-        auto type() const -> ParseResultType { return m_type; }
-        auto remainingTokens() const -> TokenStream { return m_remainingTokens; }
-
-    private:
-        ParseResultType m_type;
-        TokenStream m_remainingTokens;
-    };
-
-    using Result = BasicResult<void>;
-    using ParserResult = BasicResult<ParseResultType>;
-    using InternalParseResult = BasicResult<ParseState>;
-
-    struct HelpColumns {
-        std::string left;
-        std::string right;
-    };
-
-    template<typename T>
-    inline auto convertInto( std::string const &source, T& target ) -> ParserResult {
-        std::stringstream ss;
-        ss << source;
-        ss >> target;
-        if( ss.fail() )
-            return ParserResult::runtimeError( "Unable to convert '" + source + "' to destination type" );
-        else
-            return ParserResult::ok( ParseResultType::Matched );
-    }
-    inline auto convertInto( std::string const &source, std::string& target ) -> ParserResult {
-        target = source;
-        return ParserResult::ok( ParseResultType::Matched );
-    }
-    inline auto convertInto( std::string const &source, bool &target ) -> ParserResult {
-        std::string srcLC = source;
-        std::transform( srcLC.begin(), srcLC.end(), srcLC.begin(), []( char c ) { return static_cast<char>( std::tolower(c) ); } );
-        if (srcLC == "y" || srcLC == "1" || srcLC == "true" || srcLC == "yes" || srcLC == "on")
-            target = true;
-        else if (srcLC == "n" || srcLC == "0" || srcLC == "false" || srcLC == "no" || srcLC == "off")
-            target = false;
-        else
-            return ParserResult::runtimeError( "Expected a boolean value but did not recognise: '" + source + "'" );
-        return ParserResult::ok( ParseResultType::Matched );
-    }
-#ifdef CLARA_CONFIG_OPTIONAL_TYPE
-    template<typename T>
-    inline auto convertInto( std::string const &source, CLARA_CONFIG_OPTIONAL_TYPE<T>& target ) -> ParserResult {
-        T temp;
-        auto result = convertInto( source, temp );
-        if( result )
-            target = std::move(temp);
-        return result;
-    }
-#endif // CLARA_CONFIG_OPTIONAL_TYPE
-
-    struct NonCopyable {
-        NonCopyable() = default;
-        NonCopyable( NonCopyable const & ) = delete;
-        NonCopyable( NonCopyable && ) = delete;
-        NonCopyable &operator=( NonCopyable const & ) = delete;
-        NonCopyable &operator=( NonCopyable && ) = delete;
-    };
-
-    struct BoundRef : NonCopyable {
-        virtual ~BoundRef() = default;
-        virtual auto isContainer() const -> bool { return false; }
-        virtual auto isFlag() const -> bool { return false; }
-    };
-    struct BoundValueRefBase : BoundRef {
-        virtual auto setValue( std::string const &arg ) -> ParserResult = 0;
-    };
-    struct BoundFlagRefBase : BoundRef {
-        virtual auto setFlag( bool flag ) -> ParserResult = 0;
-        virtual auto isFlag() const -> bool { return true; }
-    };
-
-    template<typename T>
-    struct BoundValueRef : BoundValueRefBase {
-        T &m_ref;
-
-        explicit BoundValueRef( T &ref ) : m_ref( ref ) {}
-
-        auto setValue( std::string const &arg ) -> ParserResult override {
-            return convertInto( arg, m_ref );
-        }
-    };
-
-    template<typename T>
-    struct BoundValueRef<std::vector<T>> : BoundValueRefBase {
-        std::vector<T> &m_ref;
-
-        explicit BoundValueRef( std::vector<T> &ref ) : m_ref( ref ) {}
-
-        auto isContainer() const -> bool override { return true; }
-
-        auto setValue( std::string const &arg ) -> ParserResult override {
-            T temp;
-            auto result = convertInto( arg, temp );
-            if( result )
-                m_ref.push_back( temp );
-            return result;
-        }
-    };
-
-    struct BoundFlagRef : BoundFlagRefBase {
-        bool &m_ref;
-
-        explicit BoundFlagRef( bool &ref ) : m_ref( ref ) {}
-
-        auto setFlag( bool flag ) -> ParserResult override {
-            m_ref = flag;
-            return ParserResult::ok( ParseResultType::Matched );
-        }
-    };
-
-    template<typename ReturnType>
-    struct LambdaInvoker {
-        static_assert( std::is_same<ReturnType, ParserResult>::value, "Lambda must return void or clara::ParserResult" );
-
-        template<typename L, typename ArgType>
-        static auto invoke( L const &lambda, ArgType const &arg ) -> ParserResult {
-            return lambda( arg );
-        }
-    };
-
-    template<>
-    struct LambdaInvoker<void> {
-        template<typename L, typename ArgType>
-        static auto invoke( L const &lambda, ArgType const &arg ) -> ParserResult {
-            lambda( arg );
-            return ParserResult::ok( ParseResultType::Matched );
-        }
-    };
-
-    template<typename ArgType, typename L>
-    inline auto invokeLambda( L const &lambda, std::string const &arg ) -> ParserResult {
-        ArgType temp{};
-        auto result = convertInto( arg, temp );
-        return !result
-           ? result
-           : LambdaInvoker<typename UnaryLambdaTraits<L>::ReturnType>::invoke( lambda, temp );
-    }
-
-    template<typename L>
-    struct BoundLambda : BoundValueRefBase {
-        L m_lambda;
-
-        static_assert( UnaryLambdaTraits<L>::isValid, "Supplied lambda must take exactly one argument" );
-        explicit BoundLambda( L const &lambda ) : m_lambda( lambda ) {}
-
-        auto setValue( std::string const &arg ) -> ParserResult override {
-            return invokeLambda<typename UnaryLambdaTraits<L>::ArgType>( m_lambda, arg );
-        }
-    };
-
-    template<typename L>
-    struct BoundFlagLambda : BoundFlagRefBase {
-        L m_lambda;
-
-        static_assert( UnaryLambdaTraits<L>::isValid, "Supplied lambda must take exactly one argument" );
-        static_assert( std::is_same<typename UnaryLambdaTraits<L>::ArgType, bool>::value, "flags must be boolean" );
-
-        explicit BoundFlagLambda( L const &lambda ) : m_lambda( lambda ) {}
-
-        auto setFlag( bool flag ) -> ParserResult override {
-            return LambdaInvoker<typename UnaryLambdaTraits<L>::ReturnType>::invoke( m_lambda, flag );
-        }
-    };
-
-    enum class Optionality { Optional, Required };
-
-    struct Parser;
-
-    class ParserBase {
-    public:
-        virtual ~ParserBase() = default;
-        virtual auto validate() const -> Result { return Result::ok(); }
-        virtual auto parse( std::string const& exeName, TokenStream const &tokens) const -> InternalParseResult  = 0;
-        virtual auto cardinality() const -> size_t { return 1; }
-
-        auto parse( Args const &args ) const -> InternalParseResult {
-            return parse( args.exeName(), TokenStream( args ) );
-        }
-    };
-
-    template<typename DerivedT>
-    class ComposableParserImpl : public ParserBase {
-    public:
-        template<typename T>
-        auto operator|( T const &other ) const -> Parser;
-
-		template<typename T>
-        auto operator+( T const &other ) const -> Parser;
-    };
-
-    // Common code and state for Args and Opts
-    template<typename DerivedT>
-    class ParserRefImpl : public ComposableParserImpl<DerivedT> {
-    protected:
-        Optionality m_optionality = Optionality::Optional;
-        std::shared_ptr<BoundRef> m_ref;
-        std::string m_hint;
-        std::string m_description;
-
-        explicit ParserRefImpl( std::shared_ptr<BoundRef> const &ref ) : m_ref( ref ) {}
-
-    public:
-        template<typename T>
-        ParserRefImpl( T &ref, std::string const &hint )
-        :   m_ref( std::make_shared<BoundValueRef<T>>( ref ) ),
-            m_hint( hint )
-        {}
-
-        template<typename LambdaT>
-        ParserRefImpl( LambdaT const &ref, std::string const &hint )
-        :   m_ref( std::make_shared<BoundLambda<LambdaT>>( ref ) ),
-            m_hint(hint)
-        {}
-
-        auto operator()( std::string const &description ) -> DerivedT & {
-            m_description = description;
-            return static_cast<DerivedT &>( *this );
-        }
-
-        auto optional() -> DerivedT & {
-            m_optionality = Optionality::Optional;
-            return static_cast<DerivedT &>( *this );
-        };
-
-        auto required() -> DerivedT & {
-            m_optionality = Optionality::Required;
-            return static_cast<DerivedT &>( *this );
-        };
-
-        auto isOptional() const -> bool {
-            return m_optionality == Optionality::Optional;
-        }
-
-        auto cardinality() const -> size_t override {
-            if( m_ref->isContainer() )
-                return 0;
-            else
-                return 1;
-        }
-
-        auto hint() const -> std::string { return m_hint; }
-    };
-
-    class ExeName : public ComposableParserImpl<ExeName> {
-        std::shared_ptr<std::string> m_name;
-        std::shared_ptr<BoundValueRefBase> m_ref;
-
-        template<typename LambdaT>
-        static auto makeRef(LambdaT const &lambda) -> std::shared_ptr<BoundValueRefBase> {
-            return std::make_shared<BoundLambda<LambdaT>>( lambda) ;
-        }
-
-    public:
-        ExeName() : m_name( std::make_shared<std::string>( "<executable>" ) ) {}
-
-        explicit ExeName( std::string &ref ) : ExeName() {
-            m_ref = std::make_shared<BoundValueRef<std::string>>( ref );
-        }
-
-        template<typename LambdaT>
-        explicit ExeName( LambdaT const& lambda ) : ExeName() {
-            m_ref = std::make_shared<BoundLambda<LambdaT>>( lambda );
-        }
-
-        // The exe name is not parsed out of the normal tokens, but is handled specially
-        auto parse( std::string const&, TokenStream const &tokens ) const -> InternalParseResult override {
-            return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, tokens ) );
-        }
-
-        auto name() const -> std::string { return *m_name; }
-        auto set( std::string const& newName ) -> ParserResult {
-
-            auto lastSlash = newName.find_last_of( "\\/" );
-            auto filename = ( lastSlash == std::string::npos )
-                    ? newName
-                    : newName.substr( lastSlash+1 );
-
-            *m_name = filename;
-            if( m_ref )
-                return m_ref->setValue( filename );
-            else
-                return ParserResult::ok( ParseResultType::Matched );
-        }
-    };
-
-    class Arg : public ParserRefImpl<Arg> {
-    public:
-        using ParserRefImpl::ParserRefImpl;
-
-        auto parse( std::string const &, TokenStream const &tokens ) const -> InternalParseResult override {
-            auto validationResult = validate();
-            if( !validationResult )
-                return InternalParseResult( validationResult );
-
-            auto remainingTokens = tokens;
-            auto const &token = *remainingTokens;
-            if( token.type != TokenType::Argument )
-                return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, remainingTokens ) );
-
-            assert( !m_ref->isFlag() );
-            auto valueRef = static_cast<detail::BoundValueRefBase*>( m_ref.get() );
-
-            auto result = valueRef->setValue( remainingTokens->token );
-            if( !result )
-                return InternalParseResult( result );
-            else
-                return InternalParseResult::ok( ParseState( ParseResultType::Matched, ++remainingTokens ) );
-        }
-    };
-
-    inline auto normaliseOpt( std::string const &optName ) -> std::string {
-#ifdef CATCH_PLATFORM_WINDOWS
-        if( optName[0] == '/' )
-            return "-" + optName.substr( 1 );
-        else
-#endif
-            return optName;
-    }
-
-    class Opt : public ParserRefImpl<Opt> {
-    protected:
-        std::vector<std::string> m_optNames;
-
-    public:
-        template<typename LambdaT>
-        explicit Opt( LambdaT const &ref ) : ParserRefImpl( std::make_shared<BoundFlagLambda<LambdaT>>( ref ) ) {}
-
-        explicit Opt( bool &ref ) : ParserRefImpl( std::make_shared<BoundFlagRef>( ref ) ) {}
-
-        template<typename LambdaT>
-        Opt( LambdaT const &ref, std::string const &hint ) : ParserRefImpl( ref, hint ) {}
-
-        template<typename T>
-        Opt( T &ref, std::string const &hint ) : ParserRefImpl( ref, hint ) {}
-
-        auto operator[]( std::string const &optName ) -> Opt & {
-            m_optNames.push_back( optName );
-            return *this;
-        }
-
-        auto getHelpColumns() const -> std::vector<HelpColumns> {
-            std::ostringstream oss;
-            bool first = true;
-            for( auto const &opt : m_optNames ) {
-                if (first)
-                    first = false;
-                else
-                    oss << ", ";
-                oss << opt;
-            }
-            if( !m_hint.empty() )
-                oss << " <" << m_hint << ">";
-            return { { oss.str(), m_description } };
-        }
-
-        auto isMatch( std::string const &optToken ) const -> bool {
-            auto normalisedToken = normaliseOpt( optToken );
-            for( auto const &name : m_optNames ) {
-                if( normaliseOpt( name ) == normalisedToken )
-                    return true;
-            }
-            return false;
-        }
-
-        using ParserBase::parse;
-
-        auto parse( std::string const&, TokenStream const &tokens ) const -> InternalParseResult override {
-            auto validationResult = validate();
-            if( !validationResult )
-                return InternalParseResult( validationResult );
-
-            auto remainingTokens = tokens;
-            if( remainingTokens && remainingTokens->type == TokenType::Option ) {
-                auto const &token = *remainingTokens;
-                if( isMatch(token.token ) ) {
-                    if( m_ref->isFlag() ) {
-                        auto flagRef = static_cast<detail::BoundFlagRefBase*>( m_ref.get() );
-                        auto result = flagRef->setFlag( true );
-                        if( !result )
-                            return InternalParseResult( result );
-                        if( result.value() == ParseResultType::ShortCircuitAll )
-                            return InternalParseResult::ok( ParseState( result.value(), remainingTokens ) );
-                    } else {
-                        auto valueRef = static_cast<detail::BoundValueRefBase*>( m_ref.get() );
-                        ++remainingTokens;
-                        if( !remainingTokens )
-                            return InternalParseResult::runtimeError( "Expected argument following " + token.token );
-                        auto const &argToken = *remainingTokens;
-                        if( argToken.type != TokenType::Argument )
-                            return InternalParseResult::runtimeError( "Expected argument following " + token.token );
-                        auto result = valueRef->setValue( argToken.token );
-                        if( !result )
-                            return InternalParseResult( result );
-                        if( result.value() == ParseResultType::ShortCircuitAll )
-                            return InternalParseResult::ok( ParseState( result.value(), remainingTokens ) );
-                    }
-                    return InternalParseResult::ok( ParseState( ParseResultType::Matched, ++remainingTokens ) );
-                }
-            }
-            return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, remainingTokens ) );
-        }
-
-        auto validate() const -> Result override {
-            if( m_optNames.empty() )
-                return Result::logicError( "No options supplied to Opt" );
-            for( auto const &name : m_optNames ) {
-                if( name.empty() )
-                    return Result::logicError( "Option name cannot be empty" );
-#ifdef CATCH_PLATFORM_WINDOWS
-                if( name[0] != '-' && name[0] != '/' )
-                    return Result::logicError( "Option name must begin with '-' or '/'" );
-#else
-                if( name[0] != '-' )
-                    return Result::logicError( "Option name must begin with '-'" );
-#endif
-            }
-            return ParserRefImpl::validate();
-        }
-    };
-
-    struct Help : Opt {
-        Help( bool &showHelpFlag )
-        :   Opt([&]( bool flag ) {
-                showHelpFlag = flag;
-                return ParserResult::ok( ParseResultType::ShortCircuitAll );
-            })
-        {
-            static_cast<Opt &>( *this )
-                    ("display usage information")
-                    ["-?"]["-h"]["--help"]
-                    .optional();
-        }
-    };
-
-    struct Parser : ParserBase {
-
-        mutable ExeName m_exeName;
-        std::vector<Opt> m_options;
-        std::vector<Arg> m_args;
-
-        auto operator|=( ExeName const &exeName ) -> Parser & {
-            m_exeName = exeName;
-            return *this;
-        }
-
-        auto operator|=( Arg const &arg ) -> Parser & {
-            m_args.push_back(arg);
-            return *this;
-        }
-
-        auto operator|=( Opt const &opt ) -> Parser & {
-            m_options.push_back(opt);
-            return *this;
-        }
-
-        auto operator|=( Parser const &other ) -> Parser & {
-            m_options.insert(m_options.end(), other.m_options.begin(), other.m_options.end());
-            m_args.insert(m_args.end(), other.m_args.begin(), other.m_args.end());
-            return *this;
-        }
-
-        template<typename T>
-        auto operator|( T const &other ) const -> Parser {
-            return Parser( *this ) |= other;
-        }
-
-        // Forward deprecated interface with '+' instead of '|'
-        template<typename T>
-        auto operator+=( T const &other ) -> Parser & { return operator|=( other ); }
-        template<typename T>
-        auto operator+( T const &other ) const -> Parser { return operator|( other ); }
-
-        auto getHelpColumns() const -> std::vector<HelpColumns> {
-            std::vector<HelpColumns> cols;
-            for (auto const &o : m_options) {
-                auto childCols = o.getHelpColumns();
-                cols.insert( cols.end(), childCols.begin(), childCols.end() );
-            }
-            return cols;
-        }
-
-        void writeToStream( std::ostream &os ) const {
-            if (!m_exeName.name().empty()) {
-                os << "usage:\n" << "  " << m_exeName.name() << " ";
-                bool required = true, first = true;
-                for( auto const &arg : m_args ) {
-                    if (first)
-                        first = false;
-                    else
-                        os << " ";
-                    if( arg.isOptional() && required ) {
-                        os << "[";
-                        required = false;
-                    }
-                    os << "<" << arg.hint() << ">";
-                    if( arg.cardinality() == 0 )
-                        os << " ... ";
-                }
-                if( !required )
-                    os << "]";
-                if( !m_options.empty() )
-                    os << " options";
-                os << "\n\nwhere options are:" << std::endl;
-            }
-
-            auto rows = getHelpColumns();
-            size_t consoleWidth = CATCH_CLARA_CONFIG_CONSOLE_WIDTH;
-            size_t optWidth = 0;
-            for( auto const &cols : rows )
-                optWidth = (std::max)(optWidth, cols.left.size() + 2);
-
-            optWidth = (std::min)(optWidth, consoleWidth/2);
-
-            for( auto const &cols : rows ) {
-                auto row =
-                        TextFlow::Column( cols.left ).width( optWidth ).indent( 2 ) +
-                        TextFlow::Spacer(4) +
-                        TextFlow::Column( cols.right ).width( consoleWidth - 7 - optWidth );
-                os << row << std::endl;
-            }
-        }
-
-        friend auto operator<<( std::ostream &os, Parser const &parser ) -> std::ostream& {
-            parser.writeToStream( os );
-            return os;
-        }
-
-        auto validate() const -> Result override {
-            for( auto const &opt : m_options ) {
-                auto result = opt.validate();
-                if( !result )
-                    return result;
-            }
-            for( auto const &arg : m_args ) {
-                auto result = arg.validate();
-                if( !result )
-                    return result;
-            }
-            return Result::ok();
-        }
-
-        using ParserBase::parse;
-
-        auto parse( std::string const& exeName, TokenStream const &tokens ) const -> InternalParseResult override {
-
-            struct ParserInfo {
-                ParserBase const* parser = nullptr;
-                size_t count = 0;
-            };
-            const size_t totalParsers = m_options.size() + m_args.size();
-            assert( totalParsers < 512 );
-            // ParserInfo parseInfos[totalParsers]; // <-- this is what we really want to do
-            ParserInfo parseInfos[512];
-
-            {
-                size_t i = 0;
-                for (auto const &opt : m_options) parseInfos[i++].parser = &opt;
-                for (auto const &arg : m_args) parseInfos[i++].parser = &arg;
-            }
-
-            m_exeName.set( exeName );
-
-            auto result = InternalParseResult::ok( ParseState( ParseResultType::NoMatch, tokens ) );
-            while( result.value().remainingTokens() ) {
-                bool tokenParsed = false;
-
-                for( size_t i = 0; i < totalParsers; ++i ) {
-                    auto&  parseInfo = parseInfos[i];
-                    if( parseInfo.parser->cardinality() == 0 || parseInfo.count < parseInfo.parser->cardinality() ) {
-                        result = parseInfo.parser->parse(exeName, result.value().remainingTokens());
-                        if (!result)
-                            return result;
-                        if (result.value().type() != ParseResultType::NoMatch) {
-                            tokenParsed = true;
-                            ++parseInfo.count;
-                            break;
-                        }
-                    }
-                }
-
-                if( result.value().type() == ParseResultType::ShortCircuitAll )
-                    return result;
-                if( !tokenParsed )
-                    return InternalParseResult::runtimeError( "Unrecognised token: " + result.value().remainingTokens()->token );
-            }
-            // !TBD Check missing required options
-            return result;
-        }
-    };
-
-    template<typename DerivedT>
-    template<typename T>
-    auto ComposableParserImpl<DerivedT>::operator|( T const &other ) const -> Parser {
-        return Parser() | static_cast<DerivedT const &>( *this ) | other;
-    }
-} // namespace detail
-
-// A Combined parser
-using detail::Parser;
-
-// A parser for options
-using detail::Opt;
-
-// A parser for arguments
-using detail::Arg;
-
-// Wrapper for argc, argv from main()
-using detail::Args;
-
-// Specifies the name of the executable
-using detail::ExeName;
-
-// Convenience wrapper for option parser that specifies the help option
-using detail::Help;
-
-// enum of result types from a parse
-using detail::ParseResultType;
-
-// Result type for parser operation
-using detail::ParserResult;
-
-}} // namespace Catch::clara
-
-// end clara.hpp
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
-// Restore Clara's value for console width, if present
-#ifdef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
-#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
-#undef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
-#endif
-
-// end catch_clara.h
-namespace Catch {
-
-    clara::Parser makeCommandLineParser( ConfigData& config );
-
-} // end namespace Catch
-
-// end catch_commandline.h
-#include <fstream>
-#include <ctime>
-
-namespace Catch {
-
-    clara::Parser makeCommandLineParser( ConfigData& config ) {
-
-        using namespace clara;
-
-        auto const setWarning = [&]( std::string const& warning ) {
-                auto warningSet = [&]() {
-                    if( warning == "NoAssertions" )
-                        return WarnAbout::NoAssertions;
-
-                    if ( warning == "NoTests" )
-                        return WarnAbout::NoTests;
-
-                    return WarnAbout::Nothing;
-                }();
-
-                if (warningSet == WarnAbout::Nothing)
-                    return ParserResult::runtimeError( "Unrecognised warning: '" + warning + "'" );
-                config.warnings = static_cast<WarnAbout::What>( config.warnings | warningSet );
-                return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const loadTestNamesFromFile = [&]( std::string const& filename ) {
-                std::ifstream f( filename.c_str() );
-                if( !f.is_open() )
-                    return ParserResult::runtimeError( "Unable to load input file: '" + filename + "'" );
-
-                std::string line;
-                while( std::getline( f, line ) ) {
-                    line = trim(line);
-                    if( !line.empty() && !startsWith( line, '#' ) ) {
-                        if( !startsWith( line, '"' ) )
-                            line = '"' + line + '"';
-                        config.testsOrTags.push_back( line + ',' );
-                    }
-                }
-                return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const setTestOrder = [&]( std::string const& order ) {
-                if( startsWith( "declared", order ) )
-                    config.runOrder = RunTests::InDeclarationOrder;
-                else if( startsWith( "lexical", order ) )
-                    config.runOrder = RunTests::InLexicographicalOrder;
-                else if( startsWith( "random", order ) )
-                    config.runOrder = RunTests::InRandomOrder;
-                else
-                    return clara::ParserResult::runtimeError( "Unrecognised ordering: '" + order + "'" );
-                return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const setRngSeed = [&]( std::string const& seed ) {
-                if( seed != "time" )
-                    return clara::detail::convertInto( seed, config.rngSeed );
-                config.rngSeed = static_cast<unsigned int>( std::time(nullptr) );
-                return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const setColourUsage = [&]( std::string const& useColour ) {
-                    auto mode = toLower( useColour );
-
-                    if( mode == "yes" )
-                        config.useColour = UseColour::Yes;
-                    else if( mode == "no" )
-                        config.useColour = UseColour::No;
-                    else if( mode == "auto" )
-                        config.useColour = UseColour::Auto;
-                    else
-                        return ParserResult::runtimeError( "colour mode must be one of: auto, yes or no. '" + useColour + "' not recognised" );
-                return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const setWaitForKeypress = [&]( std::string const& keypress ) {
-                auto keypressLc = toLower( keypress );
-                if( keypressLc == "start" )
-                    config.waitForKeypress = WaitForKeypress::BeforeStart;
-                else if( keypressLc == "exit" )
-                    config.waitForKeypress = WaitForKeypress::BeforeExit;
-                else if( keypressLc == "both" )
-                    config.waitForKeypress = WaitForKeypress::BeforeStartAndExit;
-                else
-                    return ParserResult::runtimeError( "keypress argument must be one of: start, exit or both. '" + keypress + "' not recognised" );
-            return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const setVerbosity = [&]( std::string const& verbosity ) {
-            auto lcVerbosity = toLower( verbosity );
-            if( lcVerbosity == "quiet" )
-                config.verbosity = Verbosity::Quiet;
-            else if( lcVerbosity == "normal" )
-                config.verbosity = Verbosity::Normal;
-            else if( lcVerbosity == "high" )
-                config.verbosity = Verbosity::High;
-            else
-                return ParserResult::runtimeError( "Unrecognised verbosity, '" + verbosity + "'" );
-            return ParserResult::ok( ParseResultType::Matched );
-        };
-        auto const setReporter = [&]( std::string const& reporter ) {
-            IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories();
-
-            auto lcReporter = toLower( reporter );
-            auto result = factories.find( lcReporter );
-
-            if( factories.end() != result )
-                config.reporterName = lcReporter;
-            else
-                return ParserResult::runtimeError( "Unrecognized reporter, '" + reporter + "'. Check available with --list-reporters" );
-            return ParserResult::ok( ParseResultType::Matched );
-        };
-
-        auto cli
-            = ExeName( config.processName )
-            | Help( config.showHelp )
-            | Opt( config.listTests )
-                ["-l"]["--list-tests"]
-                ( "list all/matching test cases" )
-            | Opt( config.listTags )
-                ["-t"]["--list-tags"]
-                ( "list all/matching tags" )
-            | Opt( config.showSuccessfulTests )
-                ["-s"]["--success"]
-                ( "include successful tests in output" )
-            | Opt( config.shouldDebugBreak )
-                ["-b"]["--break"]
-                ( "break into debugger on failure" )
-            | Opt( config.noThrow )
-                ["-e"]["--nothrow"]
-                ( "skip exception tests" )
-            | Opt( config.showInvisibles )
-                ["-i"]["--invisibles"]
-                ( "show invisibles (tabs, newlines)" )
-            | Opt( config.outputFilename, "filename" )
-                ["-o"]["--out"]
-                ( "output filename" )
-            | Opt( setReporter, "name" )
-                ["-r"]["--reporter"]
-                ( "reporter to use (defaults to console)" )
-            | Opt( config.name, "name" )
-                ["-n"]["--name"]
-                ( "suite name" )
-            | Opt( [&]( bool ){ config.abortAfter = 1; } )
-                ["-a"]["--abort"]
-                ( "abort at first failure" )
-            | Opt( [&]( int x ){ config.abortAfter = x; }, "no. failures" )
-                ["-x"]["--abortx"]
-                ( "abort after x failures" )
-            | Opt( setWarning, "warning name" )
-                ["-w"]["--warn"]
-                ( "enable warnings" )
-            | Opt( [&]( bool flag ) { config.showDurations = flag ? ShowDurations::Always : ShowDurations::Never; }, "yes|no" )
-                ["-d"]["--durations"]
-                ( "show test durations" )
-            | Opt( loadTestNamesFromFile, "filename" )
-                ["-f"]["--input-file"]
-                ( "load test names to run from a file" )
-            | Opt( config.filenamesAsTags )
-                ["-#"]["--filenames-as-tags"]
-                ( "adds a tag for the filename" )
-            | Opt( config.sectionsToRun, "section name" )
-                ["-c"]["--section"]
-                ( "specify section to run" )
-            | Opt( setVerbosity, "quiet|normal|high" )
-                ["-v"]["--verbosity"]
-                ( "set output verbosity" )
-            | Opt( config.listTestNamesOnly )
-                ["--list-test-names-only"]
-                ( "list all/matching test cases names only" )
-            | Opt( config.listReporters )
-                ["--list-reporters"]
-                ( "list all reporters" )
-            | Opt( setTestOrder, "decl|lex|rand" )
-                ["--order"]
-                ( "test case order (defaults to decl)" )
-            | Opt( setRngSeed, "'time'|number" )
-                ["--rng-seed"]
-                ( "set a specific seed for random numbers" )
-            | Opt( setColourUsage, "yes|no" )
-                ["--use-colour"]
-                ( "should output be colourised" )
-            | Opt( config.libIdentify )
-                ["--libidentify"]
-                ( "report name and version according to libidentify standard" )
-            | Opt( setWaitForKeypress, "start|exit|both" )
-                ["--wait-for-keypress"]
-                ( "waits for a keypress before exiting" )
-            | Opt( config.benchmarkSamples, "samples" )
-                ["--benchmark-samples"]
-                ( "number of samples to collect (default: 100)" )
-            | Opt( config.benchmarkResamples, "resamples" )
-                ["--benchmark-resamples"]
-                ( "number of resamples for the bootstrap (default: 100000)" )
-            | Opt( config.benchmarkConfidenceInterval, "confidence interval" )
-                ["--benchmark-confidence-interval"]
-                ( "confidence interval for the bootstrap (between 0 and 1, default: 0.95)" )
-            | Opt( config.benchmarkNoAnalysis )
-                ["--benchmark-no-analysis"]
-                ( "perform only measurements; do not perform any analysis" )
-			| Arg( config.testsOrTags, "test name|pattern|tags" )
-                ( "which test or tests to use" );
-
-        return cli;
-    }
-
-} // end namespace Catch
-// end catch_commandline.cpp
-// start catch_common.cpp
-
-#include <cstring>
-#include <ostream>
-
-namespace Catch {
-
-    bool SourceLineInfo::empty() const noexcept {
-        return file[0] == '\0';
-    }
-    bool SourceLineInfo::operator == ( SourceLineInfo const& other ) const noexcept {
-        return line == other.line && (file == other.file || std::strcmp(file, other.file) == 0);
-    }
-    bool SourceLineInfo::operator < ( SourceLineInfo const& other ) const noexcept {
-        // We can assume that the same file will usually have the same pointer.
-        // Thus, if the pointers are the same, there is no point in calling the strcmp
-        return line < other.line || ( line == other.line && file != other.file && (std::strcmp(file, other.file) < 0));
-    }
-
-    std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ) {
-#ifndef __GNUG__
-        os << info.file << '(' << info.line << ')';
-#else
-        os << info.file << ':' << info.line;
-#endif
-        return os;
-    }
-
-    std::string StreamEndStop::operator+() const {
-        return std::string();
-    }
-
-    NonCopyable::NonCopyable() = default;
-    NonCopyable::~NonCopyable() = default;
-
-}
-// end catch_common.cpp
-// start catch_config.cpp
-
-namespace Catch {
-
-    Config::Config( ConfigData const& data )
-    :   m_data( data ),
-        m_stream( openStream() )
-    {
-        TestSpecParser parser(ITagAliasRegistry::get());
-        if (!data.testsOrTags.empty()) {
-            m_hasTestFilters = true;
-            for( auto const& testOrTags : data.testsOrTags )
-                parser.parse( testOrTags );
-        }
-        m_testSpec = parser.testSpec();
-    }
-
-    std::string const& Config::getFilename() const {
-        return m_data.outputFilename ;
-    }
-
-    bool Config::listTests() const          { return m_data.listTests; }
-    bool Config::listTestNamesOnly() const  { return m_data.listTestNamesOnly; }
-    bool Config::listTags() const           { return m_data.listTags; }
-    bool Config::listReporters() const      { return m_data.listReporters; }
-
-    std::string Config::getProcessName() const { return m_data.processName; }
-    std::string const& Config::getReporterName() const { return m_data.reporterName; }
-
-    std::vector<std::string> const& Config::getTestsOrTags() const { return m_data.testsOrTags; }
-    std::vector<std::string> const& Config::getSectionsToRun() const { return m_data.sectionsToRun; }
-
-    TestSpec const& Config::testSpec() const { return m_testSpec; }
-    bool Config::hasTestFilters() const { return m_hasTestFilters; }
-
-    bool Config::showHelp() const { return m_data.showHelp; }
-
-    // IConfig interface
-    bool Config::allowThrows() const                   { return !m_data.noThrow; }
-    std::ostream& Config::stream() const               { return m_stream->stream(); }
-    std::string Config::name() const                   { return m_data.name.empty() ? m_data.processName : m_data.name; }
-    bool Config::includeSuccessfulResults() const      { return m_data.showSuccessfulTests; }
-    bool Config::warnAboutMissingAssertions() const    { return !!(m_data.warnings & WarnAbout::NoAssertions); }
-    bool Config::warnAboutNoTests() const              { return !!(m_data.warnings & WarnAbout::NoTests); }
-    ShowDurations::OrNot Config::showDurations() const { return m_data.showDurations; }
-    RunTests::InWhatOrder Config::runOrder() const     { return m_data.runOrder; }
-    unsigned int Config::rngSeed() const               { return m_data.rngSeed; }
-    UseColour::YesOrNo Config::useColour() const       { return m_data.useColour; }
-    bool Config::shouldDebugBreak() const              { return m_data.shouldDebugBreak; }
-    int Config::abortAfter() const                     { return m_data.abortAfter; }
-    bool Config::showInvisibles() const                { return m_data.showInvisibles; }
-    Verbosity Config::verbosity() const                { return m_data.verbosity; }
-
-    bool Config::benchmarkNoAnalysis() const           { return m_data.benchmarkNoAnalysis; }
-    int Config::benchmarkSamples() const               { return m_data.benchmarkSamples; }
-    double Config::benchmarkConfidenceInterval() const { return m_data.benchmarkConfidenceInterval; }
-    unsigned int Config::benchmarkResamples() const    { return m_data.benchmarkResamples; }
-
-    IStream const* Config::openStream() {
-        return Catch::makeStream(m_data.outputFilename);
-    }
-
-} // end namespace Catch
-// end catch_config.cpp
-// start catch_console_colour.cpp
-
-#if defined(__clang__)
-#    pragma clang diagnostic push
-#    pragma clang diagnostic ignored "-Wexit-time-destructors"
-#endif
-
-// start catch_errno_guard.h
-
-namespace Catch {
-
-    class ErrnoGuard {
-    public:
-        ErrnoGuard();
-        ~ErrnoGuard();
-    private:
-        int m_oldErrno;
-    };
-
-}
-
-// end catch_errno_guard.h
-#include <sstream>
-
-namespace Catch {
-    namespace {
-
-        struct IColourImpl {
-            virtual ~IColourImpl() = default;
-            virtual void use( Colour::Code _colourCode ) = 0;
-        };
-
-        struct NoColourImpl : IColourImpl {
-            void use( Colour::Code ) {}
-
-            static IColourImpl* instance() {
-                static NoColourImpl s_instance;
-                return &s_instance;
-            }
-        };
-
-    } // anon namespace
-} // namespace Catch
-
-#if !defined( CATCH_CONFIG_COLOUR_NONE ) && !defined( CATCH_CONFIG_COLOUR_WINDOWS ) && !defined( CATCH_CONFIG_COLOUR_ANSI )
-#   ifdef CATCH_PLATFORM_WINDOWS
-#       define CATCH_CONFIG_COLOUR_WINDOWS
-#   else
-#       define CATCH_CONFIG_COLOUR_ANSI
-#   endif
-#endif
-
-#if defined ( CATCH_CONFIG_COLOUR_WINDOWS ) /////////////////////////////////////////
-
-namespace Catch {
-namespace {
-
-    class Win32ColourImpl : public IColourImpl {
-    public:
-        Win32ColourImpl() : stdoutHandle( GetStdHandle(STD_OUTPUT_HANDLE) )
-        {
-            CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
-            GetConsoleScreenBufferInfo( stdoutHandle, &csbiInfo );
-            originalForegroundAttributes = csbiInfo.wAttributes & ~( BACKGROUND_GREEN | BACKGROUND_RED | BACKGROUND_BLUE | BACKGROUND_INTENSITY );
-            originalBackgroundAttributes = csbiInfo.wAttributes & ~( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY );
-        }
-
-        void use( Colour::Code _colourCode ) override {
-            switch( _colourCode ) {
-                case Colour::None:      return setTextAttribute( originalForegroundAttributes );
-                case Colour::White:     return setTextAttribute( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
-                case Colour::Red:       return setTextAttribute( FOREGROUND_RED );
-                case Colour::Green:     return setTextAttribute( FOREGROUND_GREEN );
-                case Colour::Blue:      return setTextAttribute( FOREGROUND_BLUE );
-                case Colour::Cyan:      return setTextAttribute( FOREGROUND_BLUE | FOREGROUND_GREEN );
-                case Colour::Yellow:    return setTextAttribute( FOREGROUND_RED | FOREGROUND_GREEN );
-                case Colour::Grey:      return setTextAttribute( 0 );
-
-                case Colour::LightGrey:     return setTextAttribute( FOREGROUND_INTENSITY );
-                case Colour::BrightRed:     return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED );
-                case Colour::BrightGreen:   return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN );
-                case Colour::BrightWhite:   return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
-                case Colour::BrightYellow:  return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN );
-
-                case Colour::Bright: CATCH_INTERNAL_ERROR( "not a colour" );
-
-                default:
-                    CATCH_ERROR( "Unknown colour requested" );
-            }
-        }
-
-    private:
-        void setTextAttribute( WORD _textAttribute ) {
-            SetConsoleTextAttribute( stdoutHandle, _textAttribute | originalBackgroundAttributes );
-        }
-        HANDLE stdoutHandle;
-        WORD originalForegroundAttributes;
-        WORD originalBackgroundAttributes;
-    };
-
-    IColourImpl* platformColourInstance() {
-        static Win32ColourImpl s_instance;
-
-        IConfigPtr config = getCurrentContext().getConfig();
-        UseColour::YesOrNo colourMode = config
-            ? config->useColour()
-            : UseColour::Auto;
-        if( colourMode == UseColour::Auto )
-            colourMode = UseColour::Yes;
-        return colourMode == UseColour::Yes
-            ? &s_instance
-            : NoColourImpl::instance();
-    }
-
-} // end anon namespace
-} // end namespace Catch
-
-#elif defined( CATCH_CONFIG_COLOUR_ANSI ) //////////////////////////////////////
-
-#include <unistd.h>
-
-namespace Catch {
-namespace {
-
-    // use POSIX/ ANSI console terminal codes
-    // Thanks to Adam Strzelecki for original contribution
-    // (http://github.com/nanoant)
-    // https://github.com/philsquared/Catch/pull/131
-    class PosixColourImpl : public IColourImpl {
-    public:
-        void use( Colour::Code _colourCode ) override {
-            switch( _colourCode ) {
-                case Colour::None:
-                case Colour::White:     return setColour( "[0m" );
-                case Colour::Red:       return setColour( "[0;31m" );
-                case Colour::Green:     return setColour( "[0;32m" );
-                case Colour::Blue:      return setColour( "[0;34m" );
-                case Colour::Cyan:      return setColour( "[0;36m" );
-                case Colour::Yellow:    return setColour( "[0;33m" );
-                case Colour::Grey:      return setColour( "[1;30m" );
-
-                case Colour::LightGrey:     return setColour( "[0;37m" );
-                case Colour::BrightRed:     return setColour( "[1;31m" );
-                case Colour::BrightGreen:   return setColour( "[1;32m" );
-                case Colour::BrightWhite:   return setColour( "[1;37m" );
-                case Colour::BrightYellow:  return setColour( "[1;33m" );
-
-                case Colour::Bright: CATCH_INTERNAL_ERROR( "not a colour" );
-                default: CATCH_INTERNAL_ERROR( "Unknown colour requested" );
-            }
-        }
-        static IColourImpl* instance() {
-            static PosixColourImpl s_instance;
-            return &s_instance;
-        }
-
-    private:
-        void setColour( const char* _escapeCode ) {
-            getCurrentContext().getConfig()->stream()
-                << '\033' << _escapeCode;
-        }
-    };
-
-    bool useColourOnPlatform() {
-        return
-#ifdef CATCH_PLATFORM_MAC
-            !isDebuggerActive() &&
-#endif
-#if !(defined(__DJGPP__) && defined(__STRICT_ANSI__))
-            isatty(STDOUT_FILENO)
-#else
-            false
-#endif
-            ;
-    }
-    IColourImpl* platformColourInstance() {
-        ErrnoGuard guard;
-        IConfigPtr config = getCurrentContext().getConfig();
-        UseColour::YesOrNo colourMode = config
-            ? config->useColour()
-            : UseColour::Auto;
-        if( colourMode == UseColour::Auto )
-            colourMode = useColourOnPlatform()
-                ? UseColour::Yes
-                : UseColour::No;
-        return colourMode == UseColour::Yes
-            ? PosixColourImpl::instance()
-            : NoColourImpl::instance();
-    }
-
-} // end anon namespace
-} // end namespace Catch
-
-#else  // not Windows or ANSI ///////////////////////////////////////////////
-
-namespace Catch {
-
-    static IColourImpl* platformColourInstance() { return NoColourImpl::instance(); }
-
-} // end namespace Catch
-
-#endif // Windows/ ANSI/ None
-
-namespace Catch {
-
-    Colour::Colour( Code _colourCode ) { use( _colourCode ); }
-    Colour::Colour( Colour&& rhs ) noexcept {
-        m_moved = rhs.m_moved;
-        rhs.m_moved = true;
-    }
-    Colour& Colour::operator=( Colour&& rhs ) noexcept {
-        m_moved = rhs.m_moved;
-        rhs.m_moved  = true;
-        return *this;
-    }
-
-    Colour::~Colour(){ if( !m_moved ) use( None ); }
-
-    void Colour::use( Code _colourCode ) {
-        static IColourImpl* impl = platformColourInstance();
-        // Strictly speaking, this cannot possibly happen.
-        // However, under some conditions it does happen (see #1626),
-        // and this change is small enough that we can let practicality
-        // triumph over purity in this case.
-        if (impl != NULL) {
-            impl->use( _colourCode );
-        }
-    }
-
-    std::ostream& operator << ( std::ostream& os, Colour const& ) {
-        return os;
-    }
-
-} // end namespace Catch
-
-#if defined(__clang__)
-#    pragma clang diagnostic pop
-#endif
-
-// end catch_console_colour.cpp
-// start catch_context.cpp
-
-namespace Catch {
-
-    class Context : public IMutableContext, NonCopyable {
-
-    public: // IContext
-        IResultCapture* getResultCapture() override {
-            return m_resultCapture;
-        }
-        IRunner* getRunner() override {
-            return m_runner;
-        }
-
-        IConfigPtr const& getConfig() const override {
-            return m_config;
-        }
-
-        ~Context() override;
-
-    public: // IMutableContext
-        void setResultCapture( IResultCapture* resultCapture ) override {
-            m_resultCapture = resultCapture;
-        }
-        void setRunner( IRunner* runner ) override {
-            m_runner = runner;
-        }
-        void setConfig( IConfigPtr const& config ) override {
-            m_config = config;
-        }
-
-        friend IMutableContext& getCurrentMutableContext();
-
-    private:
-        IConfigPtr m_config;
-        IRunner* m_runner = nullptr;
-        IResultCapture* m_resultCapture = nullptr;
-    };
-
-    IMutableContext *IMutableContext::currentContext = nullptr;
-
-    void IMutableContext::createContext()
-    {
-        currentContext = new Context();
-    }
-
-    void cleanUpContext() {
-        delete IMutableContext::currentContext;
-        IMutableContext::currentContext = nullptr;
-    }
-    IContext::~IContext() = default;
-    IMutableContext::~IMutableContext() = default;
-    Context::~Context() = default;
-}
-// end catch_context.cpp
-// start catch_debug_console.cpp
-
-// start catch_debug_console.h
-
-#include <string>
-
-namespace Catch {
-    void writeToDebugConsole( std::string const& text );
-}
-
-// end catch_debug_console.h
-#ifdef CATCH_PLATFORM_WINDOWS
-
-    namespace Catch {
-        void writeToDebugConsole( std::string const& text ) {
-            ::OutputDebugStringA( text.c_str() );
-        }
-    }
-
-#else
-
-    namespace Catch {
-        void writeToDebugConsole( std::string const& text ) {
-            // !TBD: Need a version for Mac/ XCode and other IDEs
-            Catch::cout() << text;
-        }
-    }
-
-#endif // Platform
-// end catch_debug_console.cpp
-// start catch_debugger.cpp
-
-#ifdef CATCH_PLATFORM_MAC
-
-#  include <assert.h>
-#  include <stdbool.h>
-#  include <sys/types.h>
-#  include <unistd.h>
-#  include <cstddef>
-#  include <ostream>
-
-#ifdef __apple_build_version__
-    // These headers will only compile with AppleClang (XCode)
-    // For other compilers (Clang, GCC, ... ) we need to exclude them
-#  include <sys/sysctl.h>
-#endif
-
-    namespace Catch {
-        #ifdef __apple_build_version__
-        // The following function is taken directly from the following technical note:
-        // https://developer.apple.com/library/archive/qa/qa1361/_index.html
-
-        // Returns true if the current process is being debugged (either
-        // running under the debugger or has a debugger attached post facto).
-        bool isDebuggerActive(){
-            int                 mib[4];
-            struct kinfo_proc   info;
-            std::size_t         size;
-
-            // Initialize the flags so that, if sysctl fails for some bizarre
-            // reason, we get a predictable result.
-
-            info.kp_proc.p_flag = 0;
-
-            // Initialize mib, which tells sysctl the info we want, in this case
-            // we're looking for information about a specific process ID.
-
-            mib[0] = CTL_KERN;
-            mib[1] = KERN_PROC;
-            mib[2] = KERN_PROC_PID;
-            mib[3] = getpid();
-
-            // Call sysctl.
-
-            size = sizeof(info);
-            if( sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, nullptr, 0) != 0 ) {
-                Catch::cerr() << "\n** Call to sysctl failed - unable to determine if debugger is active **\n" << std::endl;
-                return false;
-            }
-
-            // We're being debugged if the P_TRACED flag is set.
-
-            return ( (info.kp_proc.p_flag & P_TRACED) != 0 );
-        }
-        #else
-        bool isDebuggerActive() {
-            // We need to find another way to determine this for non-appleclang compilers on macOS
-            return false;
-        }
-        #endif
-    } // namespace Catch
-
-#elif defined(CATCH_PLATFORM_LINUX)
-    #include <fstream>
-    #include <string>
-
-    namespace Catch{
-        // The standard POSIX way of detecting a debugger is to attempt to
-        // ptrace() the process, but this needs to be done from a child and not
-        // this process itself to still allow attaching to this process later
-        // if wanted, so is rather heavy. Under Linux we have the PID of the
-        // "debugger" (which doesn't need to be gdb, of course, it could also
-        // be strace, for example) in /proc/$PID/status, so just get it from
-        // there instead.
-        bool isDebuggerActive(){
-            // Libstdc++ has a bug, where std::ifstream sets errno to 0
-            // This way our users can properly assert over errno values
-            ErrnoGuard guard;
-            std::ifstream in("/proc/self/status");
-            for( std::string line; std::getline(in, line); ) {
-                static const int PREFIX_LEN = 11;
-                if( line.compare(0, PREFIX_LEN, "TracerPid:\t") == 0 ) {
-                    // We're traced if the PID is not 0 and no other PID starts
-                    // with 0 digit, so it's enough to check for just a single
-                    // character.
-                    return line.length() > PREFIX_LEN && line[PREFIX_LEN] != '0';
-                }
-            }
-
-            return false;
-        }
-    } // namespace Catch
-#elif defined(_MSC_VER)
-    extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
-    namespace Catch {
-        bool isDebuggerActive() {
-            return IsDebuggerPresent() != 0;
-        }
-    }
-#elif defined(__MINGW32__)
-    extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
-    namespace Catch {
-        bool isDebuggerActive() {
-            return IsDebuggerPresent() != 0;
-        }
-    }
-#else
-    namespace Catch {
-       bool isDebuggerActive() { return false; }
-    }
-#endif // Platform
-// end catch_debugger.cpp
-// start catch_decomposer.cpp
-
-namespace Catch {
-
-    ITransientExpression::~ITransientExpression() = default;
-
-    void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs ) {
-        if( lhs.size() + rhs.size() < 40 &&
-                lhs.find('\n') == std::string::npos &&
-                rhs.find('\n') == std::string::npos )
-            os << lhs << " " << op << " " << rhs;
-        else
-            os << lhs << "\n" << op << "\n" << rhs;
-    }
-}
-// end catch_decomposer.cpp
-// start catch_enforce.cpp
-
-#include <stdexcept>
-
-namespace Catch {
-#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS_CUSTOM_HANDLER)
-    [[noreturn]]
-    void throw_exception(std::exception const& e) {
-        Catch::cerr() << "Catch will terminate because it needed to throw an exception.\n"
-                      << "The message was: " << e.what() << '\n';
-        std::terminate();
-    }
-#endif
-
-    [[noreturn]]
-    void throw_logic_error(std::string const& msg) {
-        throw_exception(std::logic_error(msg));
-    }
-
-    [[noreturn]]
-    void throw_domain_error(std::string const& msg) {
-        throw_exception(std::domain_error(msg));
-    }
-
-    [[noreturn]]
-    void throw_runtime_error(std::string const& msg) {
-        throw_exception(std::runtime_error(msg));
-    }
-
-} // namespace Catch;
-// end catch_enforce.cpp
-// start catch_enum_values_registry.cpp
-// start catch_enum_values_registry.h
-
-#include <vector>
-#include <memory>
-
-namespace Catch {
-
-    namespace Detail {
-
-        std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values );
-
-        class EnumValuesRegistry : public IMutableEnumValuesRegistry {
-
-            std::vector<std::unique_ptr<EnumInfo>> m_enumInfos;
-
-            EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::vector<int> const& values) override;
-        };
-
-        std::vector<std::string> parseEnums( StringRef enums );
-
-    } // Detail
-
-} // Catch
-
-// end catch_enum_values_registry.h
-
-#include <map>
-#include <cassert>
-
-namespace Catch {
-
-    IMutableEnumValuesRegistry::~IMutableEnumValuesRegistry() {}
-
-    namespace Detail {
-
-        std::vector<std::string> parseEnums( StringRef enums ) {
-            auto enumValues = splitStringRef( enums, ',' );
-            std::vector<std::string> parsed;
-            parsed.reserve( enumValues.size() );
-            for( auto const& enumValue : enumValues ) {
-                auto identifiers = splitStringRef( enumValue, ':' );
-                parsed.push_back( Catch::trim( identifiers.back() ) );
-            }
-            return parsed;
-        }
-
-        EnumInfo::~EnumInfo() {}
-
-        StringRef EnumInfo::lookup( int value ) const {
-            for( auto const& valueToName : m_values ) {
-                if( valueToName.first == value )
-                    return valueToName.second;
-            }
-            return "{** unexpected enum value **}";
-        }
-
-        std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
-            std::unique_ptr<EnumInfo> enumInfo( new EnumInfo );
-            enumInfo->m_name = enumName;
-            enumInfo->m_values.reserve( values.size() );
-
-            const auto valueNames = Catch::Detail::parseEnums( allValueNames );
-            assert( valueNames.size() == values.size() );
-            std::size_t i = 0;
-            for( auto value : values )
-                enumInfo->m_values.push_back({ value, valueNames[i++] });
-
-            return enumInfo;
-        }
-
-        EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
-            auto enumInfo = makeEnumInfo( enumName, allValueNames, values );
-            EnumInfo* raw = enumInfo.get();
-            m_enumInfos.push_back( std::move( enumInfo ) );
-            return *raw;
-        }
-
-    } // Detail
-} // Catch
-
-// end catch_enum_values_registry.cpp
-// start catch_errno_guard.cpp
-
-#include <cerrno>
-
-namespace Catch {
-        ErrnoGuard::ErrnoGuard():m_oldErrno(errno){}
-        ErrnoGuard::~ErrnoGuard() { errno = m_oldErrno; }
-}
-// end catch_errno_guard.cpp
-// start catch_exception_translator_registry.cpp
-
-// start catch_exception_translator_registry.h
-
-#include <vector>
-#include <string>
-#include <memory>
-
-namespace Catch {
-
-    class ExceptionTranslatorRegistry : public IExceptionTranslatorRegistry {
-    public:
-        ~ExceptionTranslatorRegistry();
-        virtual void registerTranslator( const IExceptionTranslator* translator );
-        std::string translateActiveException() const override;
-        std::string tryTranslators() const;
-
-    private:
-        std::vector<std::unique_ptr<IExceptionTranslator const>> m_translators;
-    };
-}
-
-// end catch_exception_translator_registry.h
-#ifdef __OBJC__
-#import "Foundation/Foundation.h"
-#endif
-
-namespace Catch {
-
-    ExceptionTranslatorRegistry::~ExceptionTranslatorRegistry() {
-    }
-
-    void ExceptionTranslatorRegistry::registerTranslator( const IExceptionTranslator* translator ) {
-        m_translators.push_back( std::unique_ptr<const IExceptionTranslator>( translator ) );
-    }
-
-#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-    std::string ExceptionTranslatorRegistry::translateActiveException() const {
-        try {
-#ifdef __OBJC__
-            // In Objective-C try objective-c exceptions first
-            @try {
-                return tryTranslators();
-            }
-            @catch (NSException *exception) {
-                return Catch::Detail::stringify( [exception description] );
-            }
-#else
-            // Compiling a mixed mode project with MSVC means that CLR
-            // exceptions will be caught in (...) as well. However, these
-            // do not fill-in std::current_exception and thus lead to crash
-            // when attempting rethrow.
-            // /EHa switch also causes structured exceptions to be caught
-            // here, but they fill-in current_exception properly, so
-            // at worst the output should be a little weird, instead of
-            // causing a crash.
-            if (std::current_exception() == nullptr) {
-                return "Non C++ exception. Possibly a CLR exception.";
-            }
-            return tryTranslators();
-#endif
-        }
-        catch( TestFailureException& ) {
-            std::rethrow_exception(std::current_exception());
-        }
-        catch( std::exception& ex ) {
-            return ex.what();
-        }
-        catch( std::string& msg ) {
-            return msg;
-        }
-        catch( const char* msg ) {
-            return msg;
-        }
-        catch(...) {
-            return "Unknown exception";
-        }
-    }
-
-    std::string ExceptionTranslatorRegistry::tryTranslators() const {
-        if (m_translators.empty()) {
-            std::rethrow_exception(std::current_exception());
-        } else {
-            return m_translators[0]->translate(m_translators.begin() + 1, m_translators.end());
-        }
-    }
-
-#else // ^^ Exceptions are enabled // Exceptions are disabled vv
-    std::string ExceptionTranslatorRegistry::translateActiveException() const {
-        CATCH_INTERNAL_ERROR("Attempted to translate active exception under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
-    }
-
-    std::string ExceptionTranslatorRegistry::tryTranslators() const {
-        CATCH_INTERNAL_ERROR("Attempted to use exception translators under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
-    }
-#endif
-
-}
-// end catch_exception_translator_registry.cpp
-// start catch_fatal_condition.cpp
-
-#if defined(__GNUC__)
-#    pragma GCC diagnostic push
-#    pragma GCC diagnostic ignored "-Wmissing-field-initializers"
-#endif
-
-#if defined( CATCH_CONFIG_WINDOWS_SEH ) || defined( CATCH_CONFIG_POSIX_SIGNALS )
-
-namespace {
-    // Report the error condition
-    void reportFatal( char const * const message ) {
-        Catch::getCurrentContext().getResultCapture()->handleFatalErrorCondition( message );
-    }
-}
-
-#endif // signals/SEH handling
-
-#if defined( CATCH_CONFIG_WINDOWS_SEH )
-
-namespace Catch {
-    struct SignalDefs { DWORD id; const char* name; };
-
-    // There is no 1-1 mapping between signals and windows exceptions.
-    // Windows can easily distinguish between SO and SigSegV,
-    // but SigInt, SigTerm, etc are handled differently.
-    static SignalDefs signalDefs[] = {
-        { static_cast<DWORD>(EXCEPTION_ILLEGAL_INSTRUCTION),  "SIGILL - Illegal instruction signal" },
-        { static_cast<DWORD>(EXCEPTION_STACK_OVERFLOW), "SIGSEGV - Stack overflow" },
-        { static_cast<DWORD>(EXCEPTION_ACCESS_VIOLATION), "SIGSEGV - Segmentation violation signal" },
-        { static_cast<DWORD>(EXCEPTION_INT_DIVIDE_BY_ZERO), "Divide by zero error" },
-    };
-
-    LONG CALLBACK FatalConditionHandler::handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo) {
-        for (auto const& def : signalDefs) {
-            if (ExceptionInfo->ExceptionRecord->ExceptionCode == def.id) {
-                reportFatal(def.name);
-            }
-        }
-        // If its not an exception we care about, pass it along.
-        // This stops us from eating debugger breaks etc.
-        return EXCEPTION_CONTINUE_SEARCH;
-    }
-
-    FatalConditionHandler::FatalConditionHandler() {
-        isSet = true;
-        // 32k seems enough for Catch to handle stack overflow,
-        // but the value was found experimentally, so there is no strong guarantee
-        guaranteeSize = 32 * 1024;
-        exceptionHandlerHandle = nullptr;
-        // Register as first handler in current chain
-        exceptionHandlerHandle = AddVectoredExceptionHandler(1, handleVectoredException);
-        // Pass in guarantee size to be filled
-        SetThreadStackGuarantee(&guaranteeSize);
-    }
-
-    void FatalConditionHandler::reset() {
-        if (isSet) {
-            RemoveVectoredExceptionHandler(exceptionHandlerHandle);
-            SetThreadStackGuarantee(&guaranteeSize);
-            exceptionHandlerHandle = nullptr;
-            isSet = false;
-        }
-    }
-
-    FatalConditionHandler::~FatalConditionHandler() {
-        reset();
-    }
-
-bool FatalConditionHandler::isSet = false;
-ULONG FatalConditionHandler::guaranteeSize = 0;
-PVOID FatalConditionHandler::exceptionHandlerHandle = nullptr;
-
-} // namespace Catch
-
-#elif defined( CATCH_CONFIG_POSIX_SIGNALS )
-
-namespace Catch {
-
-    struct SignalDefs {
-        int id;
-        const char* name;
-    };
-
-    // 32kb for the alternate stack seems to be sufficient. However, this value
-    // is experimentally determined, so that's not guaranteed.
-    constexpr static std::size_t sigStackSize = 32768 >= MINSIGSTKSZ ? 32768 : MINSIGSTKSZ;
-
-    static SignalDefs signalDefs[] = {
-        { SIGINT,  "SIGINT - Terminal interrupt signal" },
-        { SIGILL,  "SIGILL - Illegal instruction signal" },
-        { SIGFPE,  "SIGFPE - Floating point error signal" },
-        { SIGSEGV, "SIGSEGV - Segmentation violation signal" },
-        { SIGTERM, "SIGTERM - Termination request signal" },
-        { SIGABRT, "SIGABRT - Abort (abnormal termination) signal" }
-    };
-
-    void FatalConditionHandler::handleSignal( int sig ) {
-        char const * name = "<unknown signal>";
-        for (auto const& def : signalDefs) {
-            if (sig == def.id) {
-                name = def.name;
-                break;
-            }
-        }
-        reset();
-        reportFatal(name);
-        raise( sig );
-    }
-
-    FatalConditionHandler::FatalConditionHandler() {
-        isSet = true;
-        stack_t sigStack;
-        sigStack.ss_sp = altStackMem;
-        sigStack.ss_size = sigStackSize;
-        sigStack.ss_flags = 0;
-        sigaltstack(&sigStack, &oldSigStack);
-        struct sigaction sa = { };
-
-        sa.sa_handler = handleSignal;
-        sa.sa_flags = SA_ONSTACK;
-        for (std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i) {
-            sigaction(signalDefs[i].id, &sa, &oldSigActions[i]);
-        }
-    }
-
-    FatalConditionHandler::~FatalConditionHandler() {
-        reset();
-    }
-
-    void FatalConditionHandler::reset() {
-        if( isSet ) {
-            // Set signals back to previous values -- hopefully nobody overwrote them in the meantime
-            for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i ) {
-                sigaction(signalDefs[i].id, &oldSigActions[i], nullptr);
-            }
-            // Return the old stack
-            sigaltstack(&oldSigStack, nullptr);
-            isSet = false;
-        }
-    }
-
-    bool FatalConditionHandler::isSet = false;
-    struct sigaction FatalConditionHandler::oldSigActions[sizeof(signalDefs)/sizeof(SignalDefs)] = {};
-    stack_t FatalConditionHandler::oldSigStack = {};
-    char FatalConditionHandler::altStackMem[sigStackSize] = {};
-
-} // namespace Catch
-
-#else
-
-namespace Catch {
-    void FatalConditionHandler::reset() {}
-}
-
-#endif // signals/SEH handling
-
-#if defined(__GNUC__)
-#    pragma GCC diagnostic pop
-#endif
-// end catch_fatal_condition.cpp
-// start catch_generators.cpp
-
-// start catch_random_number_generator.h
-
-#include <algorithm>
-#include <random>
-
-namespace Catch {
-
-    struct IConfig;
-
-    std::mt19937& rng();
-    void seedRng( IConfig const& config );
-    unsigned int rngSeed();
-
-}
-
-// end catch_random_number_generator.h
-#include <limits>
-#include <set>
-
-namespace Catch {
-
-IGeneratorTracker::~IGeneratorTracker() {}
-
-const char* GeneratorException::what() const noexcept {
-    return m_msg;
-}
-
-namespace Generators {
-
-    GeneratorUntypedBase::~GeneratorUntypedBase() {}
-
-    auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& {
-        return getResultCapture().acquireGeneratorTracker( lineInfo );
-    }
-
-} // namespace Generators
-} // namespace Catch
-// end catch_generators.cpp
-// start catch_interfaces_capture.cpp
-
-namespace Catch {
-    IResultCapture::~IResultCapture() = default;
-}
-// end catch_interfaces_capture.cpp
-// start catch_interfaces_config.cpp
-
-namespace Catch {
-    IConfig::~IConfig() = default;
-}
-// end catch_interfaces_config.cpp
-// start catch_interfaces_exception.cpp
-
-namespace Catch {
-    IExceptionTranslator::~IExceptionTranslator() = default;
-    IExceptionTranslatorRegistry::~IExceptionTranslatorRegistry() = default;
-}
-// end catch_interfaces_exception.cpp
-// start catch_interfaces_registry_hub.cpp
-
-namespace Catch {
-    IRegistryHub::~IRegistryHub() = default;
-    IMutableRegistryHub::~IMutableRegistryHub() = default;
-}
-// end catch_interfaces_registry_hub.cpp
-// start catch_interfaces_reporter.cpp
-
-// start catch_reporter_listening.h
-
-namespace Catch {
-
-    class ListeningReporter : public IStreamingReporter {
-        using Reporters = std::vector<IStreamingReporterPtr>;
-        Reporters m_listeners;
-        IStreamingReporterPtr m_reporter = nullptr;
-        ReporterPreferences m_preferences;
-
-    public:
-        ListeningReporter();
-
-        void addListener( IStreamingReporterPtr&& listener );
-        void addReporter( IStreamingReporterPtr&& reporter );
-
-    public: // IStreamingReporter
-
-        ReporterPreferences getPreferences() const override;
-
-        void noMatchingTestCases( std::string const& spec ) override;
-
-        static std::set<Verbosity> getSupportedVerbosities();
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-        void benchmarkPreparing(std::string const& name) override;
-        void benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) override;
-        void benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) override;
-        void benchmarkFailed(std::string const&) override;
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-        void testRunStarting( TestRunInfo const& testRunInfo ) override;
-        void testGroupStarting( GroupInfo const& groupInfo ) override;
-        void testCaseStarting( TestCaseInfo const& testInfo ) override;
-        void sectionStarting( SectionInfo const& sectionInfo ) override;
-        void assertionStarting( AssertionInfo const& assertionInfo ) override;
-
-        // The return value indicates if the messages buffer should be cleared:
-        bool assertionEnded( AssertionStats const& assertionStats ) override;
-        void sectionEnded( SectionStats const& sectionStats ) override;
-        void testCaseEnded( TestCaseStats const& testCaseStats ) override;
-        void testGroupEnded( TestGroupStats const& testGroupStats ) override;
-        void testRunEnded( TestRunStats const& testRunStats ) override;
-
-        void skipTest( TestCaseInfo const& testInfo ) override;
-        bool isMulti() const override;
-
-    };
-
-} // end namespace Catch
-
-// end catch_reporter_listening.h
-namespace Catch {
-
-    ReporterConfig::ReporterConfig( IConfigPtr const& _fullConfig )
-    :   m_stream( &_fullConfig->stream() ), m_fullConfig( _fullConfig ) {}
-
-    ReporterConfig::ReporterConfig( IConfigPtr const& _fullConfig, std::ostream& _stream )
-    :   m_stream( &_stream ), m_fullConfig( _fullConfig ) {}
-
-    std::ostream& ReporterConfig::stream() const { return *m_stream; }
-    IConfigPtr ReporterConfig::fullConfig() const { return m_fullConfig; }
-
-    TestRunInfo::TestRunInfo( std::string const& _name ) : name( _name ) {}
-
-    GroupInfo::GroupInfo(  std::string const& _name,
-                           std::size_t _groupIndex,
-                           std::size_t _groupsCount )
-    :   name( _name ),
-        groupIndex( _groupIndex ),
-        groupsCounts( _groupsCount )
-    {}
-
-     AssertionStats::AssertionStats( AssertionResult const& _assertionResult,
-                                     std::vector<MessageInfo> const& _infoMessages,
-                                     Totals const& _totals )
-    :   assertionResult( _assertionResult ),
-        infoMessages( _infoMessages ),
-        totals( _totals )
-    {
-        assertionResult.m_resultData.lazyExpression.m_transientExpression = _assertionResult.m_resultData.lazyExpression.m_transientExpression;
-
-        if( assertionResult.hasMessage() ) {
-            // Copy message into messages list.
-            // !TBD This should have been done earlier, somewhere
-            MessageBuilder builder( assertionResult.getTestMacroName(), assertionResult.getSourceInfo(), assertionResult.getResultType() );
-            builder << assertionResult.getMessage();
-            builder.m_info.message = builder.m_stream.str();
-
-            infoMessages.push_back( builder.m_info );
-        }
-    }
-
-     AssertionStats::~AssertionStats() = default;
-
-    SectionStats::SectionStats(  SectionInfo const& _sectionInfo,
-                                 Counts const& _assertions,
-                                 double _durationInSeconds,
-                                 bool _missingAssertions )
-    :   sectionInfo( _sectionInfo ),
-        assertions( _assertions ),
-        durationInSeconds( _durationInSeconds ),
-        missingAssertions( _missingAssertions )
-    {}
-
-    SectionStats::~SectionStats() = default;
-
-    TestCaseStats::TestCaseStats(  TestCaseInfo const& _testInfo,
-                                   Totals const& _totals,
-                                   std::string const& _stdOut,
-                                   std::string const& _stdErr,
-                                   bool _aborting )
-    : testInfo( _testInfo ),
-        totals( _totals ),
-        stdOut( _stdOut ),
-        stdErr( _stdErr ),
-        aborting( _aborting )
-    {}
-
-    TestCaseStats::~TestCaseStats() = default;
-
-    TestGroupStats::TestGroupStats( GroupInfo const& _groupInfo,
-                                    Totals const& _totals,
-                                    bool _aborting )
-    :   groupInfo( _groupInfo ),
-        totals( _totals ),
-        aborting( _aborting )
-    {}
-
-    TestGroupStats::TestGroupStats( GroupInfo const& _groupInfo )
-    :   groupInfo( _groupInfo ),
-        aborting( false )
-    {}
-
-    TestGroupStats::~TestGroupStats() = default;
-
-    TestRunStats::TestRunStats(   TestRunInfo const& _runInfo,
-                    Totals const& _totals,
-                    bool _aborting )
-    :   runInfo( _runInfo ),
-        totals( _totals ),
-        aborting( _aborting )
-    {}
-
-    TestRunStats::~TestRunStats() = default;
-
-    void IStreamingReporter::fatalErrorEncountered( StringRef ) {}
-    bool IStreamingReporter::isMulti() const { return false; }
-
-    IReporterFactory::~IReporterFactory() = default;
-    IReporterRegistry::~IReporterRegistry() = default;
-
-} // end namespace Catch
-// end catch_interfaces_reporter.cpp
-// start catch_interfaces_runner.cpp
-
-namespace Catch {
-    IRunner::~IRunner() = default;
-}
-// end catch_interfaces_runner.cpp
-// start catch_interfaces_testcase.cpp
-
-namespace Catch {
-    ITestInvoker::~ITestInvoker() = default;
-    ITestCaseRegistry::~ITestCaseRegistry() = default;
-}
-// end catch_interfaces_testcase.cpp
-// start catch_leak_detector.cpp
-
-#ifdef CATCH_CONFIG_WINDOWS_CRTDBG
-#include <crtdbg.h>
-
-namespace Catch {
-
-    LeakDetector::LeakDetector() {
-        int flag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
-        flag |= _CRTDBG_LEAK_CHECK_DF;
-        flag |= _CRTDBG_ALLOC_MEM_DF;
-        _CrtSetDbgFlag(flag);
-        _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
-        _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
-        // Change this to leaking allocation's number to break there
-        _CrtSetBreakAlloc(-1);
-    }
-}
-
-#else
-
-    Catch::LeakDetector::LeakDetector() {}
-
-#endif
-
-Catch::LeakDetector::~LeakDetector() {
-    Catch::cleanUp();
-}
-// end catch_leak_detector.cpp
-// start catch_list.cpp
-
-// start catch_list.h
-
-#include <set>
-
-namespace Catch {
-
-    std::size_t listTests( Config const& config );
-
-    std::size_t listTestsNamesOnly( Config const& config );
-
-    struct TagInfo {
-        void add( std::string const& spelling );
-        std::string all() const;
-
-        std::set<std::string> spellings;
-        std::size_t count = 0;
-    };
-
-    std::size_t listTags( Config const& config );
-
-    std::size_t listReporters();
-
-    Option<std::size_t> list( std::shared_ptr<Config> const& config );
-
-} // end namespace Catch
-
-// end catch_list.h
-// start catch_text.h
-
-namespace Catch {
-    using namespace clara::TextFlow;
-}
-
-// end catch_text.h
-#include <limits>
-#include <algorithm>
-#include <iomanip>
-
-namespace Catch {
-
-    std::size_t listTests( Config const& config ) {
-        TestSpec testSpec = config.testSpec();
-        if( config.hasTestFilters() )
-            Catch::cout() << "Matching test cases:\n";
-        else {
-            Catch::cout() << "All available test cases:\n";
-        }
-
-        auto matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
-        for( auto const& testCaseInfo : matchedTestCases ) {
-            Colour::Code colour = testCaseInfo.isHidden()
-                ? Colour::SecondaryText
-                : Colour::None;
-            Colour colourGuard( colour );
-
-            Catch::cout() << Column( testCaseInfo.name ).initialIndent( 2 ).indent( 4 ) << "\n";
-            if( config.verbosity() >= Verbosity::High ) {
-                Catch::cout() << Column( Catch::Detail::stringify( testCaseInfo.lineInfo ) ).indent(4) << std::endl;
-                std::string description = testCaseInfo.description;
-                if( description.empty() )
-                    description = "(NO DESCRIPTION)";
-                Catch::cout() << Column( description ).indent(4) << std::endl;
-            }
-            if( !testCaseInfo.tags.empty() )
-                Catch::cout() << Column( testCaseInfo.tagsAsString() ).indent( 6 ) << "\n";
-        }
-
-        if( !config.hasTestFilters() )
-            Catch::cout() << pluralise( matchedTestCases.size(), "test case" ) << '\n' << std::endl;
-        else
-            Catch::cout() << pluralise( matchedTestCases.size(), "matching test case" ) << '\n' << std::endl;
-        return matchedTestCases.size();
-    }
-
-    std::size_t listTestsNamesOnly( Config const& config ) {
-        TestSpec testSpec = config.testSpec();
-        std::size_t matchedTests = 0;
-        std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
-        for( auto const& testCaseInfo : matchedTestCases ) {
-            matchedTests++;
-            if( startsWith( testCaseInfo.name, '#' ) )
-               Catch::cout() << '"' << testCaseInfo.name << '"';
-            else
-               Catch::cout() << testCaseInfo.name;
-            if ( config.verbosity() >= Verbosity::High )
-                Catch::cout() << "\t@" << testCaseInfo.lineInfo;
-            Catch::cout() << std::endl;
-        }
-        return matchedTests;
-    }
-
-    void TagInfo::add( std::string const& spelling ) {
-        ++count;
-        spellings.insert( spelling );
-    }
-
-    std::string TagInfo::all() const {
-        std::string out;
-        for( auto const& spelling : spellings )
-            out += "[" + spelling + "]";
-        return out;
-    }
-
-    std::size_t listTags( Config const& config ) {
-        TestSpec testSpec = config.testSpec();
-        if( config.hasTestFilters() )
-            Catch::cout() << "Tags for matching test cases:\n";
-        else {
-            Catch::cout() << "All available tags:\n";
-        }
-
-        std::map<std::string, TagInfo> tagCounts;
-
-        std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
-        for( auto const& testCase : matchedTestCases ) {
-            for( auto const& tagName : testCase.getTestCaseInfo().tags ) {
-                std::string lcaseTagName = toLower( tagName );
-                auto countIt = tagCounts.find( lcaseTagName );
-                if( countIt == tagCounts.end() )
-                    countIt = tagCounts.insert( std::make_pair( lcaseTagName, TagInfo() ) ).first;
-                countIt->second.add( tagName );
-            }
-        }
-
-        for( auto const& tagCount : tagCounts ) {
-            ReusableStringStream rss;
-            rss << "  " << std::setw(2) << tagCount.second.count << "  ";
-            auto str = rss.str();
-            auto wrapper = Column( tagCount.second.all() )
-                                                    .initialIndent( 0 )
-                                                    .indent( str.size() )
-                                                    .width( CATCH_CONFIG_CONSOLE_WIDTH-10 );
-            Catch::cout() << str << wrapper << '\n';
-        }
-        Catch::cout() << pluralise( tagCounts.size(), "tag" ) << '\n' << std::endl;
-        return tagCounts.size();
-    }
-
-    std::size_t listReporters() {
-        Catch::cout() << "Available reporters:\n";
-        IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories();
-        std::size_t maxNameLen = 0;
-        for( auto const& factoryKvp : factories )
-            maxNameLen = (std::max)( maxNameLen, factoryKvp.first.size() );
-
-        for( auto const& factoryKvp : factories ) {
-            Catch::cout()
-                    << Column( factoryKvp.first + ":" )
-                            .indent(2)
-                            .width( 5+maxNameLen )
-                    +  Column( factoryKvp.second->getDescription() )
-                            .initialIndent(0)
-                            .indent(2)
-                            .width( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen-8 )
-                    << "\n";
-        }
-        Catch::cout() << std::endl;
-        return factories.size();
-    }
-
-    Option<std::size_t> list( std::shared_ptr<Config> const& config ) {
-        Option<std::size_t> listedCount;
-        getCurrentMutableContext().setConfig( config );
-        if( config->listTests() )
-            listedCount = listedCount.valueOr(0) + listTests( *config );
-        if( config->listTestNamesOnly() )
-            listedCount = listedCount.valueOr(0) + listTestsNamesOnly( *config );
-        if( config->listTags() )
-            listedCount = listedCount.valueOr(0) + listTags( *config );
-        if( config->listReporters() )
-            listedCount = listedCount.valueOr(0) + listReporters();
-        return listedCount;
-    }
-
-} // end namespace Catch
-// end catch_list.cpp
-// start catch_matchers.cpp
-
-namespace Catch {
-namespace Matchers {
-    namespace Impl {
-
-        std::string MatcherUntypedBase::toString() const {
-            if( m_cachedToString.empty() )
-                m_cachedToString = describe();
-            return m_cachedToString;
-        }
-
-        MatcherUntypedBase::~MatcherUntypedBase() = default;
-
-    } // namespace Impl
-} // namespace Matchers
-
-using namespace Matchers;
-using Matchers::Impl::MatcherBase;
-
-} // namespace Catch
-// end catch_matchers.cpp
-// start catch_matchers_floating.cpp
-
-// start catch_polyfills.hpp
-
-namespace Catch {
-    bool isnan(float f);
-    bool isnan(double d);
-}
-
-// end catch_polyfills.hpp
-// start catch_to_string.hpp
-
-#include <string>
-
-namespace Catch {
-    template <typename T>
-    std::string to_string(T const& t) {
-#if defined(CATCH_CONFIG_CPP11_TO_STRING)
-        return std::to_string(t);
-#else
-        ReusableStringStream rss;
-        rss << t;
-        return rss.str();
-#endif
-    }
-} // end namespace Catch
-
-// end catch_to_string.hpp
-#include <cstdlib>
-#include <cstdint>
-#include <cstring>
-#include <sstream>
-#include <iomanip>
-#include <limits>
-
-namespace Catch {
-namespace Matchers {
-namespace Floating {
-enum class FloatingPointKind : uint8_t {
-    Float,
-    Double
-};
-}
-}
-}
-
-namespace {
-
-template <typename T>
-struct Converter;
-
-template <>
-struct Converter<float> {
-    static_assert(sizeof(float) == sizeof(int32_t), "Important ULP matcher assumption violated");
-    Converter(float f) {
-        std::memcpy(&i, &f, sizeof(f));
-    }
-    int32_t i;
-};
-
-template <>
-struct Converter<double> {
-    static_assert(sizeof(double) == sizeof(int64_t), "Important ULP matcher assumption violated");
-    Converter(double d) {
-        std::memcpy(&i, &d, sizeof(d));
-    }
-    int64_t i;
-};
-
-template <typename T>
-auto convert(T t) -> Converter<T> {
-    return Converter<T>(t);
-}
-
-template <typename FP>
-bool almostEqualUlps(FP lhs, FP rhs, int maxUlpDiff) {
-    // Comparison with NaN should always be false.
-    // This way we can rule it out before getting into the ugly details
-    if (Catch::isnan(lhs) || Catch::isnan(rhs)) {
-        return false;
-    }
-
-    auto lc = convert(lhs);
-    auto rc = convert(rhs);
-
-    if ((lc.i < 0) != (rc.i < 0)) {
-        // Potentially we can have +0 and -0
-        return lhs == rhs;
-    }
-
-    auto ulpDiff = std::abs(lc.i - rc.i);
-    return ulpDiff <= maxUlpDiff;
-}
-
-template <typename FP>
-FP step(FP start, FP direction, int steps) {
-    for (int i = 0; i < steps; ++i) {
-        start = std::nextafter(start, direction);
-    }
-    return start;
-}
-
-} // end anonymous namespace
-
-namespace Catch {
-namespace Matchers {
-namespace Floating {
-    WithinAbsMatcher::WithinAbsMatcher(double target, double margin)
-        :m_target{ target }, m_margin{ margin } {
-        CATCH_ENFORCE(margin >= 0, "Invalid margin: " << margin << '.'
-            << " Margin has to be non-negative.");
-    }
-
-    // Performs equivalent check of std::fabs(lhs - rhs) <= margin
-    // But without the subtraction to allow for INFINITY in comparison
-    bool WithinAbsMatcher::match(double const& matchee) const {
-        return (matchee + m_margin >= m_target) && (m_target + m_margin >= matchee);
-    }
-
-    std::string WithinAbsMatcher::describe() const {
-        return "is within " + ::Catch::Detail::stringify(m_margin) + " of " + ::Catch::Detail::stringify(m_target);
-    }
-
-    WithinUlpsMatcher::WithinUlpsMatcher(double target, int ulps, FloatingPointKind baseType)
-        :m_target{ target }, m_ulps{ ulps }, m_type{ baseType } {
-        CATCH_ENFORCE(ulps >= 0, "Invalid ULP setting: " << ulps << '.'
-            << " ULPs have to be non-negative.");
-    }
-
-#if defined(__clang__)
-#pragma clang diagnostic push
-// Clang <3.5 reports on the default branch in the switch below
-#pragma clang diagnostic ignored "-Wunreachable-code"
-#endif
-
-    bool WithinUlpsMatcher::match(double const& matchee) const {
-        switch (m_type) {
-        case FloatingPointKind::Float:
-            return almostEqualUlps<float>(static_cast<float>(matchee), static_cast<float>(m_target), m_ulps);
-        case FloatingPointKind::Double:
-            return almostEqualUlps<double>(matchee, m_target, m_ulps);
-        default:
-            CATCH_INTERNAL_ERROR( "Unknown FloatingPointKind value" );
-        }
-    }
-
-#if defined(__clang__)
-#pragma clang diagnostic pop
-#endif
-
-    std::string WithinUlpsMatcher::describe() const {
-        std::stringstream ret;
-
-        ret << "is within " << m_ulps << " ULPs of " << ::Catch::Detail::stringify(m_target);
-
-        if (m_type == FloatingPointKind::Float) {
-            ret << 'f';
-        }
-
-        ret << " ([";
-        ret << std::fixed << std::setprecision(std::numeric_limits<double>::max_digits10);
-        if (m_type == FloatingPointKind::Double) {
-            ret << step(m_target, static_cast<double>(-INFINITY), m_ulps)
-                << ", "
-                << step(m_target, static_cast<double>(INFINITY), m_ulps);
-        } else {
-            ret << step<float>(static_cast<float>(m_target), -INFINITY, m_ulps)
-                << ", "
-                << step<float>(static_cast<float>(m_target), INFINITY, m_ulps);
-        }
-        ret << "])";
-
-        return ret.str();
-        //return "is within " + Catch::to_string(m_ulps) + " ULPs of " + ::Catch::Detail::stringify(m_target) + ((m_type == FloatingPointKind::Float)? "f" : "");
-    }
-
-}// namespace Floating
-
-Floating::WithinUlpsMatcher WithinULP(double target, int maxUlpDiff) {
-    return Floating::WithinUlpsMatcher(target, maxUlpDiff, Floating::FloatingPointKind::Double);
-}
-
-Floating::WithinUlpsMatcher WithinULP(float target, int maxUlpDiff) {
-    return Floating::WithinUlpsMatcher(target, maxUlpDiff, Floating::FloatingPointKind::Float);
-}
-
-Floating::WithinAbsMatcher WithinAbs(double target, double margin) {
-    return Floating::WithinAbsMatcher(target, margin);
-}
-
-} // namespace Matchers
-} // namespace Catch
-
-// end catch_matchers_floating.cpp
-// start catch_matchers_generic.cpp
-
-std::string Catch::Matchers::Generic::Detail::finalizeDescription(const std::string& desc) {
-    if (desc.empty()) {
-        return "matches undescribed predicate";
-    } else {
-        return "matches predicate: \"" + desc + '"';
-    }
-}
-// end catch_matchers_generic.cpp
-// start catch_matchers_string.cpp
-
-#include <regex>
-
-namespace Catch {
-namespace Matchers {
-
-    namespace StdString {
-
-        CasedString::CasedString( std::string const& str, CaseSensitive::Choice caseSensitivity )
-        :   m_caseSensitivity( caseSensitivity ),
-            m_str( adjustString( str ) )
-        {}
-        std::string CasedString::adjustString( std::string const& str ) const {
-            return m_caseSensitivity == CaseSensitive::No
-                   ? toLower( str )
-                   : str;
-        }
-        std::string CasedString::caseSensitivitySuffix() const {
-            return m_caseSensitivity == CaseSensitive::No
-                   ? " (case insensitive)"
-                   : std::string();
-        }
-
-        StringMatcherBase::StringMatcherBase( std::string const& operation, CasedString const& comparator )
-        : m_comparator( comparator ),
-          m_operation( operation ) {
-        }
-
-        std::string StringMatcherBase::describe() const {
-            std::string description;
-            description.reserve(5 + m_operation.size() + m_comparator.m_str.size() +
-                                        m_comparator.caseSensitivitySuffix().size());
-            description += m_operation;
-            description += ": \"";
-            description += m_comparator.m_str;
-            description += "\"";
-            description += m_comparator.caseSensitivitySuffix();
-            return description;
-        }
-
-        EqualsMatcher::EqualsMatcher( CasedString const& comparator ) : StringMatcherBase( "equals", comparator ) {}
-
-        bool EqualsMatcher::match( std::string const& source ) const {
-            return m_comparator.adjustString( source ) == m_comparator.m_str;
-        }
-
-        ContainsMatcher::ContainsMatcher( CasedString const& comparator ) : StringMatcherBase( "contains", comparator ) {}
-
-        bool ContainsMatcher::match( std::string const& source ) const {
-            return contains( m_comparator.adjustString( source ), m_comparator.m_str );
-        }
-
-        StartsWithMatcher::StartsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "starts with", comparator ) {}
-
-        bool StartsWithMatcher::match( std::string const& source ) const {
-            return startsWith( m_comparator.adjustString( source ), m_comparator.m_str );
-        }
-
-        EndsWithMatcher::EndsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "ends with", comparator ) {}
-
-        bool EndsWithMatcher::match( std::string const& source ) const {
-            return endsWith( m_comparator.adjustString( source ), m_comparator.m_str );
-        }
-
-        RegexMatcher::RegexMatcher(std::string regex, CaseSensitive::Choice caseSensitivity): m_regex(std::move(regex)), m_caseSensitivity(caseSensitivity) {}
-
-        bool RegexMatcher::match(std::string const& matchee) const {
-            auto flags = std::regex::ECMAScript; // ECMAScript is the default syntax option anyway
-            if (m_caseSensitivity == CaseSensitive::Choice::No) {
-                flags |= std::regex::icase;
-            }
-            auto reg = std::regex(m_regex, flags);
-            return std::regex_match(matchee, reg);
-        }
-
-        std::string RegexMatcher::describe() const {
-            return "matches " + ::Catch::Detail::stringify(m_regex) + ((m_caseSensitivity == CaseSensitive::Choice::Yes)? " case sensitively" : " case insensitively");
-        }
-
-    } // namespace StdString
-
-    StdString::EqualsMatcher Equals( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
-        return StdString::EqualsMatcher( StdString::CasedString( str, caseSensitivity) );
-    }
-    StdString::ContainsMatcher Contains( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
-        return StdString::ContainsMatcher( StdString::CasedString( str, caseSensitivity) );
-    }
-    StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
-        return StdString::EndsWithMatcher( StdString::CasedString( str, caseSensitivity) );
-    }
-    StdString::StartsWithMatcher StartsWith( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
-        return StdString::StartsWithMatcher( StdString::CasedString( str, caseSensitivity) );
-    }
-
-    StdString::RegexMatcher Matches(std::string const& regex, CaseSensitive::Choice caseSensitivity) {
-        return StdString::RegexMatcher(regex, caseSensitivity);
-    }
-
-} // namespace Matchers
-} // namespace Catch
-// end catch_matchers_string.cpp
-// start catch_message.cpp
-
-// start catch_uncaught_exceptions.h
-
-namespace Catch {
-    bool uncaught_exceptions();
-} // end namespace Catch
-
-// end catch_uncaught_exceptions.h
-#include <cassert>
-#include <stack>
-
-namespace Catch {
-
-    MessageInfo::MessageInfo(   StringRef const& _macroName,
-                                SourceLineInfo const& _lineInfo,
-                                ResultWas::OfType _type )
-    :   macroName( _macroName ),
-        lineInfo( _lineInfo ),
-        type( _type ),
-        sequence( ++globalCount )
-    {}
-
-    bool MessageInfo::operator==( MessageInfo const& other ) const {
-        return sequence == other.sequence;
-    }
-
-    bool MessageInfo::operator<( MessageInfo const& other ) const {
-        return sequence < other.sequence;
-    }
-
-    // This may need protecting if threading support is added
-    unsigned int MessageInfo::globalCount = 0;
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    Catch::MessageBuilder::MessageBuilder( StringRef const& macroName,
-                                           SourceLineInfo const& lineInfo,
-                                           ResultWas::OfType type )
-        :m_info(macroName, lineInfo, type) {}
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    ScopedMessage::ScopedMessage( MessageBuilder const& builder )
-    : m_info( builder.m_info ), m_moved()
-    {
-        m_info.message = builder.m_stream.str();
-        getResultCapture().pushScopedMessage( m_info );
-    }
-
-    ScopedMessage::ScopedMessage( ScopedMessage&& old )
-    : m_info( old.m_info ), m_moved()
-    {
-        old.m_moved = true;
-    }
-
-    ScopedMessage::~ScopedMessage() {
-        if ( !uncaught_exceptions() && !m_moved ){
-            getResultCapture().popScopedMessage(m_info);
-        }
-    }
-
-    Capturer::Capturer( StringRef macroName, SourceLineInfo const& lineInfo, ResultWas::OfType resultType, StringRef names ) {
-        auto trimmed = [&] (size_t start, size_t end) {
-            while (names[start] == ',' || isspace(names[start])) {
-                ++start;
-            }
-            while (names[end] == ',' || isspace(names[end])) {
-                --end;
-            }
-            return names.substr(start, end - start + 1);
-        };
-        auto skipq = [&] (size_t start, char quote) {
-            for (auto i = start + 1; i < names.size() ; ++i) {
-                if (names[i] == quote)
-                    return i;
-                if (names[i] == '\\')
-                    ++i;
-            }
-            CATCH_INTERNAL_ERROR("CAPTURE parsing encountered unmatched quote");
-        };
-
-        size_t start = 0;
-        std::stack<char> openings;
-        for (size_t pos = 0; pos < names.size(); ++pos) {
-            char c = names[pos];
-            switch (c) {
-            case '[':
-            case '{':
-            case '(':
-            // It is basically impossible to disambiguate between
-            // comparison and start of template args in this context
-//            case '<':
-                openings.push(c);
-                break;
-            case ']':
-            case '}':
-            case ')':
-//           case '>':
-                openings.pop();
-                break;
-            case '"':
-            case '\'':
-                pos = skipq(pos, c);
-                break;
-            case ',':
-                if (start != pos && openings.size() == 0) {
-                    m_messages.emplace_back(macroName, lineInfo, resultType);
-                    m_messages.back().message = trimmed(start, pos);
-                    m_messages.back().message += " := ";
-                    start = pos;
-                }
-            }
-        }
-        assert(openings.size() == 0 && "Mismatched openings");
-        m_messages.emplace_back(macroName, lineInfo, resultType);
-        m_messages.back().message = trimmed(start, names.size() - 1);
-        m_messages.back().message += " := ";
-    }
-    Capturer::~Capturer() {
-        if ( !uncaught_exceptions() ){
-            assert( m_captured == m_messages.size() );
-            for( size_t i = 0; i < m_captured; ++i  )
-                m_resultCapture.popScopedMessage( m_messages[i] );
-        }
-    }
-
-    void Capturer::captureValue( size_t index, std::string const& value ) {
-        assert( index < m_messages.size() );
-        m_messages[index].message += value;
-        m_resultCapture.pushScopedMessage( m_messages[index] );
-        m_captured++;
-    }
-
-} // end namespace Catch
-// end catch_message.cpp
-// start catch_output_redirect.cpp
-
-// start catch_output_redirect.h
-#ifndef TWOBLUECUBES_CATCH_OUTPUT_REDIRECT_H
-#define TWOBLUECUBES_CATCH_OUTPUT_REDIRECT_H
-
-#include <cstdio>
-#include <iosfwd>
-#include <string>
-
-namespace Catch {
-
-    class RedirectedStream {
-        std::ostream& m_originalStream;
-        std::ostream& m_redirectionStream;
-        std::streambuf* m_prevBuf;
-
-    public:
-        RedirectedStream( std::ostream& originalStream, std::ostream& redirectionStream );
-        ~RedirectedStream();
-    };
-
-    class RedirectedStdOut {
-        ReusableStringStream m_rss;
-        RedirectedStream m_cout;
-    public:
-        RedirectedStdOut();
-        auto str() const -> std::string;
-    };
-
-    // StdErr has two constituent streams in C++, std::cerr and std::clog
-    // This means that we need to redirect 2 streams into 1 to keep proper
-    // order of writes
-    class RedirectedStdErr {
-        ReusableStringStream m_rss;
-        RedirectedStream m_cerr;
-        RedirectedStream m_clog;
-    public:
-        RedirectedStdErr();
-        auto str() const -> std::string;
-    };
-
-    class RedirectedStreams {
-    public:
-        RedirectedStreams(RedirectedStreams const&) = delete;
-        RedirectedStreams& operator=(RedirectedStreams const&) = delete;
-        RedirectedStreams(RedirectedStreams&&) = delete;
-        RedirectedStreams& operator=(RedirectedStreams&&) = delete;
-
-        RedirectedStreams(std::string& redirectedCout, std::string& redirectedCerr);
-        ~RedirectedStreams();
-    private:
-        std::string& m_redirectedCout;
-        std::string& m_redirectedCerr;
-        RedirectedStdOut m_redirectedStdOut;
-        RedirectedStdErr m_redirectedStdErr;
-    };
-
-#if defined(CATCH_CONFIG_NEW_CAPTURE)
-
-    // Windows's implementation of std::tmpfile is terrible (it tries
-    // to create a file inside system folder, thus requiring elevated
-    // privileges for the binary), so we have to use tmpnam(_s) and
-    // create the file ourselves there.
-    class TempFile {
-    public:
-        TempFile(TempFile const&) = delete;
-        TempFile& operator=(TempFile const&) = delete;
-        TempFile(TempFile&&) = delete;
-        TempFile& operator=(TempFile&&) = delete;
-
-        TempFile();
-        ~TempFile();
-
-        std::FILE* getFile();
-        std::string getContents();
-
-    private:
-        std::FILE* m_file = nullptr;
-    #if defined(_MSC_VER)
-        char m_buffer[L_tmpnam] = { 0 };
-    #endif
-    };
-
-    class OutputRedirect {
-    public:
-        OutputRedirect(OutputRedirect const&) = delete;
-        OutputRedirect& operator=(OutputRedirect const&) = delete;
-        OutputRedirect(OutputRedirect&&) = delete;
-        OutputRedirect& operator=(OutputRedirect&&) = delete;
-
-        OutputRedirect(std::string& stdout_dest, std::string& stderr_dest);
-        ~OutputRedirect();
-
-    private:
-        int m_originalStdout = -1;
-        int m_originalStderr = -1;
-        TempFile m_stdoutFile;
-        TempFile m_stderrFile;
-        std::string& m_stdoutDest;
-        std::string& m_stderrDest;
-    };
-
-#endif
-
-} // end namespace Catch
-
-#endif // TWOBLUECUBES_CATCH_OUTPUT_REDIRECT_H
-// end catch_output_redirect.h
-#include <cstdio>
-#include <cstring>
-#include <fstream>
-#include <sstream>
-#include <stdexcept>
-
-#if defined(CATCH_CONFIG_NEW_CAPTURE)
-    #if defined(_MSC_VER)
-    #include <io.h>      //_dup and _dup2
-    #define dup _dup
-    #define dup2 _dup2
-    #define fileno _fileno
-    #else
-    #include <unistd.h>  // dup and dup2
-    #endif
-#endif
-
-namespace Catch {
-
-    RedirectedStream::RedirectedStream( std::ostream& originalStream, std::ostream& redirectionStream )
-    :   m_originalStream( originalStream ),
-        m_redirectionStream( redirectionStream ),
-        m_prevBuf( m_originalStream.rdbuf() )
-    {
-        m_originalStream.rdbuf( m_redirectionStream.rdbuf() );
-    }
-
-    RedirectedStream::~RedirectedStream() {
-        m_originalStream.rdbuf( m_prevBuf );
-    }
-
-    RedirectedStdOut::RedirectedStdOut() : m_cout( Catch::cout(), m_rss.get() ) {}
-    auto RedirectedStdOut::str() const -> std::string { return m_rss.str(); }
-
-    RedirectedStdErr::RedirectedStdErr()
-    :   m_cerr( Catch::cerr(), m_rss.get() ),
-        m_clog( Catch::clog(), m_rss.get() )
-    {}
-    auto RedirectedStdErr::str() const -> std::string { return m_rss.str(); }
-
-    RedirectedStreams::RedirectedStreams(std::string& redirectedCout, std::string& redirectedCerr)
-    :   m_redirectedCout(redirectedCout),
-        m_redirectedCerr(redirectedCerr)
-    {}
-
-    RedirectedStreams::~RedirectedStreams() {
-        m_redirectedCout += m_redirectedStdOut.str();
-        m_redirectedCerr += m_redirectedStdErr.str();
-    }
-
-#if defined(CATCH_CONFIG_NEW_CAPTURE)
-
-#if defined(_MSC_VER)
-    TempFile::TempFile() {
-        if (tmpnam_s(m_buffer)) {
-            CATCH_RUNTIME_ERROR("Could not get a temp filename");
-        }
-        if (fopen_s(&m_file, m_buffer, "w")) {
-            char buffer[100];
-            if (strerror_s(buffer, errno)) {
-                CATCH_RUNTIME_ERROR("Could not translate errno to a string");
-            }
-            CATCH_RUNTIME_ERROR("Could not open the temp file: '" << m_buffer << "' because: " << buffer);
-        }
-    }
-#else
-    TempFile::TempFile() {
-        m_file = std::tmpfile();
-        if (!m_file) {
-            CATCH_RUNTIME_ERROR("Could not create a temp file.");
-        }
-    }
-
-#endif
-
-    TempFile::~TempFile() {
-         // TBD: What to do about errors here?
-         std::fclose(m_file);
-         // We manually create the file on Windows only, on Linux
-         // it will be autodeleted
-#if defined(_MSC_VER)
-         std::remove(m_buffer);
-#endif
-    }
-
-    FILE* TempFile::getFile() {
-        return m_file;
-    }
-
-    std::string TempFile::getContents() {
-        std::stringstream sstr;
-        char buffer[100] = {};
-        std::rewind(m_file);
-        while (std::fgets(buffer, sizeof(buffer), m_file)) {
-            sstr << buffer;
-        }
-        return sstr.str();
-    }
-
-    OutputRedirect::OutputRedirect(std::string& stdout_dest, std::string& stderr_dest) :
-        m_originalStdout(dup(1)),
-        m_originalStderr(dup(2)),
-        m_stdoutDest(stdout_dest),
-        m_stderrDest(stderr_dest) {
-        dup2(fileno(m_stdoutFile.getFile()), 1);
-        dup2(fileno(m_stderrFile.getFile()), 2);
-    }
-
-    OutputRedirect::~OutputRedirect() {
-        Catch::cout() << std::flush;
-        fflush(stdout);
-        // Since we support overriding these streams, we flush cerr
-        // even though std::cerr is unbuffered
-        Catch::cerr() << std::flush;
-        Catch::clog() << std::flush;
-        fflush(stderr);
-
-        dup2(m_originalStdout, 1);
-        dup2(m_originalStderr, 2);
-
-        m_stdoutDest += m_stdoutFile.getContents();
-        m_stderrDest += m_stderrFile.getContents();
-    }
-
-#endif // CATCH_CONFIG_NEW_CAPTURE
-
-} // namespace Catch
-
-#if defined(CATCH_CONFIG_NEW_CAPTURE)
-    #if defined(_MSC_VER)
-    #undef dup
-    #undef dup2
-    #undef fileno
-    #endif
-#endif
-// end catch_output_redirect.cpp
-// start catch_polyfills.cpp
-
-#include <cmath>
-
-namespace Catch {
-
-#if !defined(CATCH_CONFIG_POLYFILL_ISNAN)
-    bool isnan(float f) {
-        return std::isnan(f);
-    }
-    bool isnan(double d) {
-        return std::isnan(d);
-    }
-#else
-    // For now we only use this for embarcadero
-    bool isnan(float f) {
-        return std::_isnan(f);
-    }
-    bool isnan(double d) {
-        return std::_isnan(d);
-    }
-#endif
-
-} // end namespace Catch
-// end catch_polyfills.cpp
-// start catch_random_number_generator.cpp
-
-namespace Catch {
-
-    std::mt19937& rng() {
-        static std::mt19937 s_rng;
-        return s_rng;
-    }
-
-    void seedRng( IConfig const& config ) {
-        if( config.rngSeed() != 0 ) {
-            std::srand( config.rngSeed() );
-            rng().seed( config.rngSeed() );
-        }
-    }
-
-    unsigned int rngSeed() {
-        return getCurrentContext().getConfig()->rngSeed();
-    }
-}
-// end catch_random_number_generator.cpp
-// start catch_registry_hub.cpp
-
-// start catch_test_case_registry_impl.h
-
-#include <vector>
-#include <set>
-#include <algorithm>
-#include <ios>
-
-namespace Catch {
-
-    class TestCase;
-    struct IConfig;
-
-    std::vector<TestCase> sortTests( IConfig const& config, std::vector<TestCase> const& unsortedTestCases );
-    bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config );
-
-    void enforceNoDuplicateTestCases( std::vector<TestCase> const& functions );
-
-    std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config );
-    std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config );
-
-    class TestRegistry : public ITestCaseRegistry {
-    public:
-        virtual ~TestRegistry() = default;
-
-        virtual void registerTest( TestCase const& testCase );
-
-        std::vector<TestCase> const& getAllTests() const override;
-        std::vector<TestCase> const& getAllTestsSorted( IConfig const& config ) const override;
-
-    private:
-        std::vector<TestCase> m_functions;
-        mutable RunTests::InWhatOrder m_currentSortOrder = RunTests::InDeclarationOrder;
-        mutable std::vector<TestCase> m_sortedFunctions;
-        std::size_t m_unnamedCount = 0;
-        std::ios_base::Init m_ostreamInit; // Forces cout/ cerr to be initialised
-    };
-
-    ///////////////////////////////////////////////////////////////////////////
-
-    class TestInvokerAsFunction : public ITestInvoker {
-        void(*m_testAsFunction)();
-    public:
-        TestInvokerAsFunction( void(*testAsFunction)() ) noexcept;
-
-        void invoke() const override;
-    };
-
-    std::string extractClassName( StringRef const& classOrQualifiedMethodName );
-
-    ///////////////////////////////////////////////////////////////////////////
-
-} // end namespace Catch
-
-// end catch_test_case_registry_impl.h
-// start catch_reporter_registry.h
-
-#include <map>
-
-namespace Catch {
-
-    class ReporterRegistry : public IReporterRegistry {
-
-    public:
-
-        ~ReporterRegistry() override;
-
-        IStreamingReporterPtr create( std::string const& name, IConfigPtr const& config ) const override;
-
-        void registerReporter( std::string const& name, IReporterFactoryPtr const& factory );
-        void registerListener( IReporterFactoryPtr const& factory );
-
-        FactoryMap const& getFactories() const override;
-        Listeners const& getListeners() const override;
-
-    private:
-        FactoryMap m_factories;
-        Listeners m_listeners;
-    };
-}
-
-// end catch_reporter_registry.h
-// start catch_tag_alias_registry.h
-
-// start catch_tag_alias.h
-
-#include <string>
-
-namespace Catch {
-
-    struct TagAlias {
-        TagAlias(std::string const& _tag, SourceLineInfo _lineInfo);
-
-        std::string tag;
-        SourceLineInfo lineInfo;
-    };
-
-} // end namespace Catch
-
-// end catch_tag_alias.h
-#include <map>
-
-namespace Catch {
-
-    class TagAliasRegistry : public ITagAliasRegistry {
-    public:
-        ~TagAliasRegistry() override;
-        TagAlias const* find( std::string const& alias ) const override;
-        std::string expandAliases( std::string const& unexpandedTestSpec ) const override;
-        void add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo );
-
-    private:
-        std::map<std::string, TagAlias> m_registry;
-    };
-
-} // end namespace Catch
-
-// end catch_tag_alias_registry.h
-// start catch_startup_exception_registry.h
-
-#include <vector>
-#include <exception>
-
-namespace Catch {
-
-    class StartupExceptionRegistry {
-    public:
-        void add(std::exception_ptr const& exception) noexcept;
-        std::vector<std::exception_ptr> const& getExceptions() const noexcept;
-    private:
-        std::vector<std::exception_ptr> m_exceptions;
-    };
-
-} // end namespace Catch
-
-// end catch_startup_exception_registry.h
-// start catch_singletons.hpp
-
-namespace Catch {
-
-    struct ISingleton {
-        virtual ~ISingleton();
-    };
-
-    void addSingleton( ISingleton* singleton );
-    void cleanupSingletons();
-
-    template<typename SingletonImplT, typename InterfaceT = SingletonImplT, typename MutableInterfaceT = InterfaceT>
-    class Singleton : SingletonImplT, public ISingleton {
-
-        static auto getInternal() -> Singleton* {
-            static Singleton* s_instance = nullptr;
-            if( !s_instance ) {
-                s_instance = new Singleton;
-                addSingleton( s_instance );
-            }
-            return s_instance;
-        }
-
-    public:
-        static auto get() -> InterfaceT const& {
-            return *getInternal();
-        }
-        static auto getMutable() -> MutableInterfaceT& {
-            return *getInternal();
-        }
-    };
-
-} // namespace Catch
-
-// end catch_singletons.hpp
-namespace Catch {
-
-    namespace {
-
-        class RegistryHub : public IRegistryHub, public IMutableRegistryHub,
-                            private NonCopyable {
-
-        public: // IRegistryHub
-            RegistryHub() = default;
-            IReporterRegistry const& getReporterRegistry() const override {
-                return m_reporterRegistry;
-            }
-            ITestCaseRegistry const& getTestCaseRegistry() const override {
-                return m_testCaseRegistry;
-            }
-            IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const override {
-                return m_exceptionTranslatorRegistry;
-            }
-            ITagAliasRegistry const& getTagAliasRegistry() const override {
-                return m_tagAliasRegistry;
-            }
-            StartupExceptionRegistry const& getStartupExceptionRegistry() const override {
-                return m_exceptionRegistry;
-            }
-
-        public: // IMutableRegistryHub
-            void registerReporter( std::string const& name, IReporterFactoryPtr const& factory ) override {
-                m_reporterRegistry.registerReporter( name, factory );
-            }
-            void registerListener( IReporterFactoryPtr const& factory ) override {
-                m_reporterRegistry.registerListener( factory );
-            }
-            void registerTest( TestCase const& testInfo ) override {
-                m_testCaseRegistry.registerTest( testInfo );
-            }
-            void registerTranslator( const IExceptionTranslator* translator ) override {
-                m_exceptionTranslatorRegistry.registerTranslator( translator );
-            }
-            void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) override {
-                m_tagAliasRegistry.add( alias, tag, lineInfo );
-            }
-            void registerStartupException() noexcept override {
-                m_exceptionRegistry.add(std::current_exception());
-            }
-            IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() override {
-                return m_enumValuesRegistry;
-            }
-
-        private:
-            TestRegistry m_testCaseRegistry;
-            ReporterRegistry m_reporterRegistry;
-            ExceptionTranslatorRegistry m_exceptionTranslatorRegistry;
-            TagAliasRegistry m_tagAliasRegistry;
-            StartupExceptionRegistry m_exceptionRegistry;
-            Detail::EnumValuesRegistry m_enumValuesRegistry;
-        };
-    }
-
-    using RegistryHubSingleton = Singleton<RegistryHub, IRegistryHub, IMutableRegistryHub>;
-
-    IRegistryHub const& getRegistryHub() {
-        return RegistryHubSingleton::get();
-    }
-    IMutableRegistryHub& getMutableRegistryHub() {
-        return RegistryHubSingleton::getMutable();
-    }
-    void cleanUp() {
-        cleanupSingletons();
-        cleanUpContext();
-    }
-    std::string translateActiveException() {
-        return getRegistryHub().getExceptionTranslatorRegistry().translateActiveException();
-    }
-
-} // end namespace Catch
-// end catch_registry_hub.cpp
-// start catch_reporter_registry.cpp
-
-namespace Catch {
-
-    ReporterRegistry::~ReporterRegistry() = default;
-
-    IStreamingReporterPtr ReporterRegistry::create( std::string const& name, IConfigPtr const& config ) const {
-        auto it =  m_factories.find( name );
-        if( it == m_factories.end() )
-            return nullptr;
-        return it->second->create( ReporterConfig( config ) );
-    }
-
-    void ReporterRegistry::registerReporter( std::string const& name, IReporterFactoryPtr const& factory ) {
-        m_factories.emplace(name, factory);
-    }
-    void ReporterRegistry::registerListener( IReporterFactoryPtr const& factory ) {
-        m_listeners.push_back( factory );
-    }
-
-    IReporterRegistry::FactoryMap const& ReporterRegistry::getFactories() const {
-        return m_factories;
-    }
-    IReporterRegistry::Listeners const& ReporterRegistry::getListeners() const {
-        return m_listeners;
-    }
-
-}
-// end catch_reporter_registry.cpp
-// start catch_result_type.cpp
-
-namespace Catch {
-
-    bool isOk( ResultWas::OfType resultType ) {
-        return ( resultType & ResultWas::FailureBit ) == 0;
-    }
-    bool isJustInfo( int flags ) {
-        return flags == ResultWas::Info;
-    }
-
-    ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs ) {
-        return static_cast<ResultDisposition::Flags>( static_cast<int>( lhs ) | static_cast<int>( rhs ) );
-    }
-
-    bool shouldContinueOnFailure( int flags )    { return ( flags & ResultDisposition::ContinueOnFailure ) != 0; }
-    bool shouldSuppressFailure( int flags )      { return ( flags & ResultDisposition::SuppressFail ) != 0; }
-
-} // end namespace Catch
-// end catch_result_type.cpp
-// start catch_run_context.cpp
-
-#include <cassert>
-#include <algorithm>
-#include <sstream>
-
-namespace Catch {
-
-    namespace Generators {
-        struct GeneratorTracker : TestCaseTracking::TrackerBase, IGeneratorTracker {
-            GeneratorBasePtr m_generator;
-
-            GeneratorTracker( TestCaseTracking::NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
-            :   TrackerBase( nameAndLocation, ctx, parent )
-            {}
-            ~GeneratorTracker();
-
-            static GeneratorTracker& acquire( TrackerContext& ctx, TestCaseTracking::NameAndLocation const& nameAndLocation ) {
-                std::shared_ptr<GeneratorTracker> tracker;
-
-                ITracker& currentTracker = ctx.currentTracker();
-                if( TestCaseTracking::ITrackerPtr childTracker = currentTracker.findChild( nameAndLocation ) ) {
-                    assert( childTracker );
-                    assert( childTracker->isGeneratorTracker() );
-                    tracker = std::static_pointer_cast<GeneratorTracker>( childTracker );
-                }
-                else {
-                    tracker = std::make_shared<GeneratorTracker>( nameAndLocation, ctx, &currentTracker );
-                    currentTracker.addChild( tracker );
-                }
-
-                if( !ctx.completedCycle() && !tracker->isComplete() ) {
-                    tracker->open();
-                }
-
-                return *tracker;
-            }
-
-            // TrackerBase interface
-            bool isGeneratorTracker() const override { return true; }
-            auto hasGenerator() const -> bool override {
-                return !!m_generator;
-            }
-            void close() override {
-                TrackerBase::close();
-                // Generator interface only finds out if it has another item on atual move
-                if (m_runState == CompletedSuccessfully && m_generator->next()) {
-                    m_children.clear();
-                    m_runState = Executing;
-                }
-            }
-
-            // IGeneratorTracker interface
-            auto getGenerator() const -> GeneratorBasePtr const& override {
-                return m_generator;
-            }
-            void setGenerator( GeneratorBasePtr&& generator ) override {
-                m_generator = std::move( generator );
-            }
-        };
-        GeneratorTracker::~GeneratorTracker() {}
-    }
-
-    RunContext::RunContext(IConfigPtr const& _config, IStreamingReporterPtr&& reporter)
-    :   m_runInfo(_config->name()),
-        m_context(getCurrentMutableContext()),
-        m_config(_config),
-        m_reporter(std::move(reporter)),
-        m_lastAssertionInfo{ StringRef(), SourceLineInfo("",0), StringRef(), ResultDisposition::Normal },
-        m_includeSuccessfulResults( m_config->includeSuccessfulResults() || m_reporter->getPreferences().shouldReportAllAssertions )
-    {
-        m_context.setRunner(this);
-        m_context.setConfig(m_config);
-        m_context.setResultCapture(this);
-        m_reporter->testRunStarting(m_runInfo);
-    }
-
-    RunContext::~RunContext() {
-        m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, aborting()));
-    }
-
-    void RunContext::testGroupStarting(std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount) {
-        m_reporter->testGroupStarting(GroupInfo(testSpec, groupIndex, groupsCount));
-    }
-
-    void RunContext::testGroupEnded(std::string const& testSpec, Totals const& totals, std::size_t groupIndex, std::size_t groupsCount) {
-        m_reporter->testGroupEnded(TestGroupStats(GroupInfo(testSpec, groupIndex, groupsCount), totals, aborting()));
-    }
-
-    Totals RunContext::runTest(TestCase const& testCase) {
-        Totals prevTotals = m_totals;
-
-        std::string redirectedCout;
-        std::string redirectedCerr;
-
-        auto const& testInfo = testCase.getTestCaseInfo();
-
-        m_reporter->testCaseStarting(testInfo);
-
-        m_activeTestCase = &testCase;
-
-        ITracker& rootTracker = m_trackerContext.startRun();
-        assert(rootTracker.isSectionTracker());
-        static_cast<SectionTracker&>(rootTracker).addInitialFilters(m_config->getSectionsToRun());
-        do {
-            m_trackerContext.startCycle();
-            m_testCaseTracker = &SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocation(testInfo.name, testInfo.lineInfo));
-            runCurrentTest(redirectedCout, redirectedCerr);
-        } while (!m_testCaseTracker->isSuccessfullyCompleted() && !aborting());
-
-        Totals deltaTotals = m_totals.delta(prevTotals);
-        if (testInfo.expectedToFail() && deltaTotals.testCases.passed > 0) {
-            deltaTotals.assertions.failed++;
-            deltaTotals.testCases.passed--;
-            deltaTotals.testCases.failed++;
-        }
-        m_totals.testCases += deltaTotals.testCases;
-        m_reporter->testCaseEnded(TestCaseStats(testInfo,
-                                  deltaTotals,
-                                  redirectedCout,
-                                  redirectedCerr,
-                                  aborting()));
-
-        m_activeTestCase = nullptr;
-        m_testCaseTracker = nullptr;
-
-        return deltaTotals;
-    }
-
-    IConfigPtr RunContext::config() const {
-        return m_config;
-    }
-
-    IStreamingReporter& RunContext::reporter() const {
-        return *m_reporter;
-    }
-
-    void RunContext::assertionEnded(AssertionResult const & result) {
-        if (result.getResultType() == ResultWas::Ok) {
-            m_totals.assertions.passed++;
-            m_lastAssertionPassed = true;
-        } else if (!result.isOk()) {
-            m_lastAssertionPassed = false;
-            if( m_activeTestCase->getTestCaseInfo().okToFail() )
-                m_totals.assertions.failedButOk++;
-            else
-                m_totals.assertions.failed++;
-        }
-        else {
-            m_lastAssertionPassed = true;
-        }
-
-        // We have no use for the return value (whether messages should be cleared), because messages were made scoped
-        // and should be let to clear themselves out.
-        static_cast<void>(m_reporter->assertionEnded(AssertionStats(result, m_messages, m_totals)));
-
-        if (result.getResultType() != ResultWas::Warning)
-            m_messageScopes.clear();
-
-        // Reset working state
-        resetAssertionInfo();
-        m_lastResult = result;
-    }
-    void RunContext::resetAssertionInfo() {
-        m_lastAssertionInfo.macroName = StringRef();
-        m_lastAssertionInfo.capturedExpression = "{Unknown expression after the reported line}"_sr;
-    }
-
-    bool RunContext::sectionStarted(SectionInfo const & sectionInfo, Counts & assertions) {
-        ITracker& sectionTracker = SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocation(sectionInfo.name, sectionInfo.lineInfo));
-        if (!sectionTracker.isOpen())
-            return false;
-        m_activeSections.push_back(&sectionTracker);
-
-        m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo;
-
-        m_reporter->sectionStarting(sectionInfo);
-
-        assertions = m_totals.assertions;
-
-        return true;
-    }
-    auto RunContext::acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& {
-        using namespace Generators;
-        GeneratorTracker& tracker = GeneratorTracker::acquire( m_trackerContext, TestCaseTracking::NameAndLocation( "generator", lineInfo ) );
-        assert( tracker.isOpen() );
-        m_lastAssertionInfo.lineInfo = lineInfo;
-        return tracker;
-    }
-
-    bool RunContext::testForMissingAssertions(Counts& assertions) {
-        if (assertions.total() != 0)
-            return false;
-        if (!m_config->warnAboutMissingAssertions())
-            return false;
-        if (m_trackerContext.currentTracker().hasChildren())
-            return false;
-        m_totals.assertions.failed++;
-        assertions.failed++;
-        return true;
-    }
-
-    void RunContext::sectionEnded(SectionEndInfo const & endInfo) {
-        Counts assertions = m_totals.assertions - endInfo.prevAssertions;
-        bool missingAssertions = testForMissingAssertions(assertions);
-
-        if (!m_activeSections.empty()) {
-            m_activeSections.back()->close();
-            m_activeSections.pop_back();
-        }
-
-        m_reporter->sectionEnded(SectionStats(endInfo.sectionInfo, assertions, endInfo.durationInSeconds, missingAssertions));
-        m_messages.clear();
-        m_messageScopes.clear();
-    }
-
-    void RunContext::sectionEndedEarly(SectionEndInfo const & endInfo) {
-        if (m_unfinishedSections.empty())
-            m_activeSections.back()->fail();
-        else
-            m_activeSections.back()->close();
-        m_activeSections.pop_back();
-
-        m_unfinishedSections.push_back(endInfo);
-    }
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-    void RunContext::benchmarkPreparing(std::string const& name) {
-		m_reporter->benchmarkPreparing(name);
-	}
-    void RunContext::benchmarkStarting( BenchmarkInfo const& info ) {
-        m_reporter->benchmarkStarting( info );
-    }
-    void RunContext::benchmarkEnded( BenchmarkStats<> const& stats ) {
-        m_reporter->benchmarkEnded( stats );
-    }
-	void RunContext::benchmarkFailed(std::string const & error) {
-		m_reporter->benchmarkFailed(error);
-	}
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-    void RunContext::pushScopedMessage(MessageInfo const & message) {
-        m_messages.push_back(message);
-    }
-
-    void RunContext::popScopedMessage(MessageInfo const & message) {
-        m_messages.erase(std::remove(m_messages.begin(), m_messages.end(), message), m_messages.end());
-    }
-
-    void RunContext::emplaceUnscopedMessage( MessageBuilder const& builder ) {
-        m_messageScopes.emplace_back( builder );
-    }
-
-    std::string RunContext::getCurrentTestName() const {
-        return m_activeTestCase
-            ? m_activeTestCase->getTestCaseInfo().name
-            : std::string();
-    }
-
-    const AssertionResult * RunContext::getLastResult() const {
-        return &(*m_lastResult);
-    }
-
-    void RunContext::exceptionEarlyReported() {
-        m_shouldReportUnexpected = false;
-    }
-
-    void RunContext::handleFatalErrorCondition( StringRef message ) {
-        // First notify reporter that bad things happened
-        m_reporter->fatalErrorEncountered(message);
-
-        // Don't rebuild the result -- the stringification itself can cause more fatal errors
-        // Instead, fake a result data.
-        AssertionResultData tempResult( ResultWas::FatalErrorCondition, { false } );
-        tempResult.message = message;
-        AssertionResult result(m_lastAssertionInfo, tempResult);
-
-        assertionEnded(result);
-
-        handleUnfinishedSections();
-
-        // Recreate section for test case (as we will lose the one that was in scope)
-        auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
-        SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
-
-        Counts assertions;
-        assertions.failed = 1;
-        SectionStats testCaseSectionStats(testCaseSection, assertions, 0, false);
-        m_reporter->sectionEnded(testCaseSectionStats);
-
-        auto const& testInfo = m_activeTestCase->getTestCaseInfo();
-
-        Totals deltaTotals;
-        deltaTotals.testCases.failed = 1;
-        deltaTotals.assertions.failed = 1;
-        m_reporter->testCaseEnded(TestCaseStats(testInfo,
-                                  deltaTotals,
-                                  std::string(),
-                                  std::string(),
-                                  false));
-        m_totals.testCases.failed++;
-        testGroupEnded(std::string(), m_totals, 1, 1);
-        m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, false));
-    }
-
-    bool RunContext::lastAssertionPassed() {
-         return m_lastAssertionPassed;
-    }
-
-    void RunContext::assertionPassed() {
-        m_lastAssertionPassed = true;
-        ++m_totals.assertions.passed;
-        resetAssertionInfo();
-        m_messageScopes.clear();
-    }
-
-    bool RunContext::aborting() const {
-        return m_totals.assertions.failed >= static_cast<std::size_t>(m_config->abortAfter());
-    }
-
-    void RunContext::runCurrentTest(std::string & redirectedCout, std::string & redirectedCerr) {
-        auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
-        SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
-        m_reporter->sectionStarting(testCaseSection);
-        Counts prevAssertions = m_totals.assertions;
-        double duration = 0;
-        m_shouldReportUnexpected = true;
-        m_lastAssertionInfo = { "TEST_CASE"_sr, testCaseInfo.lineInfo, StringRef(), ResultDisposition::Normal };
-
-        seedRng(*m_config);
-
-        Timer timer;
-        CATCH_TRY {
-            if (m_reporter->getPreferences().shouldRedirectStdOut) {
-#if !defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT)
-                RedirectedStreams redirectedStreams(redirectedCout, redirectedCerr);
-
-                timer.start();
-                invokeActiveTestCase();
-#else
-                OutputRedirect r(redirectedCout, redirectedCerr);
-                timer.start();
-                invokeActiveTestCase();
-#endif
-            } else {
-                timer.start();
-                invokeActiveTestCase();
-            }
-            duration = timer.getElapsedSeconds();
-        } CATCH_CATCH_ANON (TestFailureException&) {
-            // This just means the test was aborted due to failure
-        } CATCH_CATCH_ALL {
-            // Under CATCH_CONFIG_FAST_COMPILE, unexpected exceptions under REQUIRE assertions
-            // are reported without translation at the point of origin.
-            if( m_shouldReportUnexpected ) {
-                AssertionReaction dummyReaction;
-                handleUnexpectedInflightException( m_lastAssertionInfo, translateActiveException(), dummyReaction );
-            }
-        }
-        Counts assertions = m_totals.assertions - prevAssertions;
-        bool missingAssertions = testForMissingAssertions(assertions);
-
-        m_testCaseTracker->close();
-        handleUnfinishedSections();
-        m_messages.clear();
-        m_messageScopes.clear();
-
-        SectionStats testCaseSectionStats(testCaseSection, assertions, duration, missingAssertions);
-        m_reporter->sectionEnded(testCaseSectionStats);
-    }
-
-    void RunContext::invokeActiveTestCase() {
-        FatalConditionHandler fatalConditionHandler; // Handle signals
-        m_activeTestCase->invoke();
-        fatalConditionHandler.reset();
-    }
-
-    void RunContext::handleUnfinishedSections() {
-        // If sections ended prematurely due to an exception we stored their
-        // infos here so we can tear them down outside the unwind process.
-        for (auto it = m_unfinishedSections.rbegin(),
-             itEnd = m_unfinishedSections.rend();
-             it != itEnd;
-             ++it)
-            sectionEnded(*it);
-        m_unfinishedSections.clear();
-    }
-
-    void RunContext::handleExpr(
-        AssertionInfo const& info,
-        ITransientExpression const& expr,
-        AssertionReaction& reaction
-    ) {
-        m_reporter->assertionStarting( info );
-
-        bool negated = isFalseTest( info.resultDisposition );
-        bool result = expr.getResult() != negated;
-
-        if( result ) {
-            if (!m_includeSuccessfulResults) {
-                assertionPassed();
-            }
-            else {
-                reportExpr(info, ResultWas::Ok, &expr, negated);
-            }
-        }
-        else {
-            reportExpr(info, ResultWas::ExpressionFailed, &expr, negated );
-            populateReaction( reaction );
-        }
-    }
-    void RunContext::reportExpr(
-            AssertionInfo const &info,
-            ResultWas::OfType resultType,
-            ITransientExpression const *expr,
-            bool negated ) {
-
-        m_lastAssertionInfo = info;
-        AssertionResultData data( resultType, LazyExpression( negated ) );
-
-        AssertionResult assertionResult{ info, data };
-        assertionResult.m_resultData.lazyExpression.m_transientExpression = expr;
-
-        assertionEnded( assertionResult );
-    }
-
-    void RunContext::handleMessage(
-            AssertionInfo const& info,
-            ResultWas::OfType resultType,
-            StringRef const& message,
-            AssertionReaction& reaction
-    ) {
-        m_reporter->assertionStarting( info );
-
-        m_lastAssertionInfo = info;
-
-        AssertionResultData data( resultType, LazyExpression( false ) );
-        data.message = message;
-        AssertionResult assertionResult{ m_lastAssertionInfo, data };
-        assertionEnded( assertionResult );
-        if( !assertionResult.isOk() )
-            populateReaction( reaction );
-    }
-    void RunContext::handleUnexpectedExceptionNotThrown(
-            AssertionInfo const& info,
-            AssertionReaction& reaction
-    ) {
-        handleNonExpr(info, Catch::ResultWas::DidntThrowException, reaction);
-    }
-
-    void RunContext::handleUnexpectedInflightException(
-            AssertionInfo const& info,
-            std::string const& message,
-            AssertionReaction& reaction
-    ) {
-        m_lastAssertionInfo = info;
-
-        AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
-        data.message = message;
-        AssertionResult assertionResult{ info, data };
-        assertionEnded( assertionResult );
-        populateReaction( reaction );
-    }
-
-    void RunContext::populateReaction( AssertionReaction& reaction ) {
-        reaction.shouldDebugBreak = m_config->shouldDebugBreak();
-        reaction.shouldThrow = aborting() || (m_lastAssertionInfo.resultDisposition & ResultDisposition::Normal);
-    }
-
-    void RunContext::handleIncomplete(
-            AssertionInfo const& info
-    ) {
-        m_lastAssertionInfo = info;
-
-        AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
-        data.message = "Exception translation was disabled by CATCH_CONFIG_FAST_COMPILE";
-        AssertionResult assertionResult{ info, data };
-        assertionEnded( assertionResult );
-    }
-    void RunContext::handleNonExpr(
-            AssertionInfo const &info,
-            ResultWas::OfType resultType,
-            AssertionReaction &reaction
-    ) {
-        m_lastAssertionInfo = info;
-
-        AssertionResultData data( resultType, LazyExpression( false ) );
-        AssertionResult assertionResult{ info, data };
-        assertionEnded( assertionResult );
-
-        if( !assertionResult.isOk() )
-            populateReaction( reaction );
-    }
-
-    IResultCapture& getResultCapture() {
-        if (auto* capture = getCurrentContext().getResultCapture())
-            return *capture;
-        else
-            CATCH_INTERNAL_ERROR("No result capture instance");
-    }
-}
-// end catch_run_context.cpp
-// start catch_section.cpp
-
-namespace Catch {
-
-    Section::Section( SectionInfo const& info )
-    :   m_info( info ),
-        m_sectionIncluded( getResultCapture().sectionStarted( m_info, m_assertions ) )
-    {
-        m_timer.start();
-    }
-
-    Section::~Section() {
-        if( m_sectionIncluded ) {
-            SectionEndInfo endInfo{ m_info, m_assertions, m_timer.getElapsedSeconds() };
-            if( uncaught_exceptions() )
-                getResultCapture().sectionEndedEarly( endInfo );
-            else
-                getResultCapture().sectionEnded( endInfo );
-        }
-    }
-
-    // This indicates whether the section should be executed or not
-    Section::operator bool() const {
-        return m_sectionIncluded;
-    }
-
-} // end namespace Catch
-// end catch_section.cpp
-// start catch_section_info.cpp
-
-namespace Catch {
-
-    SectionInfo::SectionInfo
-        (   SourceLineInfo const& _lineInfo,
-            std::string const& _name )
-    :   name( _name ),
-        lineInfo( _lineInfo )
-    {}
-
-} // end namespace Catch
-// end catch_section_info.cpp
-// start catch_session.cpp
-
-// start catch_session.h
-
-#include <memory>
-
-namespace Catch {
-
-    class Session : NonCopyable {
-    public:
-
-        Session();
-        ~Session() override;
-
-        void showHelp() const;
-        void libIdentify();
-
-        int applyCommandLine( int argc, char const * const * argv );
-    #if defined(CATCH_CONFIG_WCHAR) && defined(WIN32) && defined(UNICODE)
-        int applyCommandLine( int argc, wchar_t const * const * argv );
-    #endif
-
-        void useConfigData( ConfigData const& configData );
-
-        template<typename CharT>
-        int run(int argc, CharT const * const argv[]) {
-            if (m_startupExceptions)
-                return 1;
-            int returnCode = applyCommandLine(argc, argv);
-            if (returnCode == 0)
-                returnCode = run();
-            return returnCode;
-        }
-
-        int run();
-
-        clara::Parser const& cli() const;
-        void cli( clara::Parser const& newParser );
-        ConfigData& configData();
-        Config& config();
-    private:
-        int runInternal();
-
-        clara::Parser m_cli;
-        ConfigData m_configData;
-        std::shared_ptr<Config> m_config;
-        bool m_startupExceptions = false;
-    };
-
-} // end namespace Catch
-
-// end catch_session.h
-// start catch_version.h
-
-#include <iosfwd>
-
-namespace Catch {
-
-    // Versioning information
-    struct Version {
-        Version( Version const& ) = delete;
-        Version& operator=( Version const& ) = delete;
-        Version(    unsigned int _majorVersion,
-                    unsigned int _minorVersion,
-                    unsigned int _patchNumber,
-                    char const * const _branchName,
-                    unsigned int _buildNumber );
-
-        unsigned int const majorVersion;
-        unsigned int const minorVersion;
-        unsigned int const patchNumber;
-
-        // buildNumber is only used if branchName is not null
-        char const * const branchName;
-        unsigned int const buildNumber;
-
-        friend std::ostream& operator << ( std::ostream& os, Version const& version );
-    };
-
-    Version const& libraryVersion();
-}
-
-// end catch_version.h
-#include <cstdlib>
-#include <iomanip>
-
-namespace Catch {
-
-    namespace {
-        const int MaxExitCode = 255;
-
-        IStreamingReporterPtr createReporter(std::string const& reporterName, IConfigPtr const& config) {
-            auto reporter = Catch::getRegistryHub().getReporterRegistry().create(reporterName, config);
-            CATCH_ENFORCE(reporter, "No reporter registered with name: '" << reporterName << "'");
-
-            return reporter;
-        }
-
-        IStreamingReporterPtr makeReporter(std::shared_ptr<Config> const& config) {
-            if (Catch::getRegistryHub().getReporterRegistry().getListeners().empty()) {
-                return createReporter(config->getReporterName(), config);
-            }
-
-            // On older platforms, returning std::unique_ptr<ListeningReporter>
-            // when the return type is std::unique_ptr<IStreamingReporter>
-            // doesn't compile without a std::move call. However, this causes
-            // a warning on newer platforms. Thus, we have to work around
-            // it a bit and downcast the pointer manually.
-            auto ret = std::unique_ptr<IStreamingReporter>(new ListeningReporter);
-            auto& multi = static_cast<ListeningReporter&>(*ret);
-            auto const& listeners = Catch::getRegistryHub().getReporterRegistry().getListeners();
-            for (auto const& listener : listeners) {
-                multi.addListener(listener->create(Catch::ReporterConfig(config)));
-            }
-            multi.addReporter(createReporter(config->getReporterName(), config));
-            return ret;
-        }
-
-        Catch::Totals runTests(std::shared_ptr<Config> const& config) {
-            auto reporter = makeReporter(config);
-
-            RunContext context(config, std::move(reporter));
-
-            Totals totals;
-
-            context.testGroupStarting(config->name(), 1, 1);
-
-            TestSpec testSpec = config->testSpec();
-
-            auto const& allTestCases = getAllTestCasesSorted(*config);
-            for (auto const& testCase : allTestCases) {
-                bool matching = (!testSpec.hasFilters() && !testCase.isHidden()) ||
-                                 (testSpec.hasFilters() && matchTest(testCase, testSpec, *config));
-
-                if (!context.aborting() && matching)
-                    totals += context.runTest(testCase);
-                else
-                    context.reporter().skipTest(testCase);
-            }
-
-            if (config->warnAboutNoTests() && totals.testCases.total() == 0) {
-                ReusableStringStream testConfig;
-
-                bool first = true;
-                for (const auto& input : config->getTestsOrTags()) {
-                    if (!first) { testConfig << ' '; }
-                    first = false;
-                    testConfig << input;
-                }
-
-                context.reporter().noMatchingTestCases(testConfig.str());
-                totals.error = -1;
-            }
-
-            context.testGroupEnded(config->name(), totals, 1, 1);
-            return totals;
-        }
-
-        void applyFilenamesAsTags(Catch::IConfig const& config) {
-            auto& tests = const_cast<std::vector<TestCase>&>(getAllTestCasesSorted(config));
-            for (auto& testCase : tests) {
-                auto tags = testCase.tags;
-
-                std::string filename = testCase.lineInfo.file;
-                auto lastSlash = filename.find_last_of("\\/");
-                if (lastSlash != std::string::npos) {
-                    filename.erase(0, lastSlash);
-                    filename[0] = '#';
-                }
-
-                auto lastDot = filename.find_last_of('.');
-                if (lastDot != std::string::npos) {
-                    filename.erase(lastDot);
-                }
-
-                tags.push_back(std::move(filename));
-                setTags(testCase, tags);
-            }
-        }
-
-    } // anon namespace
-
-    Session::Session() {
-        static bool alreadyInstantiated = false;
-        if( alreadyInstantiated ) {
-            CATCH_TRY { CATCH_INTERNAL_ERROR( "Only one instance of Catch::Session can ever be used" ); }
-            CATCH_CATCH_ALL { getMutableRegistryHub().registerStartupException(); }
-        }
-
-        // There cannot be exceptions at startup in no-exception mode.
-#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-        const auto& exceptions = getRegistryHub().getStartupExceptionRegistry().getExceptions();
-        if ( !exceptions.empty() ) {
-            config();
-            getCurrentMutableContext().setConfig(m_config);
-
-            m_startupExceptions = true;
-            Colour colourGuard( Colour::Red );
-            Catch::cerr() << "Errors occurred during startup!" << '\n';
-            // iterate over all exceptions and notify user
-            for ( const auto& ex_ptr : exceptions ) {
-                try {
-                    std::rethrow_exception(ex_ptr);
-                } catch ( std::exception const& ex ) {
-                    Catch::cerr() << Column( ex.what() ).indent(2) << '\n';
-                }
-            }
-        }
-#endif
-
-        alreadyInstantiated = true;
-        m_cli = makeCommandLineParser( m_configData );
-    }
-    Session::~Session() {
-        Catch::cleanUp();
-    }
-
-    void Session::showHelp() const {
-        Catch::cout()
-                << "\nCatch v" << libraryVersion() << "\n"
-                << m_cli << std::endl
-                << "For more detailed usage please see the project docs\n" << std::endl;
-    }
-    void Session::libIdentify() {
-        Catch::cout()
-                << std::left << std::setw(16) << "description: " << "A Catch test executable\n"
-                << std::left << std::setw(16) << "category: " << "testframework\n"
-                << std::left << std::setw(16) << "framework: " << "Catch Test\n"
-                << std::left << std::setw(16) << "version: " << libraryVersion() << std::endl;
-    }
-
-    int Session::applyCommandLine( int argc, char const * const * argv ) {
-        if( m_startupExceptions )
-            return 1;
-
-        auto result = m_cli.parse( clara::Args( argc, argv ) );
-        if( !result ) {
-            config();
-            getCurrentMutableContext().setConfig(m_config);
-            Catch::cerr()
-                << Colour( Colour::Red )
-                << "\nError(s) in input:\n"
-                << Column( result.errorMessage() ).indent( 2 )
-                << "\n\n";
-            Catch::cerr() << "Run with -? for usage\n" << std::endl;
-            return MaxExitCode;
-        }
-
-        if( m_configData.showHelp )
-            showHelp();
-        if( m_configData.libIdentify )
-            libIdentify();
-        m_config.reset();
-        return 0;
-    }
-
-#if defined(CATCH_CONFIG_WCHAR) && defined(WIN32) && defined(UNICODE)
-    int Session::applyCommandLine( int argc, wchar_t const * const * argv ) {
-
-        char **utf8Argv = new char *[ argc ];
-
-        for ( int i = 0; i < argc; ++i ) {
-            int bufSize = WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, NULL, 0, NULL, NULL );
-
-            utf8Argv[ i ] = new char[ bufSize ];
-
-            WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, utf8Argv[i], bufSize, NULL, NULL );
-        }
-
-        int returnCode = applyCommandLine( argc, utf8Argv );
-
-        for ( int i = 0; i < argc; ++i )
-            delete [] utf8Argv[ i ];
-
-        delete [] utf8Argv;
-
-        return returnCode;
-    }
-#endif
-
-    void Session::useConfigData( ConfigData const& configData ) {
-        m_configData = configData;
-        m_config.reset();
-    }
-
-    int Session::run() {
-        if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeStart ) != 0 ) {
-            Catch::cout() << "...waiting for enter/ return before starting" << std::endl;
-            static_cast<void>(std::getchar());
-        }
-        int exitCode = runInternal();
-        if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeExit ) != 0 ) {
-            Catch::cout() << "...waiting for enter/ return before exiting, with code: " << exitCode << std::endl;
-            static_cast<void>(std::getchar());
-        }
-        return exitCode;
-    }
-
-    clara::Parser const& Session::cli() const {
-        return m_cli;
-    }
-    void Session::cli( clara::Parser const& newParser ) {
-        m_cli = newParser;
-    }
-    ConfigData& Session::configData() {
-        return m_configData;
-    }
-    Config& Session::config() {
-        if( !m_config )
-            m_config = std::make_shared<Config>( m_configData );
-        return *m_config;
-    }
-
-    int Session::runInternal() {
-        if( m_startupExceptions )
-            return 1;
-
-        if (m_configData.showHelp || m_configData.libIdentify) {
-            return 0;
-        }
-
-        CATCH_TRY {
-            config(); // Force config to be constructed
-
-            seedRng( *m_config );
-
-            if( m_configData.filenamesAsTags )
-                applyFilenamesAsTags( *m_config );
-
-            // Handle list request
-            if( Option<std::size_t> listed = list( m_config ) )
-                return static_cast<int>( *listed );
-
-            auto totals = runTests( m_config );
-            // Note that on unices only the lower 8 bits are usually used, clamping
-            // the return value to 255 prevents false negative when some multiple
-            // of 256 tests has failed
-            return (std::min) (MaxExitCode, (std::max) (totals.error, static_cast<int>(totals.assertions.failed)));
-        }
-#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-        catch( std::exception& ex ) {
-            Catch::cerr() << ex.what() << std::endl;
-            return MaxExitCode;
-        }
-#endif
-    }
-
-} // end namespace Catch
-// end catch_session.cpp
-// start catch_singletons.cpp
-
-#include <vector>
-
-namespace Catch {
-
-    namespace {
-        static auto getSingletons() -> std::vector<ISingleton*>*& {
-            static std::vector<ISingleton*>* g_singletons = nullptr;
-            if( !g_singletons )
-                g_singletons = new std::vector<ISingleton*>();
-            return g_singletons;
-        }
-    }
-
-    ISingleton::~ISingleton() {}
-
-    void addSingleton(ISingleton* singleton ) {
-        getSingletons()->push_back( singleton );
-    }
-    void cleanupSingletons() {
-        auto& singletons = getSingletons();
-        for( auto singleton : *singletons )
-            delete singleton;
-        delete singletons;
-        singletons = nullptr;
-    }
-
-} // namespace Catch
-// end catch_singletons.cpp
-// start catch_startup_exception_registry.cpp
-
-namespace Catch {
-void StartupExceptionRegistry::add( std::exception_ptr const& exception ) noexcept {
-        CATCH_TRY {
-            m_exceptions.push_back(exception);
-        } CATCH_CATCH_ALL {
-            // If we run out of memory during start-up there's really not a lot more we can do about it
-            std::terminate();
-        }
-    }
-
-    std::vector<std::exception_ptr> const& StartupExceptionRegistry::getExceptions() const noexcept {
-        return m_exceptions;
-    }
-
-} // end namespace Catch
-// end catch_startup_exception_registry.cpp
-// start catch_stream.cpp
-
-#include <cstdio>
-#include <iostream>
-#include <fstream>
-#include <sstream>
-#include <vector>
-#include <memory>
-
-namespace Catch {
-
-    Catch::IStream::~IStream() = default;
-
-    namespace Detail { namespace {
-        template<typename WriterF, std::size_t bufferSize=256>
-        class StreamBufImpl : public std::streambuf {
-            char data[bufferSize];
-            WriterF m_writer;
-
-        public:
-            StreamBufImpl() {
-                setp( data, data + sizeof(data) );
-            }
-
-            ~StreamBufImpl() noexcept {
-                StreamBufImpl::sync();
-            }
-
-        private:
-            int overflow( int c ) override {
-                sync();
-
-                if( c != EOF ) {
-                    if( pbase() == epptr() )
-                        m_writer( std::string( 1, static_cast<char>( c ) ) );
-                    else
-                        sputc( static_cast<char>( c ) );
-                }
-                return 0;
-            }
-
-            int sync() override {
-                if( pbase() != pptr() ) {
-                    m_writer( std::string( pbase(), static_cast<std::string::size_type>( pptr() - pbase() ) ) );
-                    setp( pbase(), epptr() );
-                }
-                return 0;
-            }
-        };
-
-        ///////////////////////////////////////////////////////////////////////////
-
-        struct OutputDebugWriter {
-
-            void operator()( std::string const&str ) {
-                writeToDebugConsole( str );
-            }
-        };
-
-        ///////////////////////////////////////////////////////////////////////////
-
-        class FileStream : public IStream {
-            mutable std::ofstream m_ofs;
-        public:
-            FileStream( StringRef filename ) {
-                m_ofs.open( filename.c_str() );
-                CATCH_ENFORCE( !m_ofs.fail(), "Unable to open file: '" << filename << "'" );
-            }
-            ~FileStream() override = default;
-        public: // IStream
-            std::ostream& stream() const override {
-                return m_ofs;
-            }
-        };
-
-        ///////////////////////////////////////////////////////////////////////////
-
-        class CoutStream : public IStream {
-            mutable std::ostream m_os;
-        public:
-            // Store the streambuf from cout up-front because
-            // cout may get redirected when running tests
-            CoutStream() : m_os( Catch::cout().rdbuf() ) {}
-            ~CoutStream() override = default;
-
-        public: // IStream
-            std::ostream& stream() const override { return m_os; }
-        };
-
-        ///////////////////////////////////////////////////////////////////////////
-
-        class DebugOutStream : public IStream {
-            std::unique_ptr<StreamBufImpl<OutputDebugWriter>> m_streamBuf;
-            mutable std::ostream m_os;
-        public:
-            DebugOutStream()
-            :   m_streamBuf( new StreamBufImpl<OutputDebugWriter>() ),
-                m_os( m_streamBuf.get() )
-            {}
-
-            ~DebugOutStream() override = default;
-
-        public: // IStream
-            std::ostream& stream() const override { return m_os; }
-        };
-
-    }} // namespace anon::detail
-
-    ///////////////////////////////////////////////////////////////////////////
-
-    auto makeStream( StringRef const &filename ) -> IStream const* {
-        if( filename.empty() )
-            return new Detail::CoutStream();
-        else if( filename[0] == '%' ) {
-            if( filename == "%debug" )
-                return new Detail::DebugOutStream();
-            else
-                CATCH_ERROR( "Unrecognised stream: '" << filename << "'" );
-        }
-        else
-            return new Detail::FileStream( filename );
-    }
-
-    // This class encapsulates the idea of a pool of ostringstreams that can be reused.
-    struct StringStreams {
-        std::vector<std::unique_ptr<std::ostringstream>> m_streams;
-        std::vector<std::size_t> m_unused;
-        std::ostringstream m_referenceStream; // Used for copy state/ flags from
-
-        auto add() -> std::size_t {
-            if( m_unused.empty() ) {
-                m_streams.push_back( std::unique_ptr<std::ostringstream>( new std::ostringstream ) );
-                return m_streams.size()-1;
-            }
-            else {
-                auto index = m_unused.back();
-                m_unused.pop_back();
-                return index;
-            }
-        }
-
-        void release( std::size_t index ) {
-            m_streams[index]->copyfmt( m_referenceStream ); // Restore initial flags and other state
-            m_unused.push_back(index);
-        }
-    };
-
-    ReusableStringStream::ReusableStringStream()
-    :   m_index( Singleton<StringStreams>::getMutable().add() ),
-        m_oss( Singleton<StringStreams>::getMutable().m_streams[m_index].get() )
-    {}
-
-    ReusableStringStream::~ReusableStringStream() {
-        static_cast<std::ostringstream*>( m_oss )->str("");
-        m_oss->clear();
-        Singleton<StringStreams>::getMutable().release( m_index );
-    }
-
-    auto ReusableStringStream::str() const -> std::string {
-        return static_cast<std::ostringstream*>( m_oss )->str();
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-
-#ifndef CATCH_CONFIG_NOSTDOUT // If you #define this you must implement these functions
-    std::ostream& cout() { return std::cout; }
-    std::ostream& cerr() { return std::cerr; }
-    std::ostream& clog() { return std::clog; }
-#endif
-}
-// end catch_stream.cpp
-// start catch_string_manip.cpp
-
-#include <algorithm>
-#include <ostream>
-#include <cstring>
-#include <cctype>
-#include <vector>
-
-namespace Catch {
-
-    namespace {
-        char toLowerCh(char c) {
-            return static_cast<char>( std::tolower( c ) );
-        }
-    }
-
-    bool startsWith( std::string const& s, std::string const& prefix ) {
-        return s.size() >= prefix.size() && std::equal(prefix.begin(), prefix.end(), s.begin());
-    }
-    bool startsWith( std::string const& s, char prefix ) {
-        return !s.empty() && s[0] == prefix;
-    }
-    bool endsWith( std::string const& s, std::string const& suffix ) {
-        return s.size() >= suffix.size() && std::equal(suffix.rbegin(), suffix.rend(), s.rbegin());
-    }
-    bool endsWith( std::string const& s, char suffix ) {
-        return !s.empty() && s[s.size()-1] == suffix;
-    }
-    bool contains( std::string const& s, std::string const& infix ) {
-        return s.find( infix ) != std::string::npos;
-    }
-    void toLowerInPlace( std::string& s ) {
-        std::transform( s.begin(), s.end(), s.begin(), toLowerCh );
-    }
-    std::string toLower( std::string const& s ) {
-        std::string lc = s;
-        toLowerInPlace( lc );
-        return lc;
-    }
-    std::string trim( std::string const& str ) {
-        static char const* whitespaceChars = "\n\r\t ";
-        std::string::size_type start = str.find_first_not_of( whitespaceChars );
-        std::string::size_type end = str.find_last_not_of( whitespaceChars );
-
-        return start != std::string::npos ? str.substr( start, 1+end-start ) : std::string();
-    }
-
-    bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis ) {
-        bool replaced = false;
-        std::size_t i = str.find( replaceThis );
-        while( i != std::string::npos ) {
-            replaced = true;
-            str = str.substr( 0, i ) + withThis + str.substr( i+replaceThis.size() );
-            if( i < str.size()-withThis.size() )
-                i = str.find( replaceThis, i+withThis.size() );
-            else
-                i = std::string::npos;
-        }
-        return replaced;
-    }
-
-    std::vector<StringRef> splitStringRef( StringRef str, char delimiter ) {
-        std::vector<StringRef> subStrings;
-        std::size_t start = 0;
-        for(std::size_t pos = 0; pos < str.size(); ++pos ) {
-            if( str[pos] == delimiter ) {
-                if( pos - start > 1 )
-                    subStrings.push_back( str.substr( start, pos-start ) );
-                start = pos+1;
-            }
-        }
-        if( start < str.size() )
-            subStrings.push_back( str.substr( start, str.size()-start ) );
-        return subStrings;
-    }
-
-    pluralise::pluralise( std::size_t count, std::string const& label )
-    :   m_count( count ),
-        m_label( label )
-    {}
-
-    std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser ) {
-        os << pluraliser.m_count << ' ' << pluraliser.m_label;
-        if( pluraliser.m_count != 1 )
-            os << 's';
-        return os;
-    }
-
-}
-// end catch_string_manip.cpp
-// start catch_stringref.cpp
-
-#if defined(__clang__)
-#    pragma clang diagnostic push
-#    pragma clang diagnostic ignored "-Wexit-time-destructors"
-#endif
-
-#include <ostream>
-#include <cstring>
-#include <cstdint>
-
-namespace {
-    const uint32_t byte_2_lead = 0xC0;
-    const uint32_t byte_3_lead = 0xE0;
-    const uint32_t byte_4_lead = 0xF0;
-}
-
-namespace Catch {
-    StringRef::StringRef( char const* rawChars ) noexcept
-    : StringRef( rawChars, static_cast<StringRef::size_type>(std::strlen(rawChars) ) )
-    {}
-
-    StringRef::operator std::string() const {
-        return std::string( m_start, m_size );
-    }
-
-    void StringRef::swap( StringRef& other ) noexcept {
-        std::swap( m_start, other.m_start );
-        std::swap( m_size, other.m_size );
-        std::swap( m_data, other.m_data );
-    }
-
-    auto StringRef::c_str() const -> char const* {
-        if( !isSubstring() )
-            return m_start;
-
-        const_cast<StringRef *>( this )->takeOwnership();
-        return m_data;
-    }
-    auto StringRef::currentData() const noexcept -> char const* {
-        return m_start;
-    }
-
-    auto StringRef::isOwned() const noexcept -> bool {
-        return m_data != nullptr;
-    }
-    auto StringRef::isSubstring() const noexcept -> bool {
-        return m_start[m_size] != '\0';
-    }
-
-    void StringRef::takeOwnership() {
-        if( !isOwned() ) {
-            m_data = new char[m_size+1];
-            memcpy( m_data, m_start, m_size );
-            m_data[m_size] = '\0';
-        }
-    }
-    auto StringRef::substr( size_type start, size_type size ) const noexcept -> StringRef {
-        if( start < m_size )
-            return StringRef( m_start+start, size );
-        else
-            return StringRef();
-    }
-    auto StringRef::operator == ( StringRef const& other ) const noexcept -> bool {
-        return
-            size() == other.size() &&
-            (std::strncmp( m_start, other.m_start, size() ) == 0);
-    }
-    auto StringRef::operator != ( StringRef const& other ) const noexcept -> bool {
-        return !operator==( other );
-    }
-
-    auto StringRef::operator[](size_type index) const noexcept -> char {
-        return m_start[index];
-    }
-
-    auto StringRef::numberOfCharacters() const noexcept -> size_type {
-        size_type noChars = m_size;
-        // Make adjustments for uft encodings
-        for( size_type i=0; i < m_size; ++i ) {
-            char c = m_start[i];
-            if( ( c & byte_2_lead ) == byte_2_lead ) {
-                noChars--;
-                if (( c & byte_3_lead ) == byte_3_lead )
-                    noChars--;
-                if( ( c & byte_4_lead ) == byte_4_lead )
-                    noChars--;
-            }
-        }
-        return noChars;
-    }
-
-    auto operator + ( StringRef const& lhs, StringRef const& rhs ) -> std::string {
-        std::string str;
-        str.reserve( lhs.size() + rhs.size() );
-        str += lhs;
-        str += rhs;
-        return str;
-    }
-    auto operator + ( StringRef const& lhs, const char* rhs ) -> std::string {
-        return std::string( lhs ) + std::string( rhs );
-    }
-    auto operator + ( char const* lhs, StringRef const& rhs ) -> std::string {
-        return std::string( lhs ) + std::string( rhs );
-    }
-
-    auto operator << ( std::ostream& os, StringRef const& str ) -> std::ostream& {
-        return os.write(str.currentData(), str.size());
-    }
-
-    auto operator+=( std::string& lhs, StringRef const& rhs ) -> std::string& {
-        lhs.append(rhs.currentData(), rhs.size());
-        return lhs;
-    }
-
-} // namespace Catch
-
-#if defined(__clang__)
-#    pragma clang diagnostic pop
-#endif
-// end catch_stringref.cpp
-// start catch_tag_alias.cpp
-
-namespace Catch {
-    TagAlias::TagAlias(std::string const & _tag, SourceLineInfo _lineInfo): tag(_tag), lineInfo(_lineInfo) {}
-}
-// end catch_tag_alias.cpp
-// start catch_tag_alias_autoregistrar.cpp
-
-namespace Catch {
-
-    RegistrarForTagAliases::RegistrarForTagAliases(char const* alias, char const* tag, SourceLineInfo const& lineInfo) {
-        CATCH_TRY {
-            getMutableRegistryHub().registerTagAlias(alias, tag, lineInfo);
-        } CATCH_CATCH_ALL {
-            // Do not throw when constructing global objects, instead register the exception to be processed later
-            getMutableRegistryHub().registerStartupException();
-        }
-    }
-
-}
-// end catch_tag_alias_autoregistrar.cpp
-// start catch_tag_alias_registry.cpp
-
-#include <sstream>
-
-namespace Catch {
-
-    TagAliasRegistry::~TagAliasRegistry() {}
-
-    TagAlias const* TagAliasRegistry::find( std::string const& alias ) const {
-        auto it = m_registry.find( alias );
-        if( it != m_registry.end() )
-            return &(it->second);
-        else
-            return nullptr;
-    }
-
-    std::string TagAliasRegistry::expandAliases( std::string const& unexpandedTestSpec ) const {
-        std::string expandedTestSpec = unexpandedTestSpec;
-        for( auto const& registryKvp : m_registry ) {
-            std::size_t pos = expandedTestSpec.find( registryKvp.first );
-            if( pos != std::string::npos ) {
-                expandedTestSpec =  expandedTestSpec.substr( 0, pos ) +
-                                    registryKvp.second.tag +
-                                    expandedTestSpec.substr( pos + registryKvp.first.size() );
-            }
-        }
-        return expandedTestSpec;
-    }
-
-    void TagAliasRegistry::add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) {
-        CATCH_ENFORCE( startsWith(alias, "[@") && endsWith(alias, ']'),
-                      "error: tag alias, '" << alias << "' is not of the form [@alias name].\n" << lineInfo );
-
-        CATCH_ENFORCE( m_registry.insert(std::make_pair(alias, TagAlias(tag, lineInfo))).second,
-                      "error: tag alias, '" << alias << "' already registered.\n"
-                      << "\tFirst seen at: " << find(alias)->lineInfo << "\n"
-                      << "\tRedefined at: " << lineInfo );
-    }
-
-    ITagAliasRegistry::~ITagAliasRegistry() {}
-
-    ITagAliasRegistry const& ITagAliasRegistry::get() {
-        return getRegistryHub().getTagAliasRegistry();
-    }
-
-} // end namespace Catch
-// end catch_tag_alias_registry.cpp
-// start catch_test_case_info.cpp
-
-#include <cctype>
-#include <exception>
-#include <algorithm>
-#include <sstream>
-
-namespace Catch {
-
-    namespace {
-        TestCaseInfo::SpecialProperties parseSpecialTag( std::string const& tag ) {
-            if( startsWith( tag, '.' ) ||
-                tag == "!hide" )
-                return TestCaseInfo::IsHidden;
-            else if( tag == "!throws" )
-                return TestCaseInfo::Throws;
-            else if( tag == "!shouldfail" )
-                return TestCaseInfo::ShouldFail;
-            else if( tag == "!mayfail" )
-                return TestCaseInfo::MayFail;
-            else if( tag == "!nonportable" )
-                return TestCaseInfo::NonPortable;
-            else if( tag == "!benchmark" )
-                return static_cast<TestCaseInfo::SpecialProperties>( TestCaseInfo::Benchmark | TestCaseInfo::IsHidden );
-            else
-                return TestCaseInfo::None;
-        }
-        bool isReservedTag( std::string const& tag ) {
-            return parseSpecialTag( tag ) == TestCaseInfo::None && tag.size() > 0 && !std::isalnum( static_cast<unsigned char>(tag[0]) );
-        }
-        void enforceNotReservedTag( std::string const& tag, SourceLineInfo const& _lineInfo ) {
-            CATCH_ENFORCE( !isReservedTag(tag),
-                          "Tag name: [" << tag << "] is not allowed.\n"
-                          << "Tag names starting with non alphanumeric characters are reserved\n"
-                          << _lineInfo );
-        }
-    }
-
-    TestCase makeTestCase(  ITestInvoker* _testCase,
-                            std::string const& _className,
-                            NameAndTags const& nameAndTags,
-                            SourceLineInfo const& _lineInfo )
-    {
-        bool isHidden = false;
-
-        // Parse out tags
-        std::vector<std::string> tags;
-        std::string desc, tag;
-        bool inTag = false;
-        std::string _descOrTags = nameAndTags.tags;
-        for (char c : _descOrTags) {
-            if( !inTag ) {
-                if( c == '[' )
-                    inTag = true;
-                else
-                    desc += c;
-            }
-            else {
-                if( c == ']' ) {
-                    TestCaseInfo::SpecialProperties prop = parseSpecialTag( tag );
-                    if( ( prop & TestCaseInfo::IsHidden ) != 0 )
-                        isHidden = true;
-                    else if( prop == TestCaseInfo::None )
-                        enforceNotReservedTag( tag, _lineInfo );
-
-                    // Merged hide tags like `[.approvals]` should be added as
-                    // `[.][approvals]`. The `[.]` is added at later point, so
-                    // we only strip the prefix
-                    if (startsWith(tag, '.') && tag.size() > 1) {
-                        tag.erase(0, 1);
-                    }
-                    tags.push_back( tag );
-                    tag.clear();
-                    inTag = false;
-                }
-                else
-                    tag += c;
-            }
-        }
-        if( isHidden ) {
-            tags.push_back( "." );
-        }
-
-        TestCaseInfo info( nameAndTags.name, _className, desc, tags, _lineInfo );
-        return TestCase( _testCase, std::move(info) );
-    }
-
-    void setTags( TestCaseInfo& testCaseInfo, std::vector<std::string> tags ) {
-        std::sort(begin(tags), end(tags));
-        tags.erase(std::unique(begin(tags), end(tags)), end(tags));
-        testCaseInfo.lcaseTags.clear();
-
-        for( auto const& tag : tags ) {
-            std::string lcaseTag = toLower( tag );
-            testCaseInfo.properties = static_cast<TestCaseInfo::SpecialProperties>( testCaseInfo.properties | parseSpecialTag( lcaseTag ) );
-            testCaseInfo.lcaseTags.push_back( lcaseTag );
-        }
-        testCaseInfo.tags = std::move(tags);
-    }
-
-    TestCaseInfo::TestCaseInfo( std::string const& _name,
-                                std::string const& _className,
-                                std::string const& _description,
-                                std::vector<std::string> const& _tags,
-                                SourceLineInfo const& _lineInfo )
-    :   name( _name ),
-        className( _className ),
-        description( _description ),
-        lineInfo( _lineInfo ),
-        properties( None )
-    {
-        setTags( *this, _tags );
-    }
-
-    bool TestCaseInfo::isHidden() const {
-        return ( properties & IsHidden ) != 0;
-    }
-    bool TestCaseInfo::throws() const {
-        return ( properties & Throws ) != 0;
-    }
-    bool TestCaseInfo::okToFail() const {
-        return ( properties & (ShouldFail | MayFail ) ) != 0;
-    }
-    bool TestCaseInfo::expectedToFail() const {
-        return ( properties & (ShouldFail ) ) != 0;
-    }
-
-    std::string TestCaseInfo::tagsAsString() const {
-        std::string ret;
-        // '[' and ']' per tag
-        std::size_t full_size = 2 * tags.size();
-        for (const auto& tag : tags) {
-            full_size += tag.size();
-        }
-        ret.reserve(full_size);
-        for (const auto& tag : tags) {
-            ret.push_back('[');
-            ret.append(tag);
-            ret.push_back(']');
-        }
-
-        return ret;
-    }
-
-    TestCase::TestCase( ITestInvoker* testCase, TestCaseInfo&& info ) : TestCaseInfo( std::move(info) ), test( testCase ) {}
-
-    TestCase TestCase::withName( std::string const& _newName ) const {
-        TestCase other( *this );
-        other.name = _newName;
-        return other;
-    }
-
-    void TestCase::invoke() const {
-        test->invoke();
-    }
-
-    bool TestCase::operator == ( TestCase const& other ) const {
-        return  test.get() == other.test.get() &&
-                name == other.name &&
-                className == other.className;
-    }
-
-    bool TestCase::operator < ( TestCase const& other ) const {
-        return name < other.name;
-    }
-
-    TestCaseInfo const& TestCase::getTestCaseInfo() const
-    {
-        return *this;
-    }
-
-} // end namespace Catch
-// end catch_test_case_info.cpp
-// start catch_test_case_registry_impl.cpp
-
-#include <sstream>
-
-namespace Catch {
-
-    std::vector<TestCase> sortTests( IConfig const& config, std::vector<TestCase> const& unsortedTestCases ) {
-
-        std::vector<TestCase> sorted = unsortedTestCases;
-
-        switch( config.runOrder() ) {
-            case RunTests::InLexicographicalOrder:
-                std::sort( sorted.begin(), sorted.end() );
-                break;
-            case RunTests::InRandomOrder:
-                seedRng( config );
-                std::shuffle( sorted.begin(), sorted.end(), rng() );
-                break;
-            case RunTests::InDeclarationOrder:
-                // already in declaration order
-                break;
-        }
-        return sorted;
-    }
-    bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config ) {
-        return testSpec.matches( testCase ) && ( config.allowThrows() || !testCase.throws() );
-    }
-
-    void enforceNoDuplicateTestCases( std::vector<TestCase> const& functions ) {
-        std::set<TestCase> seenFunctions;
-        for( auto const& function : functions ) {
-            auto prev = seenFunctions.insert( function );
-            CATCH_ENFORCE( prev.second,
-                    "error: TEST_CASE( \"" << function.name << "\" ) already defined.\n"
-                    << "\tFirst seen at " << prev.first->getTestCaseInfo().lineInfo << "\n"
-                    << "\tRedefined at " << function.getTestCaseInfo().lineInfo );
-        }
-    }
-
-    std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config ) {
-        std::vector<TestCase> filtered;
-        filtered.reserve( testCases.size() );
-        for (auto const& testCase : testCases) {
-            if ((!testSpec.hasFilters() && !testCase.isHidden()) ||
-                (testSpec.hasFilters() && matchTest(testCase, testSpec, config))) {
-                filtered.push_back(testCase);
-            }
-        }
-        return filtered;
-    }
-    std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config ) {
-        return getRegistryHub().getTestCaseRegistry().getAllTestsSorted( config );
-    }
-
-    void TestRegistry::registerTest( TestCase const& testCase ) {
-        std::string name = testCase.getTestCaseInfo().name;
-        if( name.empty() ) {
-            ReusableStringStream rss;
-            rss << "Anonymous test case " << ++m_unnamedCount;
-            return registerTest( testCase.withName( rss.str() ) );
-        }
-        m_functions.push_back( testCase );
-    }
-
-    std::vector<TestCase> const& TestRegistry::getAllTests() const {
-        return m_functions;
-    }
-    std::vector<TestCase> const& TestRegistry::getAllTestsSorted( IConfig const& config ) const {
-        if( m_sortedFunctions.empty() )
-            enforceNoDuplicateTestCases( m_functions );
-
-        if(  m_currentSortOrder != config.runOrder() || m_sortedFunctions.empty() ) {
-            m_sortedFunctions = sortTests( config, m_functions );
-            m_currentSortOrder = config.runOrder();
-        }
-        return m_sortedFunctions;
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    TestInvokerAsFunction::TestInvokerAsFunction( void(*testAsFunction)() ) noexcept : m_testAsFunction( testAsFunction ) {}
-
-    void TestInvokerAsFunction::invoke() const {
-        m_testAsFunction();
-    }
-
-    std::string extractClassName( StringRef const& classOrQualifiedMethodName ) {
-        std::string className = classOrQualifiedMethodName;
-        if( startsWith( className, '&' ) )
-        {
-            std::size_t lastColons = className.rfind( "::" );
-            std::size_t penultimateColons = className.rfind( "::", lastColons-1 );
-            if( penultimateColons == std::string::npos )
-                penultimateColons = 1;
-            className = className.substr( penultimateColons, lastColons-penultimateColons );
-        }
-        return className;
-    }
-
-} // end namespace Catch
-// end catch_test_case_registry_impl.cpp
-// start catch_test_case_tracker.cpp
-
-#include <algorithm>
-#include <cassert>
-#include <stdexcept>
-#include <memory>
-#include <sstream>
-
-#if defined(__clang__)
-#    pragma clang diagnostic push
-#    pragma clang diagnostic ignored "-Wexit-time-destructors"
-#endif
-
-namespace Catch {
-namespace TestCaseTracking {
-
-    NameAndLocation::NameAndLocation( std::string const& _name, SourceLineInfo const& _location )
-    :   name( _name ),
-        location( _location )
-    {}
-
-    ITracker::~ITracker() = default;
-
-    ITracker& TrackerContext::startRun() {
-        m_rootTracker = std::make_shared<SectionTracker>( NameAndLocation( "{root}", CATCH_INTERNAL_LINEINFO ), *this, nullptr );
-        m_currentTracker = nullptr;
-        m_runState = Executing;
-        return *m_rootTracker;
-    }
-
-    void TrackerContext::endRun() {
-        m_rootTracker.reset();
-        m_currentTracker = nullptr;
-        m_runState = NotStarted;
-    }
-
-    void TrackerContext::startCycle() {
-        m_currentTracker = m_rootTracker.get();
-        m_runState = Executing;
-    }
-    void TrackerContext::completeCycle() {
-        m_runState = CompletedCycle;
-    }
-
-    bool TrackerContext::completedCycle() const {
-        return m_runState == CompletedCycle;
-    }
-    ITracker& TrackerContext::currentTracker() {
-        return *m_currentTracker;
-    }
-    void TrackerContext::setCurrentTracker( ITracker* tracker ) {
-        m_currentTracker = tracker;
-    }
-
-    TrackerBase::TrackerBase( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
-    :   m_nameAndLocation( nameAndLocation ),
-        m_ctx( ctx ),
-        m_parent( parent )
-    {}
-
-    NameAndLocation const& TrackerBase::nameAndLocation() const {
-        return m_nameAndLocation;
-    }
-    bool TrackerBase::isComplete() const {
-        return m_runState == CompletedSuccessfully || m_runState == Failed;
-    }
-    bool TrackerBase::isSuccessfullyCompleted() const {
-        return m_runState == CompletedSuccessfully;
-    }
-    bool TrackerBase::isOpen() const {
-        return m_runState != NotStarted && !isComplete();
-    }
-    bool TrackerBase::hasChildren() const {
-        return !m_children.empty();
-    }
-
-    void TrackerBase::addChild( ITrackerPtr const& child ) {
-        m_children.push_back( child );
-    }
-
-    ITrackerPtr TrackerBase::findChild( NameAndLocation const& nameAndLocation ) {
-        auto it = std::find_if( m_children.begin(), m_children.end(),
-            [&nameAndLocation]( ITrackerPtr const& tracker ){
-                return
-                    tracker->nameAndLocation().location == nameAndLocation.location &&
-                    tracker->nameAndLocation().name == nameAndLocation.name;
-            } );
-        return( it != m_children.end() )
-            ? *it
-            : nullptr;
-    }
-    ITracker& TrackerBase::parent() {
-        assert( m_parent ); // Should always be non-null except for root
-        return *m_parent;
-    }
-
-    void TrackerBase::openChild() {
-        if( m_runState != ExecutingChildren ) {
-            m_runState = ExecutingChildren;
-            if( m_parent )
-                m_parent->openChild();
-        }
-    }
-
-    bool TrackerBase::isSectionTracker() const { return false; }
-    bool TrackerBase::isGeneratorTracker() const { return false; }
-
-    void TrackerBase::open() {
-        m_runState = Executing;
-        moveToThis();
-        if( m_parent )
-            m_parent->openChild();
-    }
-
-    void TrackerBase::close() {
-
-        // Close any still open children (e.g. generators)
-        while( &m_ctx.currentTracker() != this )
-            m_ctx.currentTracker().close();
-
-        switch( m_runState ) {
-            case NeedsAnotherRun:
-                break;
-
-            case Executing:
-                m_runState = CompletedSuccessfully;
-                break;
-            case ExecutingChildren:
-                if( m_children.empty() || m_children.back()->isComplete() )
-                    m_runState = CompletedSuccessfully;
-                break;
-
-            case NotStarted:
-            case CompletedSuccessfully:
-            case Failed:
-                CATCH_INTERNAL_ERROR( "Illogical state: " << m_runState );
-
-            default:
-                CATCH_INTERNAL_ERROR( "Unknown state: " << m_runState );
-        }
-        moveToParent();
-        m_ctx.completeCycle();
-    }
-    void TrackerBase::fail() {
-        m_runState = Failed;
-        if( m_parent )
-            m_parent->markAsNeedingAnotherRun();
-        moveToParent();
-        m_ctx.completeCycle();
-    }
-    void TrackerBase::markAsNeedingAnotherRun() {
-        m_runState = NeedsAnotherRun;
-    }
-
-    void TrackerBase::moveToParent() {
-        assert( m_parent );
-        m_ctx.setCurrentTracker( m_parent );
-    }
-    void TrackerBase::moveToThis() {
-        m_ctx.setCurrentTracker( this );
-    }
-
-    SectionTracker::SectionTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
-    :   TrackerBase( nameAndLocation, ctx, parent )
-    {
-        if( parent ) {
-            while( !parent->isSectionTracker() )
-                parent = &parent->parent();
-
-            SectionTracker& parentSection = static_cast<SectionTracker&>( *parent );
-            addNextFilters( parentSection.m_filters );
-        }
-    }
-
-    bool SectionTracker::isComplete() const {
-        bool complete = true;
-
-        if ((m_filters.empty() || m_filters[0] == "") ||
-             std::find(m_filters.begin(), m_filters.end(),
-                       m_nameAndLocation.name) != m_filters.end())
-            complete = TrackerBase::isComplete();
-        return complete;
-
-    }
-
-    bool SectionTracker::isSectionTracker() const { return true; }
-
-    SectionTracker& SectionTracker::acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation ) {
-        std::shared_ptr<SectionTracker> section;
-
-        ITracker& currentTracker = ctx.currentTracker();
-        if( ITrackerPtr childTracker = currentTracker.findChild( nameAndLocation ) ) {
-            assert( childTracker );
-            assert( childTracker->isSectionTracker() );
-            section = std::static_pointer_cast<SectionTracker>( childTracker );
-        }
-        else {
-            section = std::make_shared<SectionTracker>( nameAndLocation, ctx, &currentTracker );
-            currentTracker.addChild( section );
-        }
-        if( !ctx.completedCycle() )
-            section->tryOpen();
-        return *section;
-    }
-
-    void SectionTracker::tryOpen() {
-        if( !isComplete() && (m_filters.empty() || m_filters[0].empty() ||  m_filters[0] == m_nameAndLocation.name ) )
-            open();
-    }
-
-    void SectionTracker::addInitialFilters( std::vector<std::string> const& filters ) {
-        if( !filters.empty() ) {
-            m_filters.push_back(""); // Root - should never be consulted
-            m_filters.push_back(""); // Test Case - not a section filter
-            m_filters.insert( m_filters.end(), filters.begin(), filters.end() );
-        }
-    }
-    void SectionTracker::addNextFilters( std::vector<std::string> const& filters ) {
-        if( filters.size() > 1 )
-            m_filters.insert( m_filters.end(), ++filters.begin(), filters.end() );
-    }
-
-} // namespace TestCaseTracking
-
-using TestCaseTracking::ITracker;
-using TestCaseTracking::TrackerContext;
-using TestCaseTracking::SectionTracker;
-
-} // namespace Catch
-
-#if defined(__clang__)
-#    pragma clang diagnostic pop
-#endif
-// end catch_test_case_tracker.cpp
-// start catch_test_registry.cpp
-
-namespace Catch {
-
-    auto makeTestInvoker( void(*testAsFunction)() ) noexcept -> ITestInvoker* {
-        return new(std::nothrow) TestInvokerAsFunction( testAsFunction );
-    }
-
-    NameAndTags::NameAndTags( StringRef const& name_ , StringRef const& tags_ ) noexcept : name( name_ ), tags( tags_ ) {}
-
-    AutoReg::AutoReg( ITestInvoker* invoker, SourceLineInfo const& lineInfo, StringRef const& classOrMethod, NameAndTags const& nameAndTags ) noexcept {
-        CATCH_TRY {
-            getMutableRegistryHub()
-                    .registerTest(
-                        makeTestCase(
-                            invoker,
-                            extractClassName( classOrMethod ),
-                            nameAndTags,
-                            lineInfo));
-        } CATCH_CATCH_ALL {
-            // Do not throw when constructing global objects, instead register the exception to be processed later
-            getMutableRegistryHub().registerStartupException();
-        }
-    }
-
-    AutoReg::~AutoReg() = default;
-}
-// end catch_test_registry.cpp
-// start catch_test_spec.cpp
-
-#include <algorithm>
-#include <string>
-#include <vector>
-#include <memory>
-
-namespace Catch {
-
-    TestSpec::Pattern::~Pattern() = default;
-    TestSpec::NamePattern::~NamePattern() = default;
-    TestSpec::TagPattern::~TagPattern() = default;
-    TestSpec::ExcludedPattern::~ExcludedPattern() = default;
-
-    TestSpec::NamePattern::NamePattern( std::string const& name )
-    : m_wildcardPattern( toLower( name ), CaseSensitive::No )
-    {}
-    bool TestSpec::NamePattern::matches( TestCaseInfo const& testCase ) const {
-        return m_wildcardPattern.matches( toLower( testCase.name ) );
-    }
-
-    TestSpec::TagPattern::TagPattern( std::string const& tag ) : m_tag( toLower( tag ) ) {}
-    bool TestSpec::TagPattern::matches( TestCaseInfo const& testCase ) const {
-        return std::find(begin(testCase.lcaseTags),
-                         end(testCase.lcaseTags),
-                         m_tag) != end(testCase.lcaseTags);
-    }
-
-    TestSpec::ExcludedPattern::ExcludedPattern( PatternPtr const& underlyingPattern ) : m_underlyingPattern( underlyingPattern ) {}
-    bool TestSpec::ExcludedPattern::matches( TestCaseInfo const& testCase ) const { return !m_underlyingPattern->matches( testCase ); }
-
-    bool TestSpec::Filter::matches( TestCaseInfo const& testCase ) const {
-        // All patterns in a filter must match for the filter to be a match
-        for( auto const& pattern : m_patterns ) {
-            if( !pattern->matches( testCase ) )
-                return false;
-        }
-        return true;
-    }
-
-    bool TestSpec::hasFilters() const {
-        return !m_filters.empty();
-    }
-    bool TestSpec::matches( TestCaseInfo const& testCase ) const {
-        // A TestSpec matches if any filter matches
-        for( auto const& filter : m_filters )
-            if( filter.matches( testCase ) )
-                return true;
-        return false;
-    }
-}
-// end catch_test_spec.cpp
-// start catch_test_spec_parser.cpp
-
-namespace Catch {
-
-    TestSpecParser::TestSpecParser( ITagAliasRegistry const& tagAliases ) : m_tagAliases( &tagAliases ) {}
-
-    TestSpecParser& TestSpecParser::parse( std::string const& arg ) {
-        m_mode = None;
-        m_exclusion = false;
-        m_start = std::string::npos;
-        m_arg = m_tagAliases->expandAliases( arg );
-        m_escapeChars.clear();
-        for( m_pos = 0; m_pos < m_arg.size(); ++m_pos )
-            visitChar( m_arg[m_pos] );
-        if( m_mode == Name )
-            addPattern<TestSpec::NamePattern>();
-        return *this;
-    }
-    TestSpec TestSpecParser::testSpec() {
-        addFilter();
-        return m_testSpec;
-    }
-
-    void TestSpecParser::visitChar( char c ) {
-        if( m_mode == None ) {
-            switch( c ) {
-            case ' ': return;
-            case '~': m_exclusion = true; return;
-            case '[': return startNewMode( Tag, ++m_pos );
-            case '"': return startNewMode( QuotedName, ++m_pos );
-            case '\\': return escape();
-            default: startNewMode( Name, m_pos ); break;
-            }
-        }
-        if( m_mode == Name ) {
-            if( c == ',' ) {
-                addPattern<TestSpec::NamePattern>();
-                addFilter();
-            }
-            else if( c == '[' ) {
-                if( subString() == "exclude:" )
-                    m_exclusion = true;
-                else
-                    addPattern<TestSpec::NamePattern>();
-                startNewMode( Tag, ++m_pos );
-            }
-            else if( c == '\\' )
-                escape();
-        }
-        else if( m_mode == EscapedName )
-            m_mode = Name;
-        else if( m_mode == QuotedName && c == '"' )
-            addPattern<TestSpec::NamePattern>();
-        else if( m_mode == Tag && c == ']' )
-            addPattern<TestSpec::TagPattern>();
-    }
-    void TestSpecParser::startNewMode( Mode mode, std::size_t start ) {
-        m_mode = mode;
-        m_start = start;
-    }
-    void TestSpecParser::escape() {
-        if( m_mode == None )
-            m_start = m_pos;
-        m_mode = EscapedName;
-        m_escapeChars.push_back( m_pos );
-    }
-    std::string TestSpecParser::subString() const { return m_arg.substr( m_start, m_pos - m_start ); }
-
-    void TestSpecParser::addFilter() {
-        if( !m_currentFilter.m_patterns.empty() ) {
-            m_testSpec.m_filters.push_back( m_currentFilter );
-            m_currentFilter = TestSpec::Filter();
-        }
-    }
-
-    TestSpec parseTestSpec( std::string const& arg ) {
-        return TestSpecParser( ITagAliasRegistry::get() ).parse( arg ).testSpec();
-    }
-
-} // namespace Catch
-// end catch_test_spec_parser.cpp
-// start catch_timer.cpp
-
-#include <chrono>
-
-static const uint64_t nanosecondsInSecond = 1000000000;
-
-namespace Catch {
-
-    auto getCurrentNanosecondsSinceEpoch() -> uint64_t {
-        return std::chrono::duration_cast<std::chrono::nanoseconds>( std::chrono::high_resolution_clock::now().time_since_epoch() ).count();
-    }
-
-    namespace {
-        auto estimateClockResolution() -> uint64_t {
-            uint64_t sum = 0;
-            static const uint64_t iterations = 1000000;
-
-            auto startTime = getCurrentNanosecondsSinceEpoch();
-
-            for( std::size_t i = 0; i < iterations; ++i ) {
-
-                uint64_t ticks;
-                uint64_t baseTicks = getCurrentNanosecondsSinceEpoch();
-                do {
-                    ticks = getCurrentNanosecondsSinceEpoch();
-                } while( ticks == baseTicks );
-
-                auto delta = ticks - baseTicks;
-                sum += delta;
-
-                // If we have been calibrating for over 3 seconds -- the clock
-                // is terrible and we should move on.
-                // TBD: How to signal that the measured resolution is probably wrong?
-                if (ticks > startTime + 3 * nanosecondsInSecond) {
-                    return sum / ( i + 1u );
-                }
-            }
-
-            // We're just taking the mean, here. To do better we could take the std. dev and exclude outliers
-            // - and potentially do more iterations if there's a high variance.
-            return sum/iterations;
-        }
-    }
-    auto getEstimatedClockResolution() -> uint64_t {
-        static auto s_resolution = estimateClockResolution();
-        return s_resolution;
-    }
-
-    void Timer::start() {
-       m_nanoseconds = getCurrentNanosecondsSinceEpoch();
-    }
-    auto Timer::getElapsedNanoseconds() const -> uint64_t {
-        return getCurrentNanosecondsSinceEpoch() - m_nanoseconds;
-    }
-    auto Timer::getElapsedMicroseconds() const -> uint64_t {
-        return getElapsedNanoseconds()/1000;
-    }
-    auto Timer::getElapsedMilliseconds() const -> unsigned int {
-        return static_cast<unsigned int>(getElapsedMicroseconds()/1000);
-    }
-    auto Timer::getElapsedSeconds() const -> double {
-        return getElapsedMicroseconds()/1000000.0;
-    }
-
-} // namespace Catch
-// end catch_timer.cpp
-// start catch_tostring.cpp
-
-#if defined(__clang__)
-#    pragma clang diagnostic push
-#    pragma clang diagnostic ignored "-Wexit-time-destructors"
-#    pragma clang diagnostic ignored "-Wglobal-constructors"
-#endif
-
-// Enable specific decls locally
-#if !defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)
-#define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
-#endif
-
-#include <cmath>
-#include <iomanip>
-
-namespace Catch {
-
-namespace Detail {
-
-    const std::string unprintableString = "{?}";
-
-    namespace {
-        const int hexThreshold = 255;
-
-        struct Endianness {
-            enum Arch { Big, Little };
-
-            static Arch which() {
-                union _{
-                    int asInt;
-                    char asChar[sizeof (int)];
-                } u;
-
-                u.asInt = 1;
-                return ( u.asChar[sizeof(int)-1] == 1 ) ? Big : Little;
-            }
-        };
-    }
-
-    std::string rawMemoryToString( const void *object, std::size_t size ) {
-        // Reverse order for little endian architectures
-        int i = 0, end = static_cast<int>( size ), inc = 1;
-        if( Endianness::which() == Endianness::Little ) {
-            i = end-1;
-            end = inc = -1;
-        }
-
-        unsigned char const *bytes = static_cast<unsigned char const *>(object);
-        ReusableStringStream rss;
-        rss << "0x" << std::setfill('0') << std::hex;
-        for( ; i != end; i += inc )
-             rss << std::setw(2) << static_cast<unsigned>(bytes[i]);
-       return rss.str();
-    }
-}
-
-template<typename T>
-std::string fpToString( T value, int precision ) {
-    if (Catch::isnan(value)) {
-        return "nan";
-    }
-
-    ReusableStringStream rss;
-    rss << std::setprecision( precision )
-        << std::fixed
-        << value;
-    std::string d = rss.str();
-    std::size_t i = d.find_last_not_of( '0' );
-    if( i != std::string::npos && i != d.size()-1 ) {
-        if( d[i] == '.' )
-            i++;
-        d = d.substr( 0, i+1 );
-    }
-    return d;
-}
-
-//// ======================================================= ////
-//
-//   Out-of-line defs for full specialization of StringMaker
-//
-//// ======================================================= ////
-
-std::string StringMaker<std::string>::convert(const std::string& str) {
-    if (!getCurrentContext().getConfig()->showInvisibles()) {
-        return '"' + str + '"';
-    }
-
-    std::string s("\"");
-    for (char c : str) {
-        switch (c) {
-        case '\n':
-            s.append("\\n");
-            break;
-        case '\t':
-            s.append("\\t");
-            break;
-        default:
-            s.push_back(c);
-            break;
-        }
-    }
-    s.append("\"");
-    return s;
-}
-
-#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
-std::string StringMaker<std::string_view>::convert(std::string_view str) {
-    return ::Catch::Detail::stringify(std::string{ str });
-}
-#endif
-
-std::string StringMaker<char const*>::convert(char const* str) {
-    if (str) {
-        return ::Catch::Detail::stringify(std::string{ str });
-    } else {
-        return{ "{null string}" };
-    }
-}
-std::string StringMaker<char*>::convert(char* str) {
-    if (str) {
-        return ::Catch::Detail::stringify(std::string{ str });
-    } else {
-        return{ "{null string}" };
-    }
-}
-
-#ifdef CATCH_CONFIG_WCHAR
-std::string StringMaker<std::wstring>::convert(const std::wstring& wstr) {
-    std::string s;
-    s.reserve(wstr.size());
-    for (auto c : wstr) {
-        s += (c <= 0xff) ? static_cast<char>(c) : '?';
-    }
-    return ::Catch::Detail::stringify(s);
-}
-
-# ifdef CATCH_CONFIG_CPP17_STRING_VIEW
-std::string StringMaker<std::wstring_view>::convert(std::wstring_view str) {
-    return StringMaker<std::wstring>::convert(std::wstring(str));
-}
-# endif
-
-std::string StringMaker<wchar_t const*>::convert(wchar_t const * str) {
-    if (str) {
-        return ::Catch::Detail::stringify(std::wstring{ str });
-    } else {
-        return{ "{null string}" };
-    }
-}
-std::string StringMaker<wchar_t *>::convert(wchar_t * str) {
-    if (str) {
-        return ::Catch::Detail::stringify(std::wstring{ str });
-    } else {
-        return{ "{null string}" };
-    }
-}
-#endif
-
-std::string StringMaker<int>::convert(int value) {
-    return ::Catch::Detail::stringify(static_cast<long long>(value));
-}
-std::string StringMaker<long>::convert(long value) {
-    return ::Catch::Detail::stringify(static_cast<long long>(value));
-}
-std::string StringMaker<long long>::convert(long long value) {
-    ReusableStringStream rss;
-    rss << value;
-    if (value > Detail::hexThreshold) {
-        rss << " (0x" << std::hex << value << ')';
-    }
-    return rss.str();
-}
-
-std::string StringMaker<unsigned int>::convert(unsigned int value) {
-    return ::Catch::Detail::stringify(static_cast<unsigned long long>(value));
-}
-std::string StringMaker<unsigned long>::convert(unsigned long value) {
-    return ::Catch::Detail::stringify(static_cast<unsigned long long>(value));
-}
-std::string StringMaker<unsigned long long>::convert(unsigned long long value) {
-    ReusableStringStream rss;
-    rss << value;
-    if (value > Detail::hexThreshold) {
-        rss << " (0x" << std::hex << value << ')';
-    }
-    return rss.str();
-}
-
-std::string StringMaker<bool>::convert(bool b) {
-    return b ? "true" : "false";
-}
-
-std::string StringMaker<signed char>::convert(signed char value) {
-    if (value == '\r') {
-        return "'\\r'";
-    } else if (value == '\f') {
-        return "'\\f'";
-    } else if (value == '\n') {
-        return "'\\n'";
-    } else if (value == '\t') {
-        return "'\\t'";
-    } else if ('\0' <= value && value < ' ') {
-        return ::Catch::Detail::stringify(static_cast<unsigned int>(value));
-    } else {
-        char chstr[] = "' '";
-        chstr[1] = value;
-        return chstr;
-    }
-}
-std::string StringMaker<char>::convert(char c) {
-    return ::Catch::Detail::stringify(static_cast<signed char>(c));
-}
-std::string StringMaker<unsigned char>::convert(unsigned char c) {
-    return ::Catch::Detail::stringify(static_cast<char>(c));
-}
-
-std::string StringMaker<std::nullptr_t>::convert(std::nullptr_t) {
-    return "nullptr";
-}
-
-int StringMaker<float>::precision = 5;
-
-std::string StringMaker<float>::convert(float value) {
-    return fpToString(value, precision) + 'f';
-}
-
-int StringMaker<double>::precision = 10;
-
-std::string StringMaker<double>::convert(double value) {
-    return fpToString(value, precision);
-}
-
-std::string ratio_string<std::atto>::symbol() { return "a"; }
-std::string ratio_string<std::femto>::symbol() { return "f"; }
-std::string ratio_string<std::pico>::symbol() { return "p"; }
-std::string ratio_string<std::nano>::symbol() { return "n"; }
-std::string ratio_string<std::micro>::symbol() { return "u"; }
-std::string ratio_string<std::milli>::symbol() { return "m"; }
-
-} // end namespace Catch
-
-#if defined(__clang__)
-#    pragma clang diagnostic pop
-#endif
-
-// end catch_tostring.cpp
-// start catch_totals.cpp
-
-namespace Catch {
-
-    Counts Counts::operator - ( Counts const& other ) const {
-        Counts diff;
-        diff.passed = passed - other.passed;
-        diff.failed = failed - other.failed;
-        diff.failedButOk = failedButOk - other.failedButOk;
-        return diff;
-    }
-
-    Counts& Counts::operator += ( Counts const& other ) {
-        passed += other.passed;
-        failed += other.failed;
-        failedButOk += other.failedButOk;
-        return *this;
-    }
-
-    std::size_t Counts::total() const {
-        return passed + failed + failedButOk;
-    }
-    bool Counts::allPassed() const {
-        return failed == 0 && failedButOk == 0;
-    }
-    bool Counts::allOk() const {
-        return failed == 0;
-    }
-
-    Totals Totals::operator - ( Totals const& other ) const {
-        Totals diff;
-        diff.assertions = assertions - other.assertions;
-        diff.testCases = testCases - other.testCases;
-        return diff;
-    }
-
-    Totals& Totals::operator += ( Totals const& other ) {
-        assertions += other.assertions;
-        testCases += other.testCases;
-        return *this;
-    }
-
-    Totals Totals::delta( Totals const& prevTotals ) const {
-        Totals diff = *this - prevTotals;
-        if( diff.assertions.failed > 0 )
-            ++diff.testCases.failed;
-        else if( diff.assertions.failedButOk > 0 )
-            ++diff.testCases.failedButOk;
-        else
-            ++diff.testCases.passed;
-        return diff;
-    }
-
-}
-// end catch_totals.cpp
-// start catch_uncaught_exceptions.cpp
-
-#include <exception>
-
-namespace Catch {
-    bool uncaught_exceptions() {
-#if defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
-        return std::uncaught_exceptions() > 0;
-#else
-        return std::uncaught_exception();
-#endif
-  }
-} // end namespace Catch
-// end catch_uncaught_exceptions.cpp
-// start catch_version.cpp
-
-#include <ostream>
-
-namespace Catch {
-
-    Version::Version
-        (   unsigned int _majorVersion,
-            unsigned int _minorVersion,
-            unsigned int _patchNumber,
-            char const * const _branchName,
-            unsigned int _buildNumber )
-    :   majorVersion( _majorVersion ),
-        minorVersion( _minorVersion ),
-        patchNumber( _patchNumber ),
-        branchName( _branchName ),
-        buildNumber( _buildNumber )
-    {}
-
-    std::ostream& operator << ( std::ostream& os, Version const& version ) {
-        os  << version.majorVersion << '.'
-            << version.minorVersion << '.'
-            << version.patchNumber;
-        // branchName is never null -> 0th char is \0 if it is empty
-        if (version.branchName[0]) {
-            os << '-' << version.branchName
-               << '.' << version.buildNumber;
-        }
-        return os;
-    }
-
-    Version const& libraryVersion() {
-        static Version version( 2, 9, 1, "", 0 );
-        return version;
-    }
-
-}
-// end catch_version.cpp
-// start catch_wildcard_pattern.cpp
-
-#include <sstream>
-
-namespace Catch {
-
-    WildcardPattern::WildcardPattern( std::string const& pattern,
-                                      CaseSensitive::Choice caseSensitivity )
-    :   m_caseSensitivity( caseSensitivity ),
-        m_pattern( adjustCase( pattern ) )
-    {
-        if( startsWith( m_pattern, '*' ) ) {
-            m_pattern = m_pattern.substr( 1 );
-            m_wildcard = WildcardAtStart;
-        }
-        if( endsWith( m_pattern, '*' ) ) {
-            m_pattern = m_pattern.substr( 0, m_pattern.size()-1 );
-            m_wildcard = static_cast<WildcardPosition>( m_wildcard | WildcardAtEnd );
-        }
-    }
-
-    bool WildcardPattern::matches( std::string const& str ) const {
-        switch( m_wildcard ) {
-            case NoWildcard:
-                return m_pattern == adjustCase( str );
-            case WildcardAtStart:
-                return endsWith( adjustCase( str ), m_pattern );
-            case WildcardAtEnd:
-                return startsWith( adjustCase( str ), m_pattern );
-            case WildcardAtBothEnds:
-                return contains( adjustCase( str ), m_pattern );
-            default:
-                CATCH_INTERNAL_ERROR( "Unknown enum" );
-        }
-    }
-
-    std::string WildcardPattern::adjustCase( std::string const& str ) const {
-        return m_caseSensitivity == CaseSensitive::No ? toLower( str ) : str;
-    }
-}
-// end catch_wildcard_pattern.cpp
-// start catch_xmlwriter.cpp
-
-#include <iomanip>
-
-using uchar = unsigned char;
-
-namespace Catch {
-
-namespace {
-
-    size_t trailingBytes(unsigned char c) {
-        if ((c & 0xE0) == 0xC0) {
-            return 2;
-        }
-        if ((c & 0xF0) == 0xE0) {
-            return 3;
-        }
-        if ((c & 0xF8) == 0xF0) {
-            return 4;
-        }
-        CATCH_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
-    }
-
-    uint32_t headerValue(unsigned char c) {
-        if ((c & 0xE0) == 0xC0) {
-            return c & 0x1F;
-        }
-        if ((c & 0xF0) == 0xE0) {
-            return c & 0x0F;
-        }
-        if ((c & 0xF8) == 0xF0) {
-            return c & 0x07;
-        }
-        CATCH_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
-    }
-
-    void hexEscapeChar(std::ostream& os, unsigned char c) {
-        std::ios_base::fmtflags f(os.flags());
-        os << "\\x"
-            << std::uppercase << std::hex << std::setfill('0') << std::setw(2)
-            << static_cast<int>(c);
-        os.flags(f);
-    }
-
-} // anonymous namespace
-
-    XmlEncode::XmlEncode( std::string const& str, ForWhat forWhat )
-    :   m_str( str ),
-        m_forWhat( forWhat )
-    {}
-
-    void XmlEncode::encodeTo( std::ostream& os ) const {
-        // Apostrophe escaping not necessary if we always use " to write attributes
-        // (see: http://www.w3.org/TR/xml/#syntax)
-
-        for( std::size_t idx = 0; idx < m_str.size(); ++ idx ) {
-            uchar c = m_str[idx];
-            switch (c) {
-            case '<':   os << "&lt;"; break;
-            case '&':   os << "&amp;"; break;
-
-            case '>':
-                // See: http://www.w3.org/TR/xml/#syntax
-                if (idx > 2 && m_str[idx - 1] == ']' && m_str[idx - 2] == ']')
-                    os << "&gt;";
-                else
-                    os << c;
-                break;
-
-            case '\"':
-                if (m_forWhat == ForAttributes)
-                    os << "&quot;";
-                else
-                    os << c;
-                break;
-
-            default:
-                // Check for control characters and invalid utf-8
-
-                // Escape control characters in standard ascii
-                // see http://stackoverflow.com/questions/404107/why-are-control-characters-illegal-in-xml-1-0
-                if (c < 0x09 || (c > 0x0D && c < 0x20) || c == 0x7F) {
-                    hexEscapeChar(os, c);
-                    break;
-                }
-
-                // Plain ASCII: Write it to stream
-                if (c < 0x7F) {
-                    os << c;
-                    break;
-                }
-
-                // UTF-8 territory
-                // Check if the encoding is valid and if it is not, hex escape bytes.
-                // Important: We do not check the exact decoded values for validity, only the encoding format
-                // First check that this bytes is a valid lead byte:
-                // This means that it is not encoded as 1111 1XXX
-                // Or as 10XX XXXX
-                if (c <  0xC0 ||
-                    c >= 0xF8) {
-                    hexEscapeChar(os, c);
-                    break;
-                }
-
-                auto encBytes = trailingBytes(c);
-                // Are there enough bytes left to avoid accessing out-of-bounds memory?
-                if (idx + encBytes - 1 >= m_str.size()) {
-                    hexEscapeChar(os, c);
-                    break;
-                }
-                // The header is valid, check data
-                // The next encBytes bytes must together be a valid utf-8
-                // This means: bitpattern 10XX XXXX and the extracted value is sane (ish)
-                bool valid = true;
-                uint32_t value = headerValue(c);
-                for (std::size_t n = 1; n < encBytes; ++n) {
-                    uchar nc = m_str[idx + n];
-                    valid &= ((nc & 0xC0) == 0x80);
-                    value = (value << 6) | (nc & 0x3F);
-                }
-
-                if (
-                    // Wrong bit pattern of following bytes
-                    (!valid) ||
-                    // Overlong encodings
-                    (value < 0x80) ||
-                    (0x80 <= value && value < 0x800   && encBytes > 2) ||
-                    (0x800 < value && value < 0x10000 && encBytes > 3) ||
-                    // Encoded value out of range
-                    (value >= 0x110000)
-                    ) {
-                    hexEscapeChar(os, c);
-                    break;
-                }
-
-                // If we got here, this is in fact a valid(ish) utf-8 sequence
-                for (std::size_t n = 0; n < encBytes; ++n) {
-                    os << m_str[idx + n];
-                }
-                idx += encBytes - 1;
-                break;
-            }
-        }
-    }
-
-    std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode ) {
-        xmlEncode.encodeTo( os );
-        return os;
-    }
-
-    XmlWriter::ScopedElement::ScopedElement( XmlWriter* writer )
-    :   m_writer( writer )
-    {}
-
-    XmlWriter::ScopedElement::ScopedElement( ScopedElement&& other ) noexcept
-    :   m_writer( other.m_writer ){
-        other.m_writer = nullptr;
-    }
-    XmlWriter::ScopedElement& XmlWriter::ScopedElement::operator=( ScopedElement&& other ) noexcept {
-        if ( m_writer ) {
-            m_writer->endElement();
-        }
-        m_writer = other.m_writer;
-        other.m_writer = nullptr;
-        return *this;
-    }
-
-    XmlWriter::ScopedElement::~ScopedElement() {
-        if( m_writer )
-            m_writer->endElement();
-    }
-
-    XmlWriter::ScopedElement& XmlWriter::ScopedElement::writeText( std::string const& text, bool indent ) {
-        m_writer->writeText( text, indent );
-        return *this;
-    }
-
-    XmlWriter::XmlWriter( std::ostream& os ) : m_os( os )
-    {
-        writeDeclaration();
-    }
-
-    XmlWriter::~XmlWriter() {
-        while( !m_tags.empty() )
-            endElement();
-    }
-
-    XmlWriter& XmlWriter::startElement( std::string const& name ) {
-        ensureTagClosed();
-        newlineIfNecessary();
-        m_os << m_indent << '<' << name;
-        m_tags.push_back( name );
-        m_indent += "  ";
-        m_tagIsOpen = true;
-        return *this;
-    }
-
-    XmlWriter::ScopedElement XmlWriter::scopedElement( std::string const& name ) {
-        ScopedElement scoped( this );
-        startElement( name );
-        return scoped;
-    }
-
-    XmlWriter& XmlWriter::endElement() {
-        newlineIfNecessary();
-        m_indent = m_indent.substr( 0, m_indent.size()-2 );
-        if( m_tagIsOpen ) {
-            m_os << "/>";
-            m_tagIsOpen = false;
-        }
-        else {
-            m_os << m_indent << "</" << m_tags.back() << ">";
-        }
-        m_os << std::endl;
-        m_tags.pop_back();
-        return *this;
-    }
-
-    XmlWriter& XmlWriter::writeAttribute( std::string const& name, std::string const& attribute ) {
-        if( !name.empty() && !attribute.empty() )
-            m_os << ' ' << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << '"';
-        return *this;
-    }
-
-    XmlWriter& XmlWriter::writeAttribute( std::string const& name, bool attribute ) {
-        m_os << ' ' << name << "=\"" << ( attribute ? "true" : "false" ) << '"';
-        return *this;
-    }
-
-    XmlWriter& XmlWriter::writeText( std::string const& text, bool indent ) {
-        if( !text.empty() ){
-            bool tagWasOpen = m_tagIsOpen;
-            ensureTagClosed();
-            if( tagWasOpen && indent )
-                m_os << m_indent;
-            m_os << XmlEncode( text );
-            m_needsNewline = true;
-        }
-        return *this;
-    }
-
-    XmlWriter& XmlWriter::writeComment( std::string const& text ) {
-        ensureTagClosed();
-        m_os << m_indent << "<!--" << text << "-->";
-        m_needsNewline = true;
-        return *this;
-    }
-
-    void XmlWriter::writeStylesheetRef( std::string const& url ) {
-        m_os << "<?xml-stylesheet type=\"text/xsl\" href=\"" << url << "\"?>\n";
-    }
-
-    XmlWriter& XmlWriter::writeBlankLine() {
-        ensureTagClosed();
-        m_os << '\n';
-        return *this;
-    }
-
-    void XmlWriter::ensureTagClosed() {
-        if( m_tagIsOpen ) {
-            m_os << ">" << std::endl;
-            m_tagIsOpen = false;
-        }
-    }
-
-    void XmlWriter::writeDeclaration() {
-        m_os << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
-    }
-
-    void XmlWriter::newlineIfNecessary() {
-        if( m_needsNewline ) {
-            m_os << std::endl;
-            m_needsNewline = false;
-        }
-    }
-}
-// end catch_xmlwriter.cpp
-// start catch_reporter_bases.cpp
-
-#include <cstring>
-#include <cfloat>
-#include <cstdio>
-#include <cassert>
-#include <memory>
-
-namespace Catch {
-    void prepareExpandedExpression(AssertionResult& result) {
-        result.getExpandedExpression();
-    }
-
-    // Because formatting using c++ streams is stateful, drop down to C is required
-    // Alternatively we could use stringstream, but its performance is... not good.
-    std::string getFormattedDuration( double duration ) {
-        // Max exponent + 1 is required to represent the whole part
-        // + 1 for decimal point
-        // + 3 for the 3 decimal places
-        // + 1 for null terminator
-        const std::size_t maxDoubleSize = DBL_MAX_10_EXP + 1 + 1 + 3 + 1;
-        char buffer[maxDoubleSize];
-
-        // Save previous errno, to prevent sprintf from overwriting it
-        ErrnoGuard guard;
-#ifdef _MSC_VER
-        sprintf_s(buffer, "%.3f", duration);
-#else
-        std::sprintf(buffer, "%.3f", duration);
-#endif
-        return std::string(buffer);
-    }
-
-    std::string serializeFilters( std::vector<std::string> const& container ) {
-        ReusableStringStream oss;
-        bool first = true;
-        for (auto&& filter : container)
-        {
-            if (!first)
-                oss << ' ';
-            else
-                first = false;
-
-            oss << filter;
-        }
-        return oss.str();
-    }
-
-    TestEventListenerBase::TestEventListenerBase(ReporterConfig const & _config)
-        :StreamingReporterBase(_config) {}
-
-    std::set<Verbosity> TestEventListenerBase::getSupportedVerbosities() {
-        return { Verbosity::Quiet, Verbosity::Normal, Verbosity::High };
-    }
-
-    void TestEventListenerBase::assertionStarting(AssertionInfo const &) {}
-
-    bool TestEventListenerBase::assertionEnded(AssertionStats const &) {
-        return false;
-    }
-
-} // end namespace Catch
-// end catch_reporter_bases.cpp
-// start catch_reporter_compact.cpp
-
-namespace {
-
-#ifdef CATCH_PLATFORM_MAC
-    const char* failedString() { return "FAILED"; }
-    const char* passedString() { return "PASSED"; }
-#else
-    const char* failedString() { return "failed"; }
-    const char* passedString() { return "passed"; }
-#endif
-
-    // Colour::LightGrey
-    Catch::Colour::Code dimColour() { return Catch::Colour::FileName; }
-
-    std::string bothOrAll( std::size_t count ) {
-        return count == 1 ? std::string() :
-               count == 2 ? "both " : "all " ;
-    }
-
-} // anon namespace
-
-namespace Catch {
-namespace {
-// Colour, message variants:
-// - white: No tests ran.
-// -   red: Failed [both/all] N test cases, failed [both/all] M assertions.
-// - white: Passed [both/all] N test cases (no assertions).
-// -   red: Failed N tests cases, failed M assertions.
-// - green: Passed [both/all] N tests cases with M assertions.
-void printTotals(std::ostream& out, const Totals& totals) {
-    if (totals.testCases.total() == 0) {
-        out << "No tests ran.";
-    } else if (totals.testCases.failed == totals.testCases.total()) {
-        Colour colour(Colour::ResultError);
-        const std::string qualify_assertions_failed =
-            totals.assertions.failed == totals.assertions.total() ?
-            bothOrAll(totals.assertions.failed) : std::string();
-        out <<
-            "Failed " << bothOrAll(totals.testCases.failed)
-            << pluralise(totals.testCases.failed, "test case") << ", "
-            "failed " << qualify_assertions_failed <<
-            pluralise(totals.assertions.failed, "assertion") << '.';
-    } else if (totals.assertions.total() == 0) {
-        out <<
-            "Passed " << bothOrAll(totals.testCases.total())
-            << pluralise(totals.testCases.total(), "test case")
-            << " (no assertions).";
-    } else if (totals.assertions.failed) {
-        Colour colour(Colour::ResultError);
-        out <<
-            "Failed " << pluralise(totals.testCases.failed, "test case") << ", "
-            "failed " << pluralise(totals.assertions.failed, "assertion") << '.';
-    } else {
-        Colour colour(Colour::ResultSuccess);
-        out <<
-            "Passed " << bothOrAll(totals.testCases.passed)
-            << pluralise(totals.testCases.passed, "test case") <<
-            " with " << pluralise(totals.assertions.passed, "assertion") << '.';
-    }
-}
-
-// Implementation of CompactReporter formatting
-class AssertionPrinter {
-public:
-    AssertionPrinter& operator= (AssertionPrinter const&) = delete;
-    AssertionPrinter(AssertionPrinter const&) = delete;
-    AssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages)
-        : stream(_stream)
-        , result(_stats.assertionResult)
-        , messages(_stats.infoMessages)
-        , itMessage(_stats.infoMessages.begin())
-        , printInfoMessages(_printInfoMessages) {}
-
-    void print() {
-        printSourceInfo();
-
-        itMessage = messages.begin();
-
-        switch (result.getResultType()) {
-        case ResultWas::Ok:
-            printResultType(Colour::ResultSuccess, passedString());
-            printOriginalExpression();
-            printReconstructedExpression();
-            if (!result.hasExpression())
-                printRemainingMessages(Colour::None);
-            else
-                printRemainingMessages();
-            break;
-        case ResultWas::ExpressionFailed:
-            if (result.isOk())
-                printResultType(Colour::ResultSuccess, failedString() + std::string(" - but was ok"));
-            else
-                printResultType(Colour::Error, failedString());
-            printOriginalExpression();
-            printReconstructedExpression();
-            printRemainingMessages();
-            break;
-        case ResultWas::ThrewException:
-            printResultType(Colour::Error, failedString());
-            printIssue("unexpected exception with message:");
-            printMessage();
-            printExpressionWas();
-            printRemainingMessages();
-            break;
-        case ResultWas::FatalErrorCondition:
-            printResultType(Colour::Error, failedString());
-            printIssue("fatal error condition with message:");
-            printMessage();
-            printExpressionWas();
-            printRemainingMessages();
-            break;
-        case ResultWas::DidntThrowException:
-            printResultType(Colour::Error, failedString());
-            printIssue("expected exception, got none");
-            printExpressionWas();
-            printRemainingMessages();
-            break;
-        case ResultWas::Info:
-            printResultType(Colour::None, "info");
-            printMessage();
-            printRemainingMessages();
-            break;
-        case ResultWas::Warning:
-            printResultType(Colour::None, "warning");
-            printMessage();
-            printRemainingMessages();
-            break;
-        case ResultWas::ExplicitFailure:
-            printResultType(Colour::Error, failedString());
-            printIssue("explicitly");
-            printRemainingMessages(Colour::None);
-            break;
-            // These cases are here to prevent compiler warnings
-        case ResultWas::Unknown:
-        case ResultWas::FailureBit:
-        case ResultWas::Exception:
-            printResultType(Colour::Error, "** internal error **");
-            break;
-        }
-    }
-
-private:
-    void printSourceInfo() const {
-        Colour colourGuard(Colour::FileName);
-        stream << result.getSourceInfo() << ':';
-    }
-
-    void printResultType(Colour::Code colour, std::string const& passOrFail) const {
-        if (!passOrFail.empty()) {
-            {
-                Colour colourGuard(colour);
-                stream << ' ' << passOrFail;
-            }
-            stream << ':';
-        }
-    }
-
-    void printIssue(std::string const& issue) const {
-        stream << ' ' << issue;
-    }
-
-    void printExpressionWas() {
-        if (result.hasExpression()) {
-            stream << ';';
-            {
-                Colour colour(dimColour());
-                stream << " expression was:";
-            }
-            printOriginalExpression();
-        }
-    }
-
-    void printOriginalExpression() const {
-        if (result.hasExpression()) {
-            stream << ' ' << result.getExpression();
-        }
-    }
-
-    void printReconstructedExpression() const {
-        if (result.hasExpandedExpression()) {
-            {
-                Colour colour(dimColour());
-                stream << " for: ";
-            }
-            stream << result.getExpandedExpression();
-        }
-    }
-
-    void printMessage() {
-        if (itMessage != messages.end()) {
-            stream << " '" << itMessage->message << '\'';
-            ++itMessage;
-        }
-    }
-
-    void printRemainingMessages(Colour::Code colour = dimColour()) {
-        if (itMessage == messages.end())
-            return;
-
-        // using messages.end() directly yields (or auto) compilation error:
-        std::vector<MessageInfo>::const_iterator itEnd = messages.end();
-        const std::size_t N = static_cast<std::size_t>(std::distance(itMessage, itEnd));
-
-        {
-            Colour colourGuard(colour);
-            stream << " with " << pluralise(N, "message") << ':';
-        }
-
-        for (; itMessage != itEnd; ) {
-            // If this assertion is a warning ignore any INFO messages
-            if (printInfoMessages || itMessage->type != ResultWas::Info) {
-                stream << " '" << itMessage->message << '\'';
-                if (++itMessage != itEnd) {
-                    Colour colourGuard(dimColour());
-                    stream << " and";
-                }
-            }
-        }
-    }
-
-private:
-    std::ostream& stream;
-    AssertionResult const& result;
-    std::vector<MessageInfo> messages;
-    std::vector<MessageInfo>::const_iterator itMessage;
-    bool printInfoMessages;
-};
-
-} // anon namespace
-
-        std::string CompactReporter::getDescription() {
-            return "Reports test results on a single line, suitable for IDEs";
-        }
-
-        ReporterPreferences CompactReporter::getPreferences() const {
-            return m_reporterPrefs;
-        }
-
-        void CompactReporter::noMatchingTestCases( std::string const& spec ) {
-            stream << "No test cases matched '" << spec << '\'' << std::endl;
-        }
-
-        void CompactReporter::assertionStarting( AssertionInfo const& ) {}
-
-        bool CompactReporter::assertionEnded( AssertionStats const& _assertionStats ) {
-            AssertionResult const& result = _assertionStats.assertionResult;
-
-            bool printInfoMessages = true;
-
-            // Drop out if result was successful and we're not printing those
-            if( !m_config->includeSuccessfulResults() && result.isOk() ) {
-                if( result.getResultType() != ResultWas::Warning )
-                    return false;
-                printInfoMessages = false;
-            }
-
-            AssertionPrinter printer( stream, _assertionStats, printInfoMessages );
-            printer.print();
-
-            stream << std::endl;
-            return true;
-        }
-
-        void CompactReporter::sectionEnded(SectionStats const& _sectionStats) {
-            if (m_config->showDurations() == ShowDurations::Always) {
-                stream << getFormattedDuration(_sectionStats.durationInSeconds) << " s: " << _sectionStats.sectionInfo.name << std::endl;
-            }
-        }
-
-        void CompactReporter::testRunEnded( TestRunStats const& _testRunStats ) {
-            printTotals( stream, _testRunStats.totals );
-            stream << '\n' << std::endl;
-            StreamingReporterBase::testRunEnded( _testRunStats );
-        }
-
-        CompactReporter::~CompactReporter() {}
-
-    CATCH_REGISTER_REPORTER( "compact", CompactReporter )
-
-} // end namespace Catch
-// end catch_reporter_compact.cpp
-// start catch_reporter_console.cpp
-
-#include <cfloat>
-#include <cstdio>
-
-#if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
- // Note that 4062 (not all labels are handled and default is missing) is enabled
-#endif
-
-#if defined(__clang__)
-#  pragma clang diagnostic push
-// For simplicity, benchmarking-only helpers are always enabled
-#  pragma clang diagnostic ignored "-Wunused-function"
-#endif
-
-namespace Catch {
-
-namespace {
-
-// Formatter impl for ConsoleReporter
-class ConsoleAssertionPrinter {
-public:
-    ConsoleAssertionPrinter& operator= (ConsoleAssertionPrinter const&) = delete;
-    ConsoleAssertionPrinter(ConsoleAssertionPrinter const&) = delete;
-    ConsoleAssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages)
-        : stream(_stream),
-        stats(_stats),
-        result(_stats.assertionResult),
-        colour(Colour::None),
-        message(result.getMessage()),
-        messages(_stats.infoMessages),
-        printInfoMessages(_printInfoMessages) {
-        switch (result.getResultType()) {
-        case ResultWas::Ok:
-            colour = Colour::Success;
-            passOrFail = "PASSED";
-            //if( result.hasMessage() )
-            if (_stats.infoMessages.size() == 1)
-                messageLabel = "with message";
-            if (_stats.infoMessages.size() > 1)
-                messageLabel = "with messages";
-            break;
-        case ResultWas::ExpressionFailed:
-            if (result.isOk()) {
-                colour = Colour::Success;
-                passOrFail = "FAILED - but was ok";
-            } else {
-                colour = Colour::Error;
-                passOrFail = "FAILED";
-            }
-            if (_stats.infoMessages.size() == 1)
-                messageLabel = "with message";
-            if (_stats.infoMessages.size() > 1)
-                messageLabel = "with messages";
-            break;
-        case ResultWas::ThrewException:
-            colour = Colour::Error;
-            passOrFail = "FAILED";
-            messageLabel = "due to unexpected exception with ";
-            if (_stats.infoMessages.size() == 1)
-                messageLabel += "message";
-            if (_stats.infoMessages.size() > 1)
-                messageLabel += "messages";
-            break;
-        case ResultWas::FatalErrorCondition:
-            colour = Colour::Error;
-            passOrFail = "FAILED";
-            messageLabel = "due to a fatal error condition";
-            break;
-        case ResultWas::DidntThrowException:
-            colour = Colour::Error;
-            passOrFail = "FAILED";
-            messageLabel = "because no exception was thrown where one was expected";
-            break;
-        case ResultWas::Info:
-            messageLabel = "info";
-            break;
-        case ResultWas::Warning:
-            messageLabel = "warning";
-            break;
-        case ResultWas::ExplicitFailure:
-            passOrFail = "FAILED";
-            colour = Colour::Error;
-            if (_stats.infoMessages.size() == 1)
-                messageLabel = "explicitly with message";
-            if (_stats.infoMessages.size() > 1)
-                messageLabel = "explicitly with messages";
-            break;
-            // These cases are here to prevent compiler warnings
-        case ResultWas::Unknown:
-        case ResultWas::FailureBit:
-        case ResultWas::Exception:
-            passOrFail = "** internal error **";
-            colour = Colour::Error;
-            break;
-        }
-    }
-
-    void print() const {
-        printSourceInfo();
-        if (stats.totals.assertions.total() > 0) {
-            printResultType();
-            printOriginalExpression();
-            printReconstructedExpression();
-        } else {
-            stream << '\n';
-        }
-        printMessage();
-    }
-
-private:
-    void printResultType() const {
-        if (!passOrFail.empty()) {
-            Colour colourGuard(colour);
-            stream << passOrFail << ":\n";
-        }
-    }
-    void printOriginalExpression() const {
-        if (result.hasExpression()) {
-            Colour colourGuard(Colour::OriginalExpression);
-            stream << "  ";
-            stream << result.getExpressionInMacro();
-            stream << '\n';
-        }
-    }
-    void printReconstructedExpression() const {
-        if (result.hasExpandedExpression()) {
-            stream << "with expansion:\n";
-            Colour colourGuard(Colour::ReconstructedExpression);
-            stream << Column(result.getExpandedExpression()).indent(2) << '\n';
-        }
-    }
-    void printMessage() const {
-        if (!messageLabel.empty())
-            stream << messageLabel << ':' << '\n';
-        for (auto const& msg : messages) {
-            // If this assertion is a warning ignore any INFO messages
-            if (printInfoMessages || msg.type != ResultWas::Info)
-                stream << Column(msg.message).indent(2) << '\n';
-        }
-    }
-    void printSourceInfo() const {
-        Colour colourGuard(Colour::FileName);
-        stream << result.getSourceInfo() << ": ";
-    }
-
-    std::ostream& stream;
-    AssertionStats const& stats;
-    AssertionResult const& result;
-    Colour::Code colour;
-    std::string passOrFail;
-    std::string messageLabel;
-    std::string message;
-    std::vector<MessageInfo> messages;
-    bool printInfoMessages;
-};
-
-std::size_t makeRatio(std::size_t number, std::size_t total) {
-    std::size_t ratio = total > 0 ? CATCH_CONFIG_CONSOLE_WIDTH * number / total : 0;
-    return (ratio == 0 && number > 0) ? 1 : ratio;
-}
-
-std::size_t& findMax(std::size_t& i, std::size_t& j, std::size_t& k) {
-    if (i > j && i > k)
-        return i;
-    else if (j > k)
-        return j;
-    else
-        return k;
-}
-
-struct ColumnInfo {
-    enum Justification { Left, Right };
-    std::string name;
-    int width;
-    Justification justification;
-};
-struct ColumnBreak {};
-struct RowBreak {};
-
-class Duration {
-    enum class Unit {
-        Auto,
-        Nanoseconds,
-        Microseconds,
-        Milliseconds,
-        Seconds,
-        Minutes
-    };
-    static const uint64_t s_nanosecondsInAMicrosecond = 1000;
-    static const uint64_t s_nanosecondsInAMillisecond = 1000 * s_nanosecondsInAMicrosecond;
-    static const uint64_t s_nanosecondsInASecond = 1000 * s_nanosecondsInAMillisecond;
-    static const uint64_t s_nanosecondsInAMinute = 60 * s_nanosecondsInASecond;
-
-    uint64_t m_inNanoseconds;
-    Unit m_units;
-
-public:
-	explicit Duration(double inNanoseconds, Unit units = Unit::Auto)
-        : Duration(static_cast<uint64_t>(inNanoseconds), units) {
-    }
-
-    explicit Duration(uint64_t inNanoseconds, Unit units = Unit::Auto)
-        : m_inNanoseconds(inNanoseconds),
-        m_units(units) {
-        if (m_units == Unit::Auto) {
-            if (m_inNanoseconds < s_nanosecondsInAMicrosecond)
-                m_units = Unit::Nanoseconds;
-            else if (m_inNanoseconds < s_nanosecondsInAMillisecond)
-                m_units = Unit::Microseconds;
-            else if (m_inNanoseconds < s_nanosecondsInASecond)
-                m_units = Unit::Milliseconds;
-            else if (m_inNanoseconds < s_nanosecondsInAMinute)
-                m_units = Unit::Seconds;
-            else
-                m_units = Unit::Minutes;
-        }
-
-    }
-
-    auto value() const -> double {
-        switch (m_units) {
-        case Unit::Microseconds:
-            return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMicrosecond);
-        case Unit::Milliseconds:
-            return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMillisecond);
-        case Unit::Seconds:
-            return m_inNanoseconds / static_cast<double>(s_nanosecondsInASecond);
-        case Unit::Minutes:
-            return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMinute);
-        default:
-            return static_cast<double>(m_inNanoseconds);
-        }
-    }
-    auto unitsAsString() const -> std::string {
-        switch (m_units) {
-        case Unit::Nanoseconds:
-            return "ns";
-        case Unit::Microseconds:
-            return "us";
-        case Unit::Milliseconds:
-            return "ms";
-        case Unit::Seconds:
-            return "s";
-        case Unit::Minutes:
-            return "m";
-        default:
-            return "** internal error **";
-        }
-
-    }
-    friend auto operator << (std::ostream& os, Duration const& duration) -> std::ostream& {
-        return os << duration.value() << " " << duration.unitsAsString();
-    }
-};
-} // end anon namespace
-
-class TablePrinter {
-    std::ostream& m_os;
-    std::vector<ColumnInfo> m_columnInfos;
-    std::ostringstream m_oss;
-    int m_currentColumn = -1;
-    bool m_isOpen = false;
-
-public:
-    TablePrinter( std::ostream& os, std::vector<ColumnInfo> columnInfos )
-    :   m_os( os ),
-        m_columnInfos( std::move( columnInfos ) ) {}
-
-    auto columnInfos() const -> std::vector<ColumnInfo> const& {
-        return m_columnInfos;
-    }
-
-    void open() {
-        if (!m_isOpen) {
-            m_isOpen = true;
-            *this << RowBreak();
-
-			Columns headerCols;
-			Spacer spacer(2);
-			for (auto const& info : m_columnInfos) {
-				headerCols += Column(info.name).width(static_cast<std::size_t>(info.width - 2));
-				headerCols += spacer;
-			}
-			m_os << headerCols << "\n";
-
-            m_os << Catch::getLineOfChars<'-'>() << "\n";
-        }
-    }
-    void close() {
-        if (m_isOpen) {
-            *this << RowBreak();
-            m_os << std::endl;
-            m_isOpen = false;
-        }
-    }
-
-    template<typename T>
-    friend TablePrinter& operator << (TablePrinter& tp, T const& value) {
-        tp.m_oss << value;
-        return tp;
-    }
-
-    friend TablePrinter& operator << (TablePrinter& tp, ColumnBreak) {
-        auto colStr = tp.m_oss.str();
-        // This takes account of utf8 encodings
-        auto strSize = Catch::StringRef(colStr).numberOfCharacters();
-        tp.m_oss.str("");
-        tp.open();
-        if (tp.m_currentColumn == static_cast<int>(tp.m_columnInfos.size() - 1)) {
-            tp.m_currentColumn = -1;
-            tp.m_os << "\n";
-        }
-        tp.m_currentColumn++;
-
-        auto colInfo = tp.m_columnInfos[tp.m_currentColumn];
-        auto padding = (strSize + 2 < static_cast<std::size_t>(colInfo.width))
-            ? std::string(colInfo.width - (strSize + 2), ' ')
-            : std::string();
-        if (colInfo.justification == ColumnInfo::Left)
-            tp.m_os << colStr << padding << " ";
-        else
-            tp.m_os << padding << colStr << " ";
-        return tp;
-    }
-
-    friend TablePrinter& operator << (TablePrinter& tp, RowBreak) {
-        if (tp.m_currentColumn > 0) {
-            tp.m_os << "\n";
-            tp.m_currentColumn = -1;
-        }
-        return tp;
-    }
-};
-
-ConsoleReporter::ConsoleReporter(ReporterConfig const& config)
-    : StreamingReporterBase(config),
-    m_tablePrinter(new TablePrinter(config.stream(),
-    {
-        { "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 32, ColumnInfo::Left },
-        { "samples      mean       std dev", 14, ColumnInfo::Right },
-        { "iterations   low mean   low std dev", 14, ColumnInfo::Right },
-        { "estimated    high mean  high std dev", 14, ColumnInfo::Right }
-    })) {}
-ConsoleReporter::~ConsoleReporter() = default;
-
-std::string ConsoleReporter::getDescription() {
-    return "Reports test results as plain lines of text";
-}
-
-void ConsoleReporter::noMatchingTestCases(std::string const& spec) {
-    stream << "No test cases matched '" << spec << '\'' << std::endl;
-}
-
-void ConsoleReporter::assertionStarting(AssertionInfo const&) {}
-
-bool ConsoleReporter::assertionEnded(AssertionStats const& _assertionStats) {
-    AssertionResult const& result = _assertionStats.assertionResult;
-
-    bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
-
-    // Drop out if result was successful but we're not printing them.
-    if (!includeResults && result.getResultType() != ResultWas::Warning)
-        return false;
-
-    lazyPrint();
-
-    ConsoleAssertionPrinter printer(stream, _assertionStats, includeResults);
-    printer.print();
-    stream << std::endl;
-    return true;
-}
-
-void ConsoleReporter::sectionStarting(SectionInfo const& _sectionInfo) {
-    m_tablePrinter->close();
-    m_headerPrinted = false;
-    StreamingReporterBase::sectionStarting(_sectionInfo);
-}
-void ConsoleReporter::sectionEnded(SectionStats const& _sectionStats) {
-    m_tablePrinter->close();
-    if (_sectionStats.missingAssertions) {
-        lazyPrint();
-        Colour colour(Colour::ResultError);
-        if (m_sectionStack.size() > 1)
-            stream << "\nNo assertions in section";
-        else
-            stream << "\nNo assertions in test case";
-        stream << " '" << _sectionStats.sectionInfo.name << "'\n" << std::endl;
-    }
-    if (m_config->showDurations() == ShowDurations::Always) {
-        stream << getFormattedDuration(_sectionStats.durationInSeconds) << " s: " << _sectionStats.sectionInfo.name << std::endl;
-    }
-    if (m_headerPrinted) {
-        m_headerPrinted = false;
-    }
-    StreamingReporterBase::sectionEnded(_sectionStats);
-}
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-void ConsoleReporter::benchmarkPreparing(std::string const& name) {
-	lazyPrintWithoutClosingBenchmarkTable();
-
-	auto nameCol = Column(name).width(static_cast<std::size_t>(m_tablePrinter->columnInfos()[0].width - 2));
-
-	bool firstLine = true;
-	for (auto line : nameCol) {
-		if (!firstLine)
-			(*m_tablePrinter) << ColumnBreak() << ColumnBreak() << ColumnBreak();
-		else
-			firstLine = false;
-
-		(*m_tablePrinter) << line << ColumnBreak();
-	}
-}
-
-void ConsoleReporter::benchmarkStarting(BenchmarkInfo const& info) {
-	(*m_tablePrinter) << info.samples << ColumnBreak()
-		<< info.iterations << ColumnBreak()
-		<< Duration(info.estimatedDuration) << ColumnBreak();
-}
-void ConsoleReporter::benchmarkEnded(BenchmarkStats<> const& stats) {
-	(*m_tablePrinter) << ColumnBreak()
-		<< Duration(stats.mean.point.count()) << ColumnBreak()
-		<< Duration(stats.mean.lower_bound.count()) << ColumnBreak()
-		<< Duration(stats.mean.upper_bound.count()) << ColumnBreak() << ColumnBreak()
-		<< Duration(stats.standardDeviation.point.count()) << ColumnBreak()
-		<< Duration(stats.standardDeviation.lower_bound.count()) << ColumnBreak()
-		<< Duration(stats.standardDeviation.upper_bound.count()) << ColumnBreak() << ColumnBreak() << ColumnBreak() << ColumnBreak() << ColumnBreak();
-}
-
-void ConsoleReporter::benchmarkFailed(std::string const& error) {
-	Colour colour(Colour::Red);
-    (*m_tablePrinter)
-        << "Benchmark failed (" << error << ")"
-        << ColumnBreak() << RowBreak();
-}
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-void ConsoleReporter::testCaseEnded(TestCaseStats const& _testCaseStats) {
-    m_tablePrinter->close();
-    StreamingReporterBase::testCaseEnded(_testCaseStats);
-    m_headerPrinted = false;
-}
-void ConsoleReporter::testGroupEnded(TestGroupStats const& _testGroupStats) {
-    if (currentGroupInfo.used) {
-        printSummaryDivider();
-        stream << "Summary for group '" << _testGroupStats.groupInfo.name << "':\n";
-        printTotals(_testGroupStats.totals);
-        stream << '\n' << std::endl;
-    }
-    StreamingReporterBase::testGroupEnded(_testGroupStats);
-}
-void ConsoleReporter::testRunEnded(TestRunStats const& _testRunStats) {
-    printTotalsDivider(_testRunStats.totals);
-    printTotals(_testRunStats.totals);
-    stream << std::endl;
-    StreamingReporterBase::testRunEnded(_testRunStats);
-}
-void ConsoleReporter::testRunStarting(TestRunInfo const& _testInfo) {
-    StreamingReporterBase::testRunStarting(_testInfo);
-    printTestFilters();
-}
-
-void ConsoleReporter::lazyPrint() {
-
-    m_tablePrinter->close();
-    lazyPrintWithoutClosingBenchmarkTable();
-}
-
-void ConsoleReporter::lazyPrintWithoutClosingBenchmarkTable() {
-
-    if (!currentTestRunInfo.used)
-        lazyPrintRunInfo();
-    if (!currentGroupInfo.used)
-        lazyPrintGroupInfo();
-
-    if (!m_headerPrinted) {
-        printTestCaseAndSectionHeader();
-        m_headerPrinted = true;
-    }
-}
-void ConsoleReporter::lazyPrintRunInfo() {
-    stream << '\n' << getLineOfChars<'~'>() << '\n';
-    Colour colour(Colour::SecondaryText);
-    stream << currentTestRunInfo->name
-        << " is a Catch v" << libraryVersion() << " host application.\n"
-        << "Run with -? for options\n\n";
-
-    if (m_config->rngSeed() != 0)
-        stream << "Randomness seeded to: " << m_config->rngSeed() << "\n\n";
-
-    currentTestRunInfo.used = true;
-}
-void ConsoleReporter::lazyPrintGroupInfo() {
-    if (!currentGroupInfo->name.empty() && currentGroupInfo->groupsCounts > 1) {
-        printClosedHeader("Group: " + currentGroupInfo->name);
-        currentGroupInfo.used = true;
-    }
-}
-void ConsoleReporter::printTestCaseAndSectionHeader() {
-    assert(!m_sectionStack.empty());
-    printOpenHeader(currentTestCaseInfo->name);
-
-    if (m_sectionStack.size() > 1) {
-        Colour colourGuard(Colour::Headers);
-
-        auto
-            it = m_sectionStack.begin() + 1, // Skip first section (test case)
-            itEnd = m_sectionStack.end();
-        for (; it != itEnd; ++it)
-            printHeaderString(it->name, 2);
-    }
-
-    SourceLineInfo lineInfo = m_sectionStack.back().lineInfo;
-
-    if (!lineInfo.empty()) {
-        stream << getLineOfChars<'-'>() << '\n';
-        Colour colourGuard(Colour::FileName);
-        stream << lineInfo << '\n';
-    }
-    stream << getLineOfChars<'.'>() << '\n' << std::endl;
-}
-
-void ConsoleReporter::printClosedHeader(std::string const& _name) {
-    printOpenHeader(_name);
-    stream << getLineOfChars<'.'>() << '\n';
-}
-void ConsoleReporter::printOpenHeader(std::string const& _name) {
-    stream << getLineOfChars<'-'>() << '\n';
-    {
-        Colour colourGuard(Colour::Headers);
-        printHeaderString(_name);
-    }
-}
-
-// if string has a : in first line will set indent to follow it on
-// subsequent lines
-void ConsoleReporter::printHeaderString(std::string const& _string, std::size_t indent) {
-    std::size_t i = _string.find(": ");
-    if (i != std::string::npos)
-        i += 2;
-    else
-        i = 0;
-    stream << Column(_string).indent(indent + i).initialIndent(indent) << '\n';
-}
-
-struct SummaryColumn {
-
-    SummaryColumn( std::string _label, Colour::Code _colour )
-    :   label( std::move( _label ) ),
-        colour( _colour ) {}
-    SummaryColumn addRow( std::size_t count ) {
-        ReusableStringStream rss;
-        rss << count;
-        std::string row = rss.str();
-        for (auto& oldRow : rows) {
-            while (oldRow.size() < row.size())
-                oldRow = ' ' + oldRow;
-            while (oldRow.size() > row.size())
-                row = ' ' + row;
-        }
-        rows.push_back(row);
-        return *this;
-    }
-
-    std::string label;
-    Colour::Code colour;
-    std::vector<std::string> rows;
-
-};
-
-void ConsoleReporter::printTotals( Totals const& totals ) {
-    if (totals.testCases.total() == 0) {
-        stream << Colour(Colour::Warning) << "No tests ran\n";
-    } else if (totals.assertions.total() > 0 && totals.testCases.allPassed()) {
-        stream << Colour(Colour::ResultSuccess) << "All tests passed";
-        stream << " ("
-            << pluralise(totals.assertions.passed, "assertion") << " in "
-            << pluralise(totals.testCases.passed, "test case") << ')'
-            << '\n';
-    } else {
-
-        std::vector<SummaryColumn> columns;
-        columns.push_back(SummaryColumn("", Colour::None)
-                          .addRow(totals.testCases.total())
-                          .addRow(totals.assertions.total()));
-        columns.push_back(SummaryColumn("passed", Colour::Success)
-                          .addRow(totals.testCases.passed)
-                          .addRow(totals.assertions.passed));
-        columns.push_back(SummaryColumn("failed", Colour::ResultError)
-                          .addRow(totals.testCases.failed)
-                          .addRow(totals.assertions.failed));
-        columns.push_back(SummaryColumn("failed as expected", Colour::ResultExpectedFailure)
-                          .addRow(totals.testCases.failedButOk)
-                          .addRow(totals.assertions.failedButOk));
-
-        printSummaryRow("test cases", columns, 0);
-        printSummaryRow("assertions", columns, 1);
-    }
-}
-void ConsoleReporter::printSummaryRow(std::string const& label, std::vector<SummaryColumn> const& cols, std::size_t row) {
-    for (auto col : cols) {
-        std::string value = col.rows[row];
-        if (col.label.empty()) {
-            stream << label << ": ";
-            if (value != "0")
-                stream << value;
-            else
-                stream << Colour(Colour::Warning) << "- none -";
-        } else if (value != "0") {
-            stream << Colour(Colour::LightGrey) << " | ";
-            stream << Colour(col.colour)
-                << value << ' ' << col.label;
-        }
-    }
-    stream << '\n';
-}
-
-void ConsoleReporter::printTotalsDivider(Totals const& totals) {
-    if (totals.testCases.total() > 0) {
-        std::size_t failedRatio = makeRatio(totals.testCases.failed, totals.testCases.total());
-        std::size_t failedButOkRatio = makeRatio(totals.testCases.failedButOk, totals.testCases.total());
-        std::size_t passedRatio = makeRatio(totals.testCases.passed, totals.testCases.total());
-        while (failedRatio + failedButOkRatio + passedRatio < CATCH_CONFIG_CONSOLE_WIDTH - 1)
-            findMax(failedRatio, failedButOkRatio, passedRatio)++;
-        while (failedRatio + failedButOkRatio + passedRatio > CATCH_CONFIG_CONSOLE_WIDTH - 1)
-            findMax(failedRatio, failedButOkRatio, passedRatio)--;
-
-        stream << Colour(Colour::Error) << std::string(failedRatio, '=');
-        stream << Colour(Colour::ResultExpectedFailure) << std::string(failedButOkRatio, '=');
-        if (totals.testCases.allPassed())
-            stream << Colour(Colour::ResultSuccess) << std::string(passedRatio, '=');
-        else
-            stream << Colour(Colour::Success) << std::string(passedRatio, '=');
-    } else {
-        stream << Colour(Colour::Warning) << std::string(CATCH_CONFIG_CONSOLE_WIDTH - 1, '=');
-    }
-    stream << '\n';
-}
-void ConsoleReporter::printSummaryDivider() {
-    stream << getLineOfChars<'-'>() << '\n';
-}
-
-void ConsoleReporter::printTestFilters() {
-    if (m_config->testSpec().hasFilters())
-        stream << Colour(Colour::BrightYellow) << "Filters: " << serializeFilters( m_config->getTestsOrTags() ) << '\n';
-}
-
-CATCH_REGISTER_REPORTER("console", ConsoleReporter)
-
-} // end namespace Catch
-
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
-
-#if defined(__clang__)
-#  pragma clang diagnostic pop
-#endif
-// end catch_reporter_console.cpp
-// start catch_reporter_junit.cpp
-
-#include <cassert>
-#include <sstream>
-#include <ctime>
-#include <algorithm>
-
-namespace Catch {
-
-    namespace {
-        std::string getCurrentTimestamp() {
-            // Beware, this is not reentrant because of backward compatibility issues
-            // Also, UTC only, again because of backward compatibility (%z is C++11)
-            time_t rawtime;
-            std::time(&rawtime);
-            auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
-
-#ifdef _MSC_VER
-            std::tm timeInfo = {};
-            gmtime_s(&timeInfo, &rawtime);
-#else
-            std::tm* timeInfo;
-            timeInfo = std::gmtime(&rawtime);
-#endif
-
-            char timeStamp[timeStampSize];
-            const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";
-
-#ifdef _MSC_VER
-            std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
-#else
-            std::strftime(timeStamp, timeStampSize, fmt, timeInfo);
-#endif
-            return std::string(timeStamp);
-        }
-
-        std::string fileNameTag(const std::vector<std::string> &tags) {
-            auto it = std::find_if(begin(tags),
-                                   end(tags),
-                                   [] (std::string const& tag) {return tag.front() == '#'; });
-            if (it != tags.end())
-                return it->substr(1);
-            return std::string();
-        }
-    } // anonymous namespace
-
-    JunitReporter::JunitReporter( ReporterConfig const& _config )
-        :   CumulativeReporterBase( _config ),
-            xml( _config.stream() )
-        {
-            m_reporterPrefs.shouldRedirectStdOut = true;
-            m_reporterPrefs.shouldReportAllAssertions = true;
-        }
-
-    JunitReporter::~JunitReporter() {}
-
-    std::string JunitReporter::getDescription() {
-        return "Reports test results in an XML format that looks like Ant's junitreport target";
-    }
-
-    void JunitReporter::noMatchingTestCases( std::string const& /*spec*/ ) {}
-
-    void JunitReporter::testRunStarting( TestRunInfo const& runInfo )  {
-        CumulativeReporterBase::testRunStarting( runInfo );
-        xml.startElement( "testsuites" );
-    }
-
-    void JunitReporter::testGroupStarting( GroupInfo const& groupInfo ) {
-        suiteTimer.start();
-        stdOutForSuite.clear();
-        stdErrForSuite.clear();
-        unexpectedExceptions = 0;
-        CumulativeReporterBase::testGroupStarting( groupInfo );
-    }
-
-    void JunitReporter::testCaseStarting( TestCaseInfo const& testCaseInfo ) {
-        m_okToFail = testCaseInfo.okToFail();
-    }
-
-    bool JunitReporter::assertionEnded( AssertionStats const& assertionStats ) {
-        if( assertionStats.assertionResult.getResultType() == ResultWas::ThrewException && !m_okToFail )
-            unexpectedExceptions++;
-        return CumulativeReporterBase::assertionEnded( assertionStats );
-    }
-
-    void JunitReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
-        stdOutForSuite += testCaseStats.stdOut;
-        stdErrForSuite += testCaseStats.stdErr;
-        CumulativeReporterBase::testCaseEnded( testCaseStats );
-    }
-
-    void JunitReporter::testGroupEnded( TestGroupStats const& testGroupStats ) {
-        double suiteTime = suiteTimer.getElapsedSeconds();
-        CumulativeReporterBase::testGroupEnded( testGroupStats );
-        writeGroup( *m_testGroups.back(), suiteTime );
-    }
-
-    void JunitReporter::testRunEndedCumulative() {
-        xml.endElement();
-    }
-
-    void JunitReporter::writeGroup( TestGroupNode const& groupNode, double suiteTime ) {
-        XmlWriter::ScopedElement e = xml.scopedElement( "testsuite" );
-
-        TestGroupStats const& stats = groupNode.value;
-        xml.writeAttribute( "name", stats.groupInfo.name );
-        xml.writeAttribute( "errors", unexpectedExceptions );
-        xml.writeAttribute( "failures", stats.totals.assertions.failed-unexpectedExceptions );
-        xml.writeAttribute( "tests", stats.totals.assertions.total() );
-        xml.writeAttribute( "hostname", "tbd" ); // !TBD
-        if( m_config->showDurations() == ShowDurations::Never )
-            xml.writeAttribute( "time", "" );
-        else
-            xml.writeAttribute( "time", suiteTime );
-        xml.writeAttribute( "timestamp", getCurrentTimestamp() );
-
-        // Write properties if there are any
-        if (m_config->hasTestFilters() || m_config->rngSeed() != 0) {
-            auto properties = xml.scopedElement("properties");
-            if (m_config->hasTestFilters()) {
-                xml.scopedElement("property")
-                    .writeAttribute("name", "filters")
-                    .writeAttribute("value", serializeFilters(m_config->getTestsOrTags()));
-            }
-            if (m_config->rngSeed() != 0) {
-                xml.scopedElement("property")
-                    .writeAttribute("name", "random-seed")
-                    .writeAttribute("value", m_config->rngSeed());
-            }
-        }
-
-        // Write test cases
-        for( auto const& child : groupNode.children )
-            writeTestCase( *child );
-
-        xml.scopedElement( "system-out" ).writeText( trim( stdOutForSuite ), false );
-        xml.scopedElement( "system-err" ).writeText( trim( stdErrForSuite ), false );
-    }
-
-    void JunitReporter::writeTestCase( TestCaseNode const& testCaseNode ) {
-        TestCaseStats const& stats = testCaseNode.value;
-
-        // All test cases have exactly one section - which represents the
-        // test case itself. That section may have 0-n nested sections
-        assert( testCaseNode.children.size() == 1 );
-        SectionNode const& rootSection = *testCaseNode.children.front();
-
-        std::string className = stats.testInfo.className;
-
-        if( className.empty() ) {
-            className = fileNameTag(stats.testInfo.tags);
-            if ( className.empty() )
-                className = "global";
-        }
-
-        if ( !m_config->name().empty() )
-            className = m_config->name() + "." + className;
-
-        writeSection( className, "", rootSection );
-    }
-
-    void JunitReporter::writeSection(  std::string const& className,
-                        std::string const& rootName,
-                        SectionNode const& sectionNode ) {
-        std::string name = trim( sectionNode.stats.sectionInfo.name );
-        if( !rootName.empty() )
-            name = rootName + '/' + name;
-
-        if( !sectionNode.assertions.empty() ||
-            !sectionNode.stdOut.empty() ||
-            !sectionNode.stdErr.empty() ) {
-            XmlWriter::ScopedElement e = xml.scopedElement( "testcase" );
-            if( className.empty() ) {
-                xml.writeAttribute( "classname", name );
-                xml.writeAttribute( "name", "root" );
-            }
-            else {
-                xml.writeAttribute( "classname", className );
-                xml.writeAttribute( "name", name );
-            }
-            xml.writeAttribute( "time", ::Catch::Detail::stringify( sectionNode.stats.durationInSeconds ) );
-
-            writeAssertions( sectionNode );
-
-            if( !sectionNode.stdOut.empty() )
-                xml.scopedElement( "system-out" ).writeText( trim( sectionNode.stdOut ), false );
-            if( !sectionNode.stdErr.empty() )
-                xml.scopedElement( "system-err" ).writeText( trim( sectionNode.stdErr ), false );
-        }
-        for( auto const& childNode : sectionNode.childSections )
-            if( className.empty() )
-                writeSection( name, "", *childNode );
-            else
-                writeSection( className, name, *childNode );
-    }
-
-    void JunitReporter::writeAssertions( SectionNode const& sectionNode ) {
-        for( auto const& assertion : sectionNode.assertions )
-            writeAssertion( assertion );
-    }
-
-    void JunitReporter::writeAssertion( AssertionStats const& stats ) {
-        AssertionResult const& result = stats.assertionResult;
-        if( !result.isOk() ) {
-            std::string elementName;
-            switch( result.getResultType() ) {
-                case ResultWas::ThrewException:
-                case ResultWas::FatalErrorCondition:
-                    elementName = "error";
-                    break;
-                case ResultWas::ExplicitFailure:
-                    elementName = "failure";
-                    break;
-                case ResultWas::ExpressionFailed:
-                    elementName = "failure";
-                    break;
-                case ResultWas::DidntThrowException:
-                    elementName = "failure";
-                    break;
-
-                // We should never see these here:
-                case ResultWas::Info:
-                case ResultWas::Warning:
-                case ResultWas::Ok:
-                case ResultWas::Unknown:
-                case ResultWas::FailureBit:
-                case ResultWas::Exception:
-                    elementName = "internalError";
-                    break;
-            }
-
-            XmlWriter::ScopedElement e = xml.scopedElement( elementName );
-
-            xml.writeAttribute( "message", result.getExpandedExpression() );
-            xml.writeAttribute( "type", result.getTestMacroName() );
-
-            ReusableStringStream rss;
-            if( !result.getMessage().empty() )
-                rss << result.getMessage() << '\n';
-            for( auto const& msg : stats.infoMessages )
-                if( msg.type == ResultWas::Info )
-                    rss << msg.message << '\n';
-
-            rss << "at " << result.getSourceInfo();
-            xml.writeText( rss.str(), false );
-        }
-    }
-
-    CATCH_REGISTER_REPORTER( "junit", JunitReporter )
-
-} // end namespace Catch
-// end catch_reporter_junit.cpp
-// start catch_reporter_listening.cpp
-
-#include <cassert>
-
-namespace Catch {
-
-    ListeningReporter::ListeningReporter() {
-        // We will assume that listeners will always want all assertions
-        m_preferences.shouldReportAllAssertions = true;
-    }
-
-    void ListeningReporter::addListener( IStreamingReporterPtr&& listener ) {
-        m_listeners.push_back( std::move( listener ) );
-    }
-
-    void ListeningReporter::addReporter(IStreamingReporterPtr&& reporter) {
-        assert(!m_reporter && "Listening reporter can wrap only 1 real reporter");
-        m_reporter = std::move( reporter );
-        m_preferences.shouldRedirectStdOut = m_reporter->getPreferences().shouldRedirectStdOut;
-    }
-
-    ReporterPreferences ListeningReporter::getPreferences() const {
-        return m_preferences;
-    }
-
-    std::set<Verbosity> ListeningReporter::getSupportedVerbosities() {
-        return std::set<Verbosity>{ };
-    }
-
-    void ListeningReporter::noMatchingTestCases( std::string const& spec ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->noMatchingTestCases( spec );
-        }
-        m_reporter->noMatchingTestCases( spec );
-    }
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-    void ListeningReporter::benchmarkPreparing( std::string const& name ) {
-		for (auto const& listener : m_listeners) {
-			listener->benchmarkPreparing(name);
-		}
-		m_reporter->benchmarkPreparing(name);
-	}
-    void ListeningReporter::benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->benchmarkStarting( benchmarkInfo );
-        }
-        m_reporter->benchmarkStarting( benchmarkInfo );
-    }
-    void ListeningReporter::benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->benchmarkEnded( benchmarkStats );
-        }
-        m_reporter->benchmarkEnded( benchmarkStats );
-    }
-
-	void ListeningReporter::benchmarkFailed( std::string const& error ) {
-		for (auto const& listener : m_listeners) {
-			listener->benchmarkFailed(error);
-		}
-		m_reporter->benchmarkFailed(error);
-	}
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-    void ListeningReporter::testRunStarting( TestRunInfo const& testRunInfo ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->testRunStarting( testRunInfo );
-        }
-        m_reporter->testRunStarting( testRunInfo );
-    }
-
-    void ListeningReporter::testGroupStarting( GroupInfo const& groupInfo ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->testGroupStarting( groupInfo );
-        }
-        m_reporter->testGroupStarting( groupInfo );
-    }
-
-    void ListeningReporter::testCaseStarting( TestCaseInfo const& testInfo ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->testCaseStarting( testInfo );
-        }
-        m_reporter->testCaseStarting( testInfo );
-    }
-
-    void ListeningReporter::sectionStarting( SectionInfo const& sectionInfo ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->sectionStarting( sectionInfo );
-        }
-        m_reporter->sectionStarting( sectionInfo );
-    }
-
-    void ListeningReporter::assertionStarting( AssertionInfo const& assertionInfo ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->assertionStarting( assertionInfo );
-        }
-        m_reporter->assertionStarting( assertionInfo );
-    }
-
-    // The return value indicates if the messages buffer should be cleared:
-    bool ListeningReporter::assertionEnded( AssertionStats const& assertionStats ) {
-        for( auto const& listener : m_listeners ) {
-            static_cast<void>( listener->assertionEnded( assertionStats ) );
-        }
-        return m_reporter->assertionEnded( assertionStats );
-    }
-
-    void ListeningReporter::sectionEnded( SectionStats const& sectionStats ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->sectionEnded( sectionStats );
-        }
-        m_reporter->sectionEnded( sectionStats );
-    }
-
-    void ListeningReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->testCaseEnded( testCaseStats );
-        }
-        m_reporter->testCaseEnded( testCaseStats );
-    }
-
-    void ListeningReporter::testGroupEnded( TestGroupStats const& testGroupStats ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->testGroupEnded( testGroupStats );
-        }
-        m_reporter->testGroupEnded( testGroupStats );
-    }
-
-    void ListeningReporter::testRunEnded( TestRunStats const& testRunStats ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->testRunEnded( testRunStats );
-        }
-        m_reporter->testRunEnded( testRunStats );
-    }
-
-    void ListeningReporter::skipTest( TestCaseInfo const& testInfo ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->skipTest( testInfo );
-        }
-        m_reporter->skipTest( testInfo );
-    }
-
-    bool ListeningReporter::isMulti() const {
-        return true;
-    }
-
-} // end namespace Catch
-// end catch_reporter_listening.cpp
-// start catch_reporter_xml.cpp
-
-#if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
-                              // Note that 4062 (not all labels are handled
-                              // and default is missing) is enabled
-#endif
-
-namespace Catch {
-    XmlReporter::XmlReporter( ReporterConfig const& _config )
-    :   StreamingReporterBase( _config ),
-        m_xml(_config.stream())
-    {
-        m_reporterPrefs.shouldRedirectStdOut = true;
-        m_reporterPrefs.shouldReportAllAssertions = true;
-    }
-
-    XmlReporter::~XmlReporter() = default;
-
-    std::string XmlReporter::getDescription() {
-        return "Reports test results as an XML document";
-    }
-
-    std::string XmlReporter::getStylesheetRef() const {
-        return std::string();
-    }
-
-    void XmlReporter::writeSourceInfo( SourceLineInfo const& sourceInfo ) {
-        m_xml
-            .writeAttribute( "filename", sourceInfo.file )
-            .writeAttribute( "line", sourceInfo.line );
-    }
-
-    void XmlReporter::noMatchingTestCases( std::string const& s ) {
-        StreamingReporterBase::noMatchingTestCases( s );
-    }
-
-    void XmlReporter::testRunStarting( TestRunInfo const& testInfo ) {
-        StreamingReporterBase::testRunStarting( testInfo );
-        std::string stylesheetRef = getStylesheetRef();
-        if( !stylesheetRef.empty() )
-            m_xml.writeStylesheetRef( stylesheetRef );
-        m_xml.startElement( "Catch" );
-        if( !m_config->name().empty() )
-            m_xml.writeAttribute( "name", m_config->name() );
-        if (m_config->testSpec().hasFilters())
-            m_xml.writeAttribute( "filters", serializeFilters( m_config->getTestsOrTags() ) );
-        if( m_config->rngSeed() != 0 )
-            m_xml.scopedElement( "Randomness" )
-                .writeAttribute( "seed", m_config->rngSeed() );
-    }
-
-    void XmlReporter::testGroupStarting( GroupInfo const& groupInfo ) {
-        StreamingReporterBase::testGroupStarting( groupInfo );
-        m_xml.startElement( "Group" )
-            .writeAttribute( "name", groupInfo.name );
-    }
-
-    void XmlReporter::testCaseStarting( TestCaseInfo const& testInfo ) {
-        StreamingReporterBase::testCaseStarting(testInfo);
-        m_xml.startElement( "TestCase" )
-            .writeAttribute( "name", trim( testInfo.name ) )
-            .writeAttribute( "description", testInfo.description )
-            .writeAttribute( "tags", testInfo.tagsAsString() );
-
-        writeSourceInfo( testInfo.lineInfo );
-
-        if ( m_config->showDurations() == ShowDurations::Always )
-            m_testCaseTimer.start();
-        m_xml.ensureTagClosed();
-    }
-
-    void XmlReporter::sectionStarting( SectionInfo const& sectionInfo ) {
-        StreamingReporterBase::sectionStarting( sectionInfo );
-        if( m_sectionDepth++ > 0 ) {
-            m_xml.startElement( "Section" )
-                .writeAttribute( "name", trim( sectionInfo.name ) );
-            writeSourceInfo( sectionInfo.lineInfo );
-            m_xml.ensureTagClosed();
-        }
-    }
-
-    void XmlReporter::assertionStarting( AssertionInfo const& ) { }
-
-    bool XmlReporter::assertionEnded( AssertionStats const& assertionStats ) {
-
-        AssertionResult const& result = assertionStats.assertionResult;
-
-        bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
-
-        if( includeResults || result.getResultType() == ResultWas::Warning ) {
-            // Print any info messages in <Info> tags.
-            for( auto const& msg : assertionStats.infoMessages ) {
-                if( msg.type == ResultWas::Info && includeResults ) {
-                    m_xml.scopedElement( "Info" )
-                            .writeText( msg.message );
-                } else if ( msg.type == ResultWas::Warning ) {
-                    m_xml.scopedElement( "Warning" )
-                            .writeText( msg.message );
-                }
-            }
-        }
-
-        // Drop out if result was successful but we're not printing them.
-        if( !includeResults && result.getResultType() != ResultWas::Warning )
-            return true;
-
-        // Print the expression if there is one.
-        if( result.hasExpression() ) {
-            m_xml.startElement( "Expression" )
-                .writeAttribute( "success", result.succeeded() )
-                .writeAttribute( "type", result.getTestMacroName() );
-
-            writeSourceInfo( result.getSourceInfo() );
-
-            m_xml.scopedElement( "Original" )
-                .writeText( result.getExpression() );
-            m_xml.scopedElement( "Expanded" )
-                .writeText( result.getExpandedExpression() );
-        }
-
-        // And... Print a result applicable to each result type.
-        switch( result.getResultType() ) {
-            case ResultWas::ThrewException:
-                m_xml.startElement( "Exception" );
-                writeSourceInfo( result.getSourceInfo() );
-                m_xml.writeText( result.getMessage() );
-                m_xml.endElement();
-                break;
-            case ResultWas::FatalErrorCondition:
-                m_xml.startElement( "FatalErrorCondition" );
-                writeSourceInfo( result.getSourceInfo() );
-                m_xml.writeText( result.getMessage() );
-                m_xml.endElement();
-                break;
-            case ResultWas::Info:
-                m_xml.scopedElement( "Info" )
-                    .writeText( result.getMessage() );
-                break;
-            case ResultWas::Warning:
-                // Warning will already have been written
-                break;
-            case ResultWas::ExplicitFailure:
-                m_xml.startElement( "Failure" );
-                writeSourceInfo( result.getSourceInfo() );
-                m_xml.writeText( result.getMessage() );
-                m_xml.endElement();
-                break;
-            default:
-                break;
-        }
-
-        if( result.hasExpression() )
-            m_xml.endElement();
-
-        return true;
-    }
-
-    void XmlReporter::sectionEnded( SectionStats const& sectionStats ) {
-        StreamingReporterBase::sectionEnded( sectionStats );
-        if( --m_sectionDepth > 0 ) {
-            XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" );
-            e.writeAttribute( "successes", sectionStats.assertions.passed );
-            e.writeAttribute( "failures", sectionStats.assertions.failed );
-            e.writeAttribute( "expectedFailures", sectionStats.assertions.failedButOk );
-
-            if ( m_config->showDurations() == ShowDurations::Always )
-                e.writeAttribute( "durationInSeconds", sectionStats.durationInSeconds );
-
-            m_xml.endElement();
-        }
-    }
-
-    void XmlReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
-        StreamingReporterBase::testCaseEnded( testCaseStats );
-        XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResult" );
-        e.writeAttribute( "success", testCaseStats.totals.assertions.allOk() );
-
-        if ( m_config->showDurations() == ShowDurations::Always )
-            e.writeAttribute( "durationInSeconds", m_testCaseTimer.getElapsedSeconds() );
-
-        if( !testCaseStats.stdOut.empty() )
-            m_xml.scopedElement( "StdOut" ).writeText( trim( testCaseStats.stdOut ), false );
-        if( !testCaseStats.stdErr.empty() )
-            m_xml.scopedElement( "StdErr" ).writeText( trim( testCaseStats.stdErr ), false );
-
-        m_xml.endElement();
-    }
-
-    void XmlReporter::testGroupEnded( TestGroupStats const& testGroupStats ) {
-        StreamingReporterBase::testGroupEnded( testGroupStats );
-        // TODO: Check testGroupStats.aborting and act accordingly.
-        m_xml.scopedElement( "OverallResults" )
-            .writeAttribute( "successes", testGroupStats.totals.assertions.passed )
-            .writeAttribute( "failures", testGroupStats.totals.assertions.failed )
-            .writeAttribute( "expectedFailures", testGroupStats.totals.assertions.failedButOk );
-        m_xml.endElement();
-    }
-
-    void XmlReporter::testRunEnded( TestRunStats const& testRunStats ) {
-        StreamingReporterBase::testRunEnded( testRunStats );
-        m_xml.scopedElement( "OverallResults" )
-            .writeAttribute( "successes", testRunStats.totals.assertions.passed )
-            .writeAttribute( "failures", testRunStats.totals.assertions.failed )
-            .writeAttribute( "expectedFailures", testRunStats.totals.assertions.failedButOk );
-        m_xml.endElement();
-    }
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-    void XmlReporter::benchmarkStarting(BenchmarkInfo const &info) {
-        m_xml.startElement("BenchmarkResults")
-            .writeAttribute("name", info.name)
-            .writeAttribute("samples", info.samples)
-            .writeAttribute("resamples", info.resamples)
-            .writeAttribute("iterations", info.iterations)
-            .writeAttribute("clockResolution", static_cast<uint64_t>(info.clockResolution))
-            .writeAttribute("estimatedDuration", static_cast<uint64_t>(info.estimatedDuration))
-            .writeComment("All values in nano seconds");
-    }
-
-    void XmlReporter::benchmarkEnded(BenchmarkStats<> const& benchmarkStats) {
-        m_xml.startElement("mean")
-            .writeAttribute("value", static_cast<uint64_t>(benchmarkStats.mean.point.count()))
-            .writeAttribute("lowerBound", static_cast<uint64_t>(benchmarkStats.mean.lower_bound.count()))
-            .writeAttribute("upperBound", static_cast<uint64_t>(benchmarkStats.mean.upper_bound.count()))
-            .writeAttribute("ci", benchmarkStats.mean.confidence_interval);
-        m_xml.endElement();
-        m_xml.startElement("standardDeviation")
-            .writeAttribute("value", benchmarkStats.standardDeviation.point.count())
-            .writeAttribute("lowerBound", benchmarkStats.standardDeviation.lower_bound.count())
-            .writeAttribute("upperBound", benchmarkStats.standardDeviation.upper_bound.count())
-            .writeAttribute("ci", benchmarkStats.standardDeviation.confidence_interval);
-        m_xml.endElement();
-        m_xml.startElement("outliers")
-            .writeAttribute("variance", benchmarkStats.outlierVariance)
-            .writeAttribute("lowMild", benchmarkStats.outliers.low_mild)
-            .writeAttribute("lowSevere", benchmarkStats.outliers.low_severe)
-            .writeAttribute("highMild", benchmarkStats.outliers.high_mild)
-            .writeAttribute("highSevere", benchmarkStats.outliers.high_severe);
-        m_xml.endElement();
-        m_xml.endElement();
-    }
-
-    void XmlReporter::benchmarkFailed(std::string const &error) {
-        m_xml.scopedElement("failed").
-            writeAttribute("message", error);
-        m_xml.endElement();
-    }
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-    CATCH_REGISTER_REPORTER( "xml", XmlReporter )
-
-} // end namespace Catch
-
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
-// end catch_reporter_xml.cpp
-
-namespace Catch {
-    LeakDetector leakDetector;
-}
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
-// end catch_impl.hpp
-#endif
-
-#ifdef CATCH_CONFIG_MAIN
-// start catch_default_main.hpp
-
-#ifndef __OBJC__
-
-#if defined(CATCH_CONFIG_WCHAR) && defined(WIN32) && defined(_UNICODE) && !defined(DO_NOT_USE_WMAIN)
-// Standard C/C++ Win32 Unicode wmain entry point
-extern "C" int wmain (int argc, wchar_t * argv[], wchar_t * []) {
-#else
-// Standard C/C++ main entry point
-int main (int argc, char * argv[]) {
-#endif
-
-    return Catch::Session().run( argc, argv );
-}
-
-#else // __OBJC__
-
-// Objective-C entry point
-int main (int argc, char * const argv[]) {
-#if !CATCH_ARC_ENABLED
-    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
-#endif
-
-    Catch::registerTestMethods();
-    int result = Catch::Session().run( argc, (char**)argv );
-
-#if !CATCH_ARC_ENABLED
-    [pool drain];
-#endif
-
-    return result;
-}
-
-#endif // __OBJC__
-
-// end catch_default_main.hpp
-#endif
-
-#if !defined(CATCH_CONFIG_IMPL_ONLY)
-
-#ifdef CLARA_CONFIG_MAIN_NOT_DEFINED
-#  undef CLARA_CONFIG_MAIN
-#endif
-
-#if !defined(CATCH_CONFIG_DISABLE)
-//////
-// If this config identifier is defined then all CATCH macros are prefixed with CATCH_
-#ifdef CATCH_CONFIG_PREFIX_ALL
-
-#define CATCH_REQUIRE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__ )
-#define CATCH_REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
-
-#define CATCH_REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "CATCH_REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__ )
-#define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
-#define CATCH_REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CATCH_REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CATCH_REQUIRE_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::Normal, matcher, expr )
-#endif// CATCH_CONFIG_DISABLE_MATCHERS
-#define CATCH_REQUIRE_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CATCH_REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__ )
-
-#define CATCH_CHECK( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CATCH_CHECK_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
-#define CATCH_CHECKED_IF( ... ) INTERNAL_CATCH_IF( "CATCH_CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CATCH_CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CATCH_CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CATCH_CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
-
-#define CATCH_CHECK_THROWS( ... )  INTERNAL_CATCH_THROWS( "CATCH_CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CATCH_CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
-#define CATCH_CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CATCH_CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CATCH_CHECK_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-#define CATCH_CHECK_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CATCH_CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CATCH_CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
-
-#define CATCH_REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-
-#define CATCH_INFO( msg ) INTERNAL_CATCH_INFO( "CATCH_INFO", msg )
-#define CATCH_UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "CATCH_UNSCOPED_INFO", msg )
-#define CATCH_WARN( msg ) INTERNAL_CATCH_MSG( "CATCH_WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
-#define CATCH_CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CATCH_CAPTURE",__VA_ARGS__ )
-
-#define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
-#define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define CATCH_METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
-#define CATCH_REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
-#define CATCH_SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
-#define CATCH_DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
-#define CATCH_FAIL( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
-#define CATCH_FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CATCH_SUCCEED( ... ) INTERNAL_CATCH_MSG( "CATCH_SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-
-#define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE()
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
-#else
-#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
-#endif
-
-#if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
-#define CATCH_STATIC_REQUIRE( ... )       static_assert(   __VA_ARGS__ ,      #__VA_ARGS__ );     CATCH_SUCCEED( #__VA_ARGS__ )
-#define CATCH_STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); CATCH_SUCCEED( #__VA_ARGS__ )
-#else
-#define CATCH_STATIC_REQUIRE( ... )       CATCH_REQUIRE( __VA_ARGS__ )
-#define CATCH_STATIC_REQUIRE_FALSE( ... ) CATCH_REQUIRE_FALSE( __VA_ARGS__ )
-#endif
-
-// "BDD-style" convenience wrappers
-#define CATCH_SCENARIO( ... ) CATCH_TEST_CASE( "Scenario: " __VA_ARGS__ )
-#define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
-#define CATCH_GIVEN( desc )     INTERNAL_CATCH_DYNAMIC_SECTION( "    Given: " << desc )
-#define CATCH_AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc )
-#define CATCH_WHEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     When: " << desc )
-#define CATCH_AND_WHEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc )
-#define CATCH_THEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     Then: " << desc )
-#define CATCH_AND_THEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( "      And: " << desc )
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-#define CATCH_BENCHMARK(...) \
-    INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
-#define CATCH_BENCHMARK_ADVANCED(name) \
-    INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), name)
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-// If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required
-#else
-
-#define REQUIRE( ... ) INTERNAL_CATCH_TEST( "REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__  )
-#define REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
-
-#define REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__ )
-#define REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
-#define REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "REQUIRE_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::Normal, matcher, expr )
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-#define REQUIRE_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__ )
-
-#define CHECK( ... ) INTERNAL_CATCH_TEST( "CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CHECK_FALSE( ... ) INTERNAL_CATCH_TEST( "CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
-#define CHECKED_IF( ... ) INTERNAL_CATCH_IF( "CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
-
-#define CHECK_THROWS( ... )  INTERNAL_CATCH_THROWS( "CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
-#define CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CHECK_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-#define CHECK_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
-
-#define REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-
-#define INFO( msg ) INTERNAL_CATCH_INFO( "INFO", msg )
-#define UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "UNSCOPED_INFO", msg )
-#define WARN( msg ) INTERNAL_CATCH_MSG( "WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
-#define CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CAPTURE",__VA_ARGS__ )
-
-#define TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
-#define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
-#define REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
-#define SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
-#define DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
-#define FAIL( ... ) INTERNAL_CATCH_MSG( "FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
-#define FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define SUCCEED( ... ) INTERNAL_CATCH_MSG( "SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE()
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )
-#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
-#define TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(__VA_ARGS__)
-#define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#else
-#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
-#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ ) )
-#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
-#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
-#define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
-#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ ) )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
-#define TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE( __VA_ARGS__ ) )
-#define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
-#endif
-
-#if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
-#define STATIC_REQUIRE( ... )       static_assert(   __VA_ARGS__,  #__VA_ARGS__ ); SUCCEED( #__VA_ARGS__ )
-#define STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); SUCCEED( "!(" #__VA_ARGS__ ")" )
-#else
-#define STATIC_REQUIRE( ... )       REQUIRE( __VA_ARGS__ )
-#define STATIC_REQUIRE_FALSE( ... ) REQUIRE_FALSE( __VA_ARGS__ )
-#endif
-
-#endif
-
-#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature )
-
-// "BDD-style" convenience wrappers
-#define SCENARIO( ... ) TEST_CASE( "Scenario: " __VA_ARGS__ )
-#define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
-
-#define GIVEN( desc )     INTERNAL_CATCH_DYNAMIC_SECTION( "    Given: " << desc )
-#define AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc )
-#define WHEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     When: " << desc )
-#define AND_WHEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc )
-#define THEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     Then: " << desc )
-#define AND_THEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( "      And: " << desc )
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-#define BENCHMARK(...) \
-    INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
-#define BENCHMARK_ADVANCED(name) \
-    INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), name)
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-using Catch::Detail::Approx;
-
-#else // CATCH_CONFIG_DISABLE
-
-//////
-// If this config identifier is defined then all CATCH macros are prefixed with CATCH_
-#ifdef CATCH_CONFIG_PREFIX_ALL
-
-#define CATCH_REQUIRE( ... )        (void)(0)
-#define CATCH_REQUIRE_FALSE( ... )  (void)(0)
-
-#define CATCH_REQUIRE_THROWS( ... ) (void)(0)
-#define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) (void)(0)
-#define CATCH_REQUIRE_THROWS_WITH( expr, matcher )     (void)(0)
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CATCH_REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
-#endif// CATCH_CONFIG_DISABLE_MATCHERS
-#define CATCH_REQUIRE_NOTHROW( ... ) (void)(0)
-
-#define CATCH_CHECK( ... )         (void)(0)
-#define CATCH_CHECK_FALSE( ... )   (void)(0)
-#define CATCH_CHECKED_IF( ... )    if (__VA_ARGS__)
-#define CATCH_CHECKED_ELSE( ... )  if (!(__VA_ARGS__))
-#define CATCH_CHECK_NOFAIL( ... )  (void)(0)
-
-#define CATCH_CHECK_THROWS( ... )  (void)(0)
-#define CATCH_CHECK_THROWS_AS( expr, exceptionType ) (void)(0)
-#define CATCH_CHECK_THROWS_WITH( expr, matcher )     (void)(0)
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CATCH_CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-#define CATCH_CHECK_NOTHROW( ... ) (void)(0)
-
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CATCH_CHECK_THAT( arg, matcher )   (void)(0)
-
-#define CATCH_REQUIRE_THAT( arg, matcher ) (void)(0)
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-
-#define CATCH_INFO( msg )          (void)(0)
-#define CATCH_UNSCOPED_INFO( msg ) (void)(0)
-#define CATCH_WARN( msg )          (void)(0)
-#define CATCH_CAPTURE( msg )       (void)(0)
-
-#define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-#define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-#define CATCH_METHOD_AS_TEST_CASE( method, ... )
-#define CATCH_REGISTER_TEST_CASE( Function, ... ) (void)(0)
-#define CATCH_SECTION( ... )
-#define CATCH_DYNAMIC_SECTION( ... )
-#define CATCH_FAIL( ... ) (void)(0)
-#define CATCH_FAIL_CHECK( ... ) (void)(0)
-#define CATCH_SUCCEED( ... ) (void)(0)
-
-#define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
-#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
-#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
-#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#else
-#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__) )
-#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__) )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#endif
-
-// "BDD-style" convenience wrappers
-#define CATCH_SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-#define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), className )
-#define CATCH_GIVEN( desc )
-#define CATCH_AND_GIVEN( desc )
-#define CATCH_WHEN( desc )
-#define CATCH_AND_WHEN( desc )
-#define CATCH_THEN( desc )
-#define CATCH_AND_THEN( desc )
-
-#define CATCH_STATIC_REQUIRE( ... )       (void)(0)
-#define CATCH_STATIC_REQUIRE_FALSE( ... ) (void)(0)
-
-// If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required
-#else
-
-#define REQUIRE( ... )       (void)(0)
-#define REQUIRE_FALSE( ... ) (void)(0)
-
-#define REQUIRE_THROWS( ... ) (void)(0)
-#define REQUIRE_THROWS_AS( expr, exceptionType ) (void)(0)
-#define REQUIRE_THROWS_WITH( expr, matcher ) (void)(0)
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-#define REQUIRE_NOTHROW( ... ) (void)(0)
-
-#define CHECK( ... ) (void)(0)
-#define CHECK_FALSE( ... ) (void)(0)
-#define CHECKED_IF( ... ) if (__VA_ARGS__)
-#define CHECKED_ELSE( ... ) if (!(__VA_ARGS__))
-#define CHECK_NOFAIL( ... ) (void)(0)
-
-#define CHECK_THROWS( ... )  (void)(0)
-#define CHECK_THROWS_AS( expr, exceptionType ) (void)(0)
-#define CHECK_THROWS_WITH( expr, matcher ) (void)(0)
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-#define CHECK_NOTHROW( ... ) (void)(0)
-
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CHECK_THAT( arg, matcher ) (void)(0)
-
-#define REQUIRE_THAT( arg, matcher ) (void)(0)
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-
-#define INFO( msg ) (void)(0)
-#define UNSCOPED_INFO( msg ) (void)(0)
-#define WARN( msg ) (void)(0)
-#define CAPTURE( msg ) (void)(0)
-
-#define TEST_CASE( ... )  INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-#define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-#define METHOD_AS_TEST_CASE( method, ... )
-#define REGISTER_TEST_CASE( Function, ... ) (void)(0)
-#define SECTION( ... )
-#define DYNAMIC_SECTION( ... )
-#define FAIL( ... ) (void)(0)
-#define FAIL_CHECK( ... ) (void)(0)
-#define SUCCEED( ... ) (void)(0)
-#define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
-#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
-#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
-#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#else
-#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__) )
-#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__) )
-#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__ ) )
-#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ ) )
-#define TEMPLATE_PRODUCT_TEST_CASE( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#endif
-
-#define STATIC_REQUIRE( ... )       (void)(0)
-#define STATIC_REQUIRE_FALSE( ... ) (void)(0)
-
-#endif
-
-#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
-
-// "BDD-style" convenience wrappers
-#define SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ) )
-#define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), className )
-
-#define GIVEN( desc )
-#define AND_GIVEN( desc )
-#define WHEN( desc )
-#define AND_WHEN( desc )
-#define THEN( desc )
-#define AND_THEN( desc )
-
-using Catch::Detail::Approx;
-
-#endif
-
-#endif // ! CATCH_CONFIG_IMPL_ONLY
-
-// start catch_reenable_warnings.h
-
-
-#ifdef __clang__
-#    ifdef __ICC // icpc defines the __clang__ macro
-#        pragma warning(pop)
-#    else
-#        pragma clang diagnostic pop
-#    endif
-#elif defined __GNUC__
-#    pragma GCC diagnostic pop
-#endif
-
-// end catch_reenable_warnings.h
-// end catch.hpp
-#endif // TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
-
diff --git a/tests/catch_amalgamated.cpp b/tests/catch_amalgamated.cpp
new file mode 100644
index 0000000000..928d1f9607
--- /dev/null
+++ b/tests/catch_amalgamated.cpp
@@ -0,0 +1,11811 @@
+
+//              Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+//   (See accompanying file LICENSE.txt or copy at
+//        https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+
+//  Catch v3.7.1
+//  Generated: 2024-09-17 10:36:45.608896
+//  ----------------------------------------------------------
+//  This file is an amalgamation of multiple different files.
+//  You probably shouldn't edit it directly.
+//  ----------------------------------------------------------
+
+#include "catch_amalgamated.hpp"
+
+
+#ifndef CATCH_WINDOWS_H_PROXY_HPP_INCLUDED
+#define CATCH_WINDOWS_H_PROXY_HPP_INCLUDED
+
+
+#if defined(CATCH_PLATFORM_WINDOWS)
+
+// We might end up with the define made globally through the compiler,
+// and we don't want to trigger warnings for this
+#if !defined(NOMINMAX)
+#  define NOMINMAX
+#endif
+#if !defined(WIN32_LEAN_AND_MEAN)
+#  define WIN32_LEAN_AND_MEAN
+#endif
+
+#include <windows.h>
+
+#endif // defined(CATCH_PLATFORM_WINDOWS)
+
+#endif // CATCH_WINDOWS_H_PROXY_HPP_INCLUDED
+
+
+
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            ChronometerConcept::~ChronometerConcept() = default;
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+
+// Adapted from donated nonius code.
+
+
+#include <vector>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            SampleAnalysis analyse(const IConfig &cfg, FDuration* first, FDuration* last) {
+                if (!cfg.benchmarkNoAnalysis()) {
+                    std::vector<double> samples;
+                    samples.reserve(static_cast<size_t>(last - first));
+                    for (auto current = first; current != last; ++current) {
+                        samples.push_back( current->count() );
+                    }
+
+                    auto analysis = Catch::Benchmark::Detail::analyse_samples(
+                        cfg.benchmarkConfidenceInterval(),
+                        cfg.benchmarkResamples(),
+                        samples.data(),
+                        samples.data() + samples.size() );
+                    auto outliers = Catch::Benchmark::Detail::classify_outliers(
+                        samples.data(), samples.data() + samples.size() );
+
+                    auto wrap_estimate = [](Estimate<double> e) {
+                        return Estimate<FDuration> {
+                            FDuration(e.point),
+                                FDuration(e.lower_bound),
+                                FDuration(e.upper_bound),
+                                e.confidence_interval,
+                        };
+                    };
+                    std::vector<FDuration> samples2;
+                    samples2.reserve(samples.size());
+                    for (auto s : samples) {
+                        samples2.push_back( FDuration( s ) );
+                    }
+
+                    return {
+                        CATCH_MOVE(samples2),
+                        wrap_estimate(analysis.mean),
+                        wrap_estimate(analysis.standard_deviation),
+                        outliers,
+                        analysis.outlier_variance,
+                    };
+                } else {
+                    std::vector<FDuration> samples;
+                    samples.reserve(static_cast<size_t>(last - first));
+
+                    FDuration mean = FDuration(0);
+                    int i = 0;
+                    for (auto it = first; it < last; ++it, ++i) {
+                        samples.push_back(*it);
+                        mean += *it;
+                    }
+                    mean /= i;
+
+                    return SampleAnalysis{
+                        CATCH_MOVE(samples),
+                        Estimate<FDuration>{ mean, mean, mean, 0.0 },
+                        Estimate<FDuration>{ FDuration( 0 ),
+                                             FDuration( 0 ),
+                                             FDuration( 0 ),
+                                             0.0 },
+                        OutlierClassification{},
+                        0.0
+                    };
+                }
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+
+
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            struct do_nothing {
+                void operator()() const {}
+            };
+
+            BenchmarkFunction::callable::~callable() = default;
+            BenchmarkFunction::BenchmarkFunction():
+                f( new model<do_nothing>{ {} } ){}
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+
+
+
+#include <exception>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            struct optimized_away_error : std::exception {
+                const char* what() const noexcept override;
+            };
+
+            const char* optimized_away_error::what() const noexcept {
+                return "could not measure benchmark, maybe it was optimized away";
+            }
+
+            void throw_optimized_away_error() {
+                Catch::throw_exception(optimized_away_error{});
+            }
+
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+
+// Adapted from donated nonius code.
+
+
+
+#include <algorithm>
+#include <cassert>
+#include <cmath>
+#include <cstddef>
+#include <numeric>
+#include <random>
+
+
+#if defined(CATCH_CONFIG_USE_ASYNC)
+#include <future>
+#endif
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            namespace {
+
+                template <typename URng, typename Estimator>
+                static sample
+                resample( URng& rng,
+                          unsigned int resamples,
+                          double const* first,
+                          double const* last,
+                          Estimator& estimator ) {
+                    auto n = static_cast<size_t>( last - first );
+                    Catch::uniform_integer_distribution<size_t> dist( 0, n - 1 );
+
+                    sample out;
+                    out.reserve( resamples );
+                    std::vector<double> resampled;
+                    resampled.reserve( n );
+                    for ( size_t i = 0; i < resamples; ++i ) {
+                        resampled.clear();
+                        for ( size_t s = 0; s < n; ++s ) {
+                            resampled.push_back( first[dist( rng )] );
+                        }
+                        const auto estimate =
+                            estimator( resampled.data(), resampled.data() + resampled.size() );
+                        out.push_back( estimate );
+                    }
+                    std::sort( out.begin(), out.end() );
+                    return out;
+                }
+
+                static double outlier_variance( Estimate<double> mean,
+                                                Estimate<double> stddev,
+                                                int n ) {
+                    double sb = stddev.point;
+                    double mn = mean.point / n;
+                    double mg_min = mn / 2.;
+                    double sg = (std::min)( mg_min / 4., sb / std::sqrt( n ) );
+                    double sg2 = sg * sg;
+                    double sb2 = sb * sb;
+
+                    auto c_max = [n, mn, sb2, sg2]( double x ) -> double {
+                        double k = mn - x;
+                        double d = k * k;
+                        double nd = n * d;
+                        double k0 = -n * nd;
+                        double k1 = sb2 - n * sg2 + nd;
+                        double det = k1 * k1 - 4 * sg2 * k0;
+                        return static_cast<int>( -2. * k0 /
+                                                 ( k1 + std::sqrt( det ) ) );
+                    };
+
+                    auto var_out = [n, sb2, sg2]( double c ) {
+                        double nc = n - c;
+                        return ( nc / n ) * ( sb2 - nc * sg2 );
+                    };
+
+                    return (std::min)( var_out( 1 ),
+                                       var_out(
+                                           (std::min)( c_max( 0. ),
+                                                       c_max( mg_min ) ) ) ) /
+                           sb2;
+                }
+
+                static double erf_inv( double x ) {
+                    // Code accompanying the article "Approximating the erfinv
+                    // function" in GPU Computing Gems, Volume 2
+                    double w, p;
+
+                    w = -log( ( 1.0 - x ) * ( 1.0 + x ) );
+
+                    if ( w < 6.250000 ) {
+                        w = w - 3.125000;
+                        p = -3.6444120640178196996e-21;
+                        p = -1.685059138182016589e-19 + p * w;
+                        p = 1.2858480715256400167e-18 + p * w;
+                        p = 1.115787767802518096e-17 + p * w;
+                        p = -1.333171662854620906e-16 + p * w;
+                        p = 2.0972767875968561637e-17 + p * w;
+                        p = 6.6376381343583238325e-15 + p * w;
+                        p = -4.0545662729752068639e-14 + p * w;
+                        p = -8.1519341976054721522e-14 + p * w;
+                        p = 2.6335093153082322977e-12 + p * w;
+                        p = -1.2975133253453532498e-11 + p * w;
+                        p = -5.4154120542946279317e-11 + p * w;
+                        p = 1.051212273321532285e-09 + p * w;
+                        p = -4.1126339803469836976e-09 + p * w;
+                        p = -2.9070369957882005086e-08 + p * w;
+                        p = 4.2347877827932403518e-07 + p * w;
+                        p = -1.3654692000834678645e-06 + p * w;
+                        p = -1.3882523362786468719e-05 + p * w;
+                        p = 0.0001867342080340571352 + p * w;
+                        p = -0.00074070253416626697512 + p * w;
+                        p = -0.0060336708714301490533 + p * w;
+                        p = 0.24015818242558961693 + p * w;
+                        p = 1.6536545626831027356 + p * w;
+                    } else if ( w < 16.000000 ) {
+                        w = sqrt( w ) - 3.250000;
+                        p = 2.2137376921775787049e-09;
+                        p = 9.0756561938885390979e-08 + p * w;
+                        p = -2.7517406297064545428e-07 + p * w;
+                        p = 1.8239629214389227755e-08 + p * w;
+                        p = 1.5027403968909827627e-06 + p * w;
+                        p = -4.013867526981545969e-06 + p * w;
+                        p = 2.9234449089955446044e-06 + p * w;
+                        p = 1.2475304481671778723e-05 + p * w;
+                        p = -4.7318229009055733981e-05 + p * w;
+                        p = 6.8284851459573175448e-05 + p * w;
+                        p = 2.4031110387097893999e-05 + p * w;
+                        p = -0.0003550375203628474796 + p * w;
+                        p = 0.00095328937973738049703 + p * w;
+                        p = -0.0016882755560235047313 + p * w;
+                        p = 0.0024914420961078508066 + p * w;
+                        p = -0.0037512085075692412107 + p * w;
+                        p = 0.005370914553590063617 + p * w;
+                        p = 1.0052589676941592334 + p * w;
+                        p = 3.0838856104922207635 + p * w;
+                    } else {
+                        w = sqrt( w ) - 5.000000;
+                        p = -2.7109920616438573243e-11;
+                        p = -2.5556418169965252055e-10 + p * w;
+                        p = 1.5076572693500548083e-09 + p * w;
+                        p = -3.7894654401267369937e-09 + p * w;
+                        p = 7.6157012080783393804e-09 + p * w;
+                        p = -1.4960026627149240478e-08 + p * w;
+                        p = 2.9147953450901080826e-08 + p * w;
+                        p = -6.7711997758452339498e-08 + p * w;
+                        p = 2.2900482228026654717e-07 + p * w;
+                        p = -9.9298272942317002539e-07 + p * w;
+                        p = 4.5260625972231537039e-06 + p * w;
+                        p = -1.9681778105531670567e-05 + p * w;
+                        p = 7.5995277030017761139e-05 + p * w;
+                        p = -0.00021503011930044477347 + p * w;
+                        p = -0.00013871931833623122026 + p * w;
+                        p = 1.0103004648645343977 + p * w;
+                        p = 4.8499064014085844221 + p * w;
+                    }
+                    return p * x;
+                }
+
+                static double
+                standard_deviation( double const* first, double const* last ) {
+                    auto m = Catch::Benchmark::Detail::mean( first, last );
+                    double variance =
+                        std::accumulate( first,
+                                         last,
+                                         0.,
+                                         [m]( double a, double b ) {
+                                             double diff = b - m;
+                                             return a + diff * diff;
+                                         } ) /
+                        ( last - first );
+                    return std::sqrt( variance );
+                }
+
+                static sample jackknife( double ( *estimator )( double const*,
+                                                                double const* ),
+                                         double* first,
+                                         double* last ) {
+                    const auto second = first + 1;
+                    sample results;
+                    results.reserve( static_cast<size_t>( last - first ) );
+
+                    for ( auto it = first; it != last; ++it ) {
+                        std::iter_swap( it, first );
+                        results.push_back( estimator( second, last ) );
+                    }
+
+                    return results;
+                }
+
+
+            } // namespace
+        }     // namespace Detail
+    }         // namespace Benchmark
+} // namespace Catch
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+
+            double weighted_average_quantile( int k,
+                                              int q,
+                                              double* first,
+                                              double* last ) {
+                auto count = last - first;
+                double idx = (count - 1) * k / static_cast<double>(q);
+                int j = static_cast<int>(idx);
+                double g = idx - j;
+                std::nth_element(first, first + j, last);
+                auto xj = first[j];
+                if ( Catch::Detail::directCompare( g, 0 ) ) {
+                    return xj;
+                }
+
+                auto xj1 = *std::min_element(first + (j + 1), last);
+                return xj + g * (xj1 - xj);
+            }
+
+            OutlierClassification
+            classify_outliers( double const* first, double const* last ) {
+                std::vector<double> copy( first, last );
+
+                auto q1 = weighted_average_quantile( 1, 4, copy.data(), copy.data() + copy.size() );
+                auto q3 = weighted_average_quantile( 3, 4, copy.data(), copy.data() + copy.size() );
+                auto iqr = q3 - q1;
+                auto los = q1 - ( iqr * 3. );
+                auto lom = q1 - ( iqr * 1.5 );
+                auto him = q3 + ( iqr * 1.5 );
+                auto his = q3 + ( iqr * 3. );
+
+                OutlierClassification o;
+                for ( ; first != last; ++first ) {
+                    const double t = *first;
+                    if ( t < los ) {
+                        ++o.low_severe;
+                    } else if ( t < lom ) {
+                        ++o.low_mild;
+                    } else if ( t > his ) {
+                        ++o.high_severe;
+                    } else if ( t > him ) {
+                        ++o.high_mild;
+                    }
+                    ++o.samples_seen;
+                }
+                return o;
+            }
+
+            double mean( double const* first, double const* last ) {
+                auto count = last - first;
+                double sum = 0.;
+                while (first != last) {
+                    sum += *first;
+                    ++first;
+                }
+                return sum / static_cast<double>(count);
+            }
+
+            double normal_cdf( double x ) {
+                return std::erfc( -x / std::sqrt( 2.0 ) ) / 2.0;
+            }
+
+            double erfc_inv(double x) {
+                return erf_inv(1.0 - x);
+            }
+
+            double normal_quantile(double p) {
+                static const double ROOT_TWO = std::sqrt(2.0);
+
+                double result = 0.0;
+                assert(p >= 0 && p <= 1);
+                if (p < 0 || p > 1) {
+                    return result;
+                }
+
+                result = -erfc_inv(2.0 * p);
+                // result *= normal distribution standard deviation (1.0) * sqrt(2)
+                result *= /*sd * */ ROOT_TWO;
+                // result += normal disttribution mean (0)
+                return result;
+            }
+
+            Estimate<double>
+            bootstrap( double confidence_level,
+                       double* first,
+                       double* last,
+                       sample const& resample,
+                       double ( *estimator )( double const*, double const* ) ) {
+                auto n_samples = last - first;
+
+                double point = estimator( first, last );
+                // Degenerate case with a single sample
+                if ( n_samples == 1 )
+                    return { point, point, point, confidence_level };
+
+                sample jack = jackknife( estimator, first, last );
+                double jack_mean =
+                    mean( jack.data(), jack.data() + jack.size() );
+                double sum_squares = 0, sum_cubes = 0;
+                for ( double x : jack ) {
+                    auto difference = jack_mean - x;
+                    auto square = difference * difference;
+                    auto cube = square * difference;
+                    sum_squares += square;
+                    sum_cubes += cube;
+                }
+
+                double accel = sum_cubes / ( 6 * std::pow( sum_squares, 1.5 ) );
+                long n = static_cast<long>( resample.size() );
+                double prob_n =
+                    std::count_if( resample.begin(),
+                                   resample.end(),
+                                   [point]( double x ) { return x < point; } ) /
+                    static_cast<double>( n );
+                // degenerate case with uniform samples
+                if ( Catch::Detail::directCompare( prob_n, 0. ) ) {
+                    return { point, point, point, confidence_level };
+                }
+
+                double bias = normal_quantile( prob_n );
+                double z1 = normal_quantile( ( 1. - confidence_level ) / 2. );
+
+                auto cumn = [n]( double x ) -> long {
+                    return std::lround( normal_cdf( x ) *
+                                        static_cast<double>( n ) );
+                };
+                auto a = [bias, accel]( double b ) {
+                    return bias + b / ( 1. - accel * b );
+                };
+                double b1 = bias + z1;
+                double b2 = bias - z1;
+                double a1 = a( b1 );
+                double a2 = a( b2 );
+                auto lo = static_cast<size_t>( (std::max)( cumn( a1 ), 0l ) );
+                auto hi =
+                    static_cast<size_t>( (std::min)( cumn( a2 ), n - 1 ) );
+
+                return { point, resample[lo], resample[hi], confidence_level };
+            }
+
+            bootstrap_analysis analyse_samples(double confidence_level,
+                                               unsigned int n_resamples,
+                                               double* first,
+                                               double* last) {
+                auto mean = &Detail::mean;
+                auto stddev = &standard_deviation;
+
+#if defined(CATCH_CONFIG_USE_ASYNC)
+                auto Estimate = [=](double(*f)(double const*, double const*)) {
+                    std::random_device rd;
+                    auto seed = rd();
+                    return std::async(std::launch::async, [=] {
+                        SimplePcg32 rng( seed );
+                        auto resampled = resample(rng, n_resamples, first, last, f);
+                        return bootstrap(confidence_level, first, last, resampled, f);
+                    });
+                };
+
+                auto mean_future = Estimate(mean);
+                auto stddev_future = Estimate(stddev);
+
+                auto mean_estimate = mean_future.get();
+                auto stddev_estimate = stddev_future.get();
+#else
+                auto Estimate = [=](double(*f)(double const* , double const*)) {
+                    std::random_device rd;
+                    auto seed = rd();
+                    SimplePcg32 rng( seed );
+                    auto resampled = resample(rng, n_resamples, first, last, f);
+                    return bootstrap(confidence_level, first, last, resampled, f);
+                };
+
+                auto mean_estimate = Estimate(mean);
+                auto stddev_estimate = Estimate(stddev);
+#endif // CATCH_USE_ASYNC
+
+                auto n = static_cast<int>(last - first); // seriously, one can't use integral types without hell in C++
+                double outlier_variance = Detail::outlier_variance(mean_estimate, stddev_estimate, n);
+
+                return { mean_estimate, stddev_estimate, outlier_variance };
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+
+
+#include <cmath>
+#include <limits>
+
+namespace {
+
+// Performs equivalent check of std::fabs(lhs - rhs) <= margin
+// But without the subtraction to allow for INFINITY in comparison
+bool marginComparison(double lhs, double rhs, double margin) {
+    return (lhs + margin >= rhs) && (rhs + margin >= lhs);
+}
+
+}
+
+namespace Catch {
+
+    Approx::Approx ( double value )
+    :   m_epsilon( static_cast<double>(std::numeric_limits<float>::epsilon())*100. ),
+        m_margin( 0.0 ),
+        m_scale( 0.0 ),
+        m_value( value )
+    {}
+
+    Approx Approx::custom() {
+        return Approx( 0 );
+    }
+
+    Approx Approx::operator-() const {
+        auto temp(*this);
+        temp.m_value = -temp.m_value;
+        return temp;
+    }
+
+
+    std::string Approx::toString() const {
+        ReusableStringStream rss;
+        rss << "Approx( " << ::Catch::Detail::stringify( m_value ) << " )";
+        return rss.str();
+    }
+
+    bool Approx::equalityComparisonImpl(const double other) const {
+        // First try with fixed margin, then compute margin based on epsilon, scale and Approx's value
+        // Thanks to Richard Harris for his help refining the scaled margin value
+        return marginComparison(m_value, other, m_margin)
+            || marginComparison(m_value, other, m_epsilon * (m_scale + std::fabs(std::isinf(m_value)? 0 : m_value)));
+    }
+
+    void Approx::setMargin(double newMargin) {
+        CATCH_ENFORCE(newMargin >= 0,
+            "Invalid Approx::margin: " << newMargin << '.'
+            << " Approx::Margin has to be non-negative.");
+        m_margin = newMargin;
+    }
+
+    void Approx::setEpsilon(double newEpsilon) {
+        CATCH_ENFORCE(newEpsilon >= 0 && newEpsilon <= 1.0,
+            "Invalid Approx::epsilon: " << newEpsilon << '.'
+            << " Approx::epsilon has to be in [0, 1]");
+        m_epsilon = newEpsilon;
+    }
+
+namespace literals {
+    Approx operator ""_a(long double val) {
+        return Approx(val);
+    }
+    Approx operator ""_a(unsigned long long val) {
+        return Approx(val);
+    }
+} // end namespace literals
+
+std::string StringMaker<Catch::Approx>::convert(Catch::Approx const& value) {
+    return value.toString();
+}
+
+} // end namespace Catch
+
+
+
+namespace Catch {
+
+    AssertionResultData::AssertionResultData(ResultWas::OfType _resultType, LazyExpression const& _lazyExpression):
+        lazyExpression(_lazyExpression),
+        resultType(_resultType) {}
+
+    std::string AssertionResultData::reconstructExpression() const {
+
+        if( reconstructedExpression.empty() ) {
+            if( lazyExpression ) {
+                ReusableStringStream rss;
+                rss << lazyExpression;
+                reconstructedExpression = rss.str();
+            }
+        }
+        return reconstructedExpression;
+    }
+
+    AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData&& data )
+    :   m_info( info ),
+        m_resultData( CATCH_MOVE(data) )
+    {}
+
+    // Result was a success
+    bool AssertionResult::succeeded() const {
+        return Catch::isOk( m_resultData.resultType );
+    }
+
+    // Result was a success, or failure is suppressed
+    bool AssertionResult::isOk() const {
+        return Catch::isOk( m_resultData.resultType ) || shouldSuppressFailure( m_info.resultDisposition );
+    }
+
+    ResultWas::OfType AssertionResult::getResultType() const {
+        return m_resultData.resultType;
+    }
+
+    bool AssertionResult::hasExpression() const {
+        return !m_info.capturedExpression.empty();
+    }
+
+    bool AssertionResult::hasMessage() const {
+        return !m_resultData.message.empty();
+    }
+
+    std::string AssertionResult::getExpression() const {
+        // Possibly overallocating by 3 characters should be basically free
+        std::string expr; expr.reserve(m_info.capturedExpression.size() + 3);
+        if (isFalseTest(m_info.resultDisposition)) {
+            expr += "!(";
+        }
+        expr += m_info.capturedExpression;
+        if (isFalseTest(m_info.resultDisposition)) {
+            expr += ')';
+        }
+        return expr;
+    }
+
+    std::string AssertionResult::getExpressionInMacro() const {
+        if ( m_info.macroName.empty() ) {
+            return static_cast<std::string>( m_info.capturedExpression );
+        }
+        std::string expr;
+        expr.reserve( m_info.macroName.size() + m_info.capturedExpression.size() + 4 );
+        expr += m_info.macroName;
+        expr += "( ";
+        expr += m_info.capturedExpression;
+        expr += " )";
+        return expr;
+    }
+
+    bool AssertionResult::hasExpandedExpression() const {
+        return hasExpression() && getExpandedExpression() != getExpression();
+    }
+
+    std::string AssertionResult::getExpandedExpression() const {
+        std::string expr = m_resultData.reconstructExpression();
+        return expr.empty()
+                ? getExpression()
+                : expr;
+    }
+
+    StringRef AssertionResult::getMessage() const {
+        return m_resultData.message;
+    }
+    SourceLineInfo AssertionResult::getSourceInfo() const {
+        return m_info.lineInfo;
+    }
+
+    StringRef AssertionResult::getTestMacroName() const {
+        return m_info.macroName;
+    }
+
+} // end namespace Catch
+
+
+
+#include <fstream>
+
+namespace Catch {
+
+    namespace {
+        static bool enableBazelEnvSupport() {
+#if defined( CATCH_CONFIG_BAZEL_SUPPORT )
+            return true;
+#else
+            return Detail::getEnv( "BAZEL_TEST" ) != nullptr;
+#endif
+        }
+
+        struct bazelShardingOptions {
+            unsigned int shardIndex, shardCount;
+            std::string shardFilePath;
+        };
+
+        static Optional<bazelShardingOptions> readBazelShardingOptions() {
+            const auto bazelShardIndex = Detail::getEnv( "TEST_SHARD_INDEX" );
+            const auto bazelShardTotal = Detail::getEnv( "TEST_TOTAL_SHARDS" );
+            const auto bazelShardInfoFile = Detail::getEnv( "TEST_SHARD_STATUS_FILE" );
+
+
+            const bool has_all =
+                bazelShardIndex && bazelShardTotal && bazelShardInfoFile;
+            if ( !has_all ) {
+                // We provide nice warning message if the input is
+                // misconfigured.
+                auto warn = []( const char* env_var ) {
+                    Catch::cerr()
+                        << "Warning: Bazel shard configuration is missing '"
+                        << env_var << "'. Shard configuration is skipped.\n";
+                };
+                if ( !bazelShardIndex ) {
+                    warn( "TEST_SHARD_INDEX" );
+                }
+                if ( !bazelShardTotal ) {
+                    warn( "TEST_TOTAL_SHARDS" );
+                }
+                if ( !bazelShardInfoFile ) {
+                    warn( "TEST_SHARD_STATUS_FILE" );
+                }
+                return {};
+            }
+
+            auto shardIndex = parseUInt( bazelShardIndex );
+            if ( !shardIndex ) {
+                Catch::cerr()
+                    << "Warning: could not parse 'TEST_SHARD_INDEX' ('" << bazelShardIndex
+                    << "') as unsigned int.\n";
+                return {};
+            }
+            auto shardTotal = parseUInt( bazelShardTotal );
+            if ( !shardTotal ) {
+                Catch::cerr()
+                    << "Warning: could not parse 'TEST_TOTAL_SHARD' ('"
+                    << bazelShardTotal << "') as unsigned int.\n";
+                return {};
+            }
+
+            return bazelShardingOptions{
+                *shardIndex, *shardTotal, bazelShardInfoFile };
+
+        }
+    } // end namespace
+
+
+    bool operator==( ProcessedReporterSpec const& lhs,
+                     ProcessedReporterSpec const& rhs ) {
+        return lhs.name == rhs.name &&
+               lhs.outputFilename == rhs.outputFilename &&
+               lhs.colourMode == rhs.colourMode &&
+               lhs.customOptions == rhs.customOptions;
+    }
+
+    Config::Config( ConfigData const& data ):
+        m_data( data ) {
+        // We need to trim filter specs to avoid trouble with superfluous
+        // whitespace (esp. important for bdd macros, as those are manually
+        // aligned with whitespace).
+
+        for (auto& elem : m_data.testsOrTags) {
+            elem = trim(elem);
+        }
+        for (auto& elem : m_data.sectionsToRun) {
+            elem = trim(elem);
+        }
+
+        // Insert the default reporter if user hasn't asked for a specific one
+        if ( m_data.reporterSpecifications.empty() ) {
+#if defined( CATCH_CONFIG_DEFAULT_REPORTER )
+            const auto default_spec = CATCH_CONFIG_DEFAULT_REPORTER;
+#else
+            const auto default_spec = "console";
+#endif
+            auto parsed = parseReporterSpec(default_spec);
+            CATCH_ENFORCE( parsed,
+                           "Cannot parse the provided default reporter spec: '"
+                               << default_spec << '\'' );
+            m_data.reporterSpecifications.push_back( std::move( *parsed ) );
+        }
+
+        if ( enableBazelEnvSupport() ) {
+            readBazelEnvVars();
+        }
+
+        // Bazel support can modify the test specs, so parsing has to happen
+        // after reading Bazel env vars.
+        TestSpecParser parser( ITagAliasRegistry::get() );
+        if ( !m_data.testsOrTags.empty() ) {
+            m_hasTestFilters = true;
+            for ( auto const& testOrTags : m_data.testsOrTags ) {
+                parser.parse( testOrTags );
+            }
+        }
+        m_testSpec = parser.testSpec();
+
+
+        // We now fixup the reporter specs to handle default output spec,
+        // default colour spec, etc
+        bool defaultOutputUsed = false;
+        for ( auto const& reporterSpec : m_data.reporterSpecifications ) {
+            // We do the default-output check separately, while always
+            // using the default output below to make the code simpler
+            // and avoid superfluous copies.
+            if ( reporterSpec.outputFile().none() ) {
+                CATCH_ENFORCE( !defaultOutputUsed,
+                               "Internal error: cannot use default output for "
+                               "multiple reporters" );
+                defaultOutputUsed = true;
+            }
+
+            m_processedReporterSpecs.push_back( ProcessedReporterSpec{
+                reporterSpec.name(),
+                reporterSpec.outputFile() ? *reporterSpec.outputFile()
+                                          : data.defaultOutputFilename,
+                reporterSpec.colourMode().valueOr( data.defaultColourMode ),
+                reporterSpec.customOptions() } );
+        }
+    }
+
+    Config::~Config() = default;
+
+
+    bool Config::listTests() const          { return m_data.listTests; }
+    bool Config::listTags() const           { return m_data.listTags; }
+    bool Config::listReporters() const      { return m_data.listReporters; }
+    bool Config::listListeners() const      { return m_data.listListeners; }
+
+    std::vector<std::string> const& Config::getTestsOrTags() const { return m_data.testsOrTags; }
+    std::vector<std::string> const& Config::getSectionsToRun() const { return m_data.sectionsToRun; }
+
+    std::vector<ReporterSpec> const& Config::getReporterSpecs() const {
+        return m_data.reporterSpecifications;
+    }
+
+    std::vector<ProcessedReporterSpec> const&
+    Config::getProcessedReporterSpecs() const {
+        return m_processedReporterSpecs;
+    }
+
+    TestSpec const& Config::testSpec() const { return m_testSpec; }
+    bool Config::hasTestFilters() const { return m_hasTestFilters; }
+
+    bool Config::showHelp() const { return m_data.showHelp; }
+
+    // IConfig interface
+    bool Config::allowThrows() const                   { return !m_data.noThrow; }
+    StringRef Config::name() const { return m_data.name.empty() ? m_data.processName : m_data.name; }
+    bool Config::includeSuccessfulResults() const      { return m_data.showSuccessfulTests; }
+    bool Config::warnAboutMissingAssertions() const {
+        return !!( m_data.warnings & WarnAbout::NoAssertions );
+    }
+    bool Config::warnAboutUnmatchedTestSpecs() const {
+        return !!( m_data.warnings & WarnAbout::UnmatchedTestSpec );
+    }
+    bool Config::zeroTestsCountAsSuccess() const       { return m_data.allowZeroTests; }
+    ShowDurations Config::showDurations() const        { return m_data.showDurations; }
+    double Config::minDuration() const                 { return m_data.minDuration; }
+    TestRunOrder Config::runOrder() const              { return m_data.runOrder; }
+    uint32_t Config::rngSeed() const                   { return m_data.rngSeed; }
+    unsigned int Config::shardCount() const            { return m_data.shardCount; }
+    unsigned int Config::shardIndex() const            { return m_data.shardIndex; }
+    ColourMode Config::defaultColourMode() const       { return m_data.defaultColourMode; }
+    bool Config::shouldDebugBreak() const              { return m_data.shouldDebugBreak; }
+    int Config::abortAfter() const                     { return m_data.abortAfter; }
+    bool Config::showInvisibles() const                { return m_data.showInvisibles; }
+    Verbosity Config::verbosity() const                { return m_data.verbosity; }
+
+    bool Config::skipBenchmarks() const                           { return m_data.skipBenchmarks; }
+    bool Config::benchmarkNoAnalysis() const                      { return m_data.benchmarkNoAnalysis; }
+    unsigned int Config::benchmarkSamples() const                 { return m_data.benchmarkSamples; }
+    double Config::benchmarkConfidenceInterval() const            { return m_data.benchmarkConfidenceInterval; }
+    unsigned int Config::benchmarkResamples() const               { return m_data.benchmarkResamples; }
+    std::chrono::milliseconds Config::benchmarkWarmupTime() const { return std::chrono::milliseconds(m_data.benchmarkWarmupTime); }
+
+    void Config::readBazelEnvVars() {
+        // Register a JUnit reporter for Bazel. Bazel sets an environment
+        // variable with the path to XML output. If this file is written to
+        // during test, Bazel will not generate a default XML output.
+        // This allows the XML output file to contain higher level of detail
+        // than what is possible otherwise.
+        const auto bazelOutputFile = Detail::getEnv( "XML_OUTPUT_FILE" );
+
+        if ( bazelOutputFile ) {
+            m_data.reporterSpecifications.push_back(
+                { "junit", std::string( bazelOutputFile ), {}, {} } );
+        }
+
+        const auto bazelTestSpec = Detail::getEnv( "TESTBRIDGE_TEST_ONLY" );
+        if ( bazelTestSpec ) {
+            // Presumably the test spec from environment should overwrite
+            // the one we got from CLI (if we got any)
+            m_data.testsOrTags.clear();
+            m_data.testsOrTags.push_back( bazelTestSpec );
+        }
+
+        const auto bazelShardOptions = readBazelShardingOptions();
+        if ( bazelShardOptions ) {
+            std::ofstream f( bazelShardOptions->shardFilePath,
+                             std::ios_base::out | std::ios_base::trunc );
+            if ( f.is_open() ) {
+                f << "";
+                m_data.shardIndex = bazelShardOptions->shardIndex;
+                m_data.shardCount = bazelShardOptions->shardCount;
+            }
+        }
+    }
+
+} // end namespace Catch
+
+
+
+
+
+namespace Catch {
+    std::uint32_t getSeed() {
+        return getCurrentContext().getConfig()->rngSeed();
+    }
+}
+
+
+
+#include <cassert>
+#include <stack>
+
+namespace Catch {
+
+    ////////////////////////////////////////////////////////////////////////////
+
+
+    ScopedMessage::ScopedMessage( MessageBuilder&& builder ):
+        m_info( CATCH_MOVE(builder.m_info) ) {
+        m_info.message = builder.m_stream.str();
+        getResultCapture().pushScopedMessage( m_info );
+    }
+
+    ScopedMessage::ScopedMessage( ScopedMessage&& old ) noexcept:
+        m_info( CATCH_MOVE( old.m_info ) ) {
+        old.m_moved = true;
+    }
+
+    ScopedMessage::~ScopedMessage() {
+        if ( !uncaught_exceptions() && !m_moved ){
+            getResultCapture().popScopedMessage(m_info);
+        }
+    }
+
+
+    Capturer::Capturer( StringRef macroName,
+                        SourceLineInfo const& lineInfo,
+                        ResultWas::OfType resultType,
+                        StringRef names ):
+        m_resultCapture( getResultCapture() ) {
+        auto trimmed = [&] (size_t start, size_t end) {
+            while (names[start] == ',' || isspace(static_cast<unsigned char>(names[start]))) {
+                ++start;
+            }
+            while (names[end] == ',' || isspace(static_cast<unsigned char>(names[end]))) {
+                --end;
+            }
+            return names.substr(start, end - start + 1);
+        };
+        auto skipq = [&] (size_t start, char quote) {
+            for (auto i = start + 1; i < names.size() ; ++i) {
+                if (names[i] == quote)
+                    return i;
+                if (names[i] == '\\')
+                    ++i;
+            }
+            CATCH_INTERNAL_ERROR("CAPTURE parsing encountered unmatched quote");
+        };
+
+        size_t start = 0;
+        std::stack<char> openings;
+        for (size_t pos = 0; pos < names.size(); ++pos) {
+            char c = names[pos];
+            switch (c) {
+            case '[':
+            case '{':
+            case '(':
+            // It is basically impossible to disambiguate between
+            // comparison and start of template args in this context
+//            case '<':
+                openings.push(c);
+                break;
+            case ']':
+            case '}':
+            case ')':
+//           case '>':
+                openings.pop();
+                break;
+            case '"':
+            case '\'':
+                pos = skipq(pos, c);
+                break;
+            case ',':
+                if (start != pos && openings.empty()) {
+                    m_messages.emplace_back(macroName, lineInfo, resultType);
+                    m_messages.back().message = static_cast<std::string>(trimmed(start, pos));
+                    m_messages.back().message += " := ";
+                    start = pos;
+                }
+                break;
+            default:; // noop
+            }
+        }
+        assert(openings.empty() && "Mismatched openings");
+        m_messages.emplace_back(macroName, lineInfo, resultType);
+        m_messages.back().message = static_cast<std::string>(trimmed(start, names.size() - 1));
+        m_messages.back().message += " := ";
+    }
+    Capturer::~Capturer() {
+        if ( !uncaught_exceptions() ){
+            assert( m_captured == m_messages.size() );
+            for( size_t i = 0; i < m_captured; ++i  )
+                m_resultCapture.popScopedMessage( m_messages[i] );
+        }
+    }
+
+    void Capturer::captureValue( size_t index, std::string const& value ) {
+        assert( index < m_messages.size() );
+        m_messages[index].message += value;
+        m_resultCapture.pushScopedMessage( m_messages[index] );
+        m_captured++;
+    }
+
+} // end namespace Catch
+
+
+
+
+#include <exception>
+
+namespace Catch {
+
+    namespace {
+
+        class RegistryHub : public IRegistryHub,
+                            public IMutableRegistryHub,
+                            private Detail::NonCopyable {
+
+        public: // IRegistryHub
+            RegistryHub() = default;
+            ReporterRegistry const& getReporterRegistry() const override {
+                return m_reporterRegistry;
+            }
+            ITestCaseRegistry const& getTestCaseRegistry() const override {
+                return m_testCaseRegistry;
+            }
+            IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const override {
+                return m_exceptionTranslatorRegistry;
+            }
+            ITagAliasRegistry const& getTagAliasRegistry() const override {
+                return m_tagAliasRegistry;
+            }
+            StartupExceptionRegistry const& getStartupExceptionRegistry() const override {
+                return m_exceptionRegistry;
+            }
+
+        public: // IMutableRegistryHub
+            void registerReporter( std::string const& name, IReporterFactoryPtr factory ) override {
+                m_reporterRegistry.registerReporter( name, CATCH_MOVE(factory) );
+            }
+            void registerListener( Detail::unique_ptr<EventListenerFactory> factory ) override {
+                m_reporterRegistry.registerListener( CATCH_MOVE(factory) );
+            }
+            void registerTest( Detail::unique_ptr<TestCaseInfo>&& testInfo, Detail::unique_ptr<ITestInvoker>&& invoker ) override {
+                m_testCaseRegistry.registerTest( CATCH_MOVE(testInfo), CATCH_MOVE(invoker) );
+            }
+            void registerTranslator( Detail::unique_ptr<IExceptionTranslator>&& translator ) override {
+                m_exceptionTranslatorRegistry.registerTranslator( CATCH_MOVE(translator) );
+            }
+            void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) override {
+                m_tagAliasRegistry.add( alias, tag, lineInfo );
+            }
+            void registerStartupException() noexcept override {
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+                m_exceptionRegistry.add(std::current_exception());
+#else
+                CATCH_INTERNAL_ERROR("Attempted to register active exception under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
+#endif
+            }
+            IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() override {
+                return m_enumValuesRegistry;
+            }
+
+        private:
+            TestRegistry m_testCaseRegistry;
+            ReporterRegistry m_reporterRegistry;
+            ExceptionTranslatorRegistry m_exceptionTranslatorRegistry;
+            TagAliasRegistry m_tagAliasRegistry;
+            StartupExceptionRegistry m_exceptionRegistry;
+            Detail::EnumValuesRegistry m_enumValuesRegistry;
+        };
+    }
+
+    using RegistryHubSingleton = Singleton<RegistryHub, IRegistryHub, IMutableRegistryHub>;
+
+    IRegistryHub const& getRegistryHub() {
+        return RegistryHubSingleton::get();
+    }
+    IMutableRegistryHub& getMutableRegistryHub() {
+        return RegistryHubSingleton::getMutable();
+    }
+    void cleanUp() {
+        cleanupSingletons();
+        cleanUpContext();
+    }
+    std::string translateActiveException() {
+        return getRegistryHub().getExceptionTranslatorRegistry().translateActiveException();
+    }
+
+
+} // end namespace Catch
+
+
+
+#include <algorithm>
+#include <cassert>
+#include <exception>
+#include <iomanip>
+#include <set>
+
+namespace Catch {
+
+    namespace {
+        static constexpr int TestFailureExitCode = 42;
+        static constexpr int UnspecifiedErrorExitCode = 1;
+        static constexpr int AllTestsSkippedExitCode = 4;
+        static constexpr int NoTestsRunExitCode = 2;
+        static constexpr int UnmatchedTestSpecExitCode = 3;
+        static constexpr int InvalidTestSpecExitCode = 5;
+
+
+        IEventListenerPtr createReporter(std::string const& reporterName, ReporterConfig&& config) {
+            auto reporter = Catch::getRegistryHub().getReporterRegistry().create(reporterName, CATCH_MOVE(config));
+            CATCH_ENFORCE(reporter, "No reporter registered with name: '" << reporterName << '\'');
+
+            return reporter;
+        }
+
+        IEventListenerPtr prepareReporters(Config const* config) {
+            if (Catch::getRegistryHub().getReporterRegistry().getListeners().empty()
+                    && config->getProcessedReporterSpecs().size() == 1) {
+                auto const& spec = config->getProcessedReporterSpecs()[0];
+                return createReporter(
+                    spec.name,
+                    ReporterConfig( config,
+                                    makeStream( spec.outputFilename ),
+                                    spec.colourMode,
+                                    spec.customOptions ) );
+            }
+
+            auto multi = Detail::make_unique<MultiReporter>(config);
+
+            auto const& listeners = Catch::getRegistryHub().getReporterRegistry().getListeners();
+            for (auto const& listener : listeners) {
+                multi->addListener(listener->create(config));
+            }
+
+            for ( auto const& reporterSpec : config->getProcessedReporterSpecs() ) {
+                multi->addReporter( createReporter(
+                    reporterSpec.name,
+                    ReporterConfig( config,
+                                    makeStream( reporterSpec.outputFilename ),
+                                    reporterSpec.colourMode,
+                                    reporterSpec.customOptions ) ) );
+            }
+
+            return multi;
+        }
+
+        class TestGroup {
+        public:
+            explicit TestGroup(IEventListenerPtr&& reporter, Config const* config):
+                m_reporter(reporter.get()),
+                m_config{config},
+                m_context{config, CATCH_MOVE(reporter)} {
+
+                assert( m_config->testSpec().getInvalidSpecs().empty() &&
+                        "Invalid test specs should be handled before running tests" );
+
+                auto const& allTestCases = getAllTestCasesSorted(*m_config);
+                auto const& testSpec = m_config->testSpec();
+                if ( !testSpec.hasFilters() ) {
+                    for ( auto const& test : allTestCases ) {
+                        if ( !test.getTestCaseInfo().isHidden() ) {
+                            m_tests.emplace( &test );
+                        }
+                    }
+                } else {
+                    m_matches =
+                        testSpec.matchesByFilter( allTestCases, *m_config );
+                    for ( auto const& match : m_matches ) {
+                        m_tests.insert( match.tests.begin(),
+                                        match.tests.end() );
+                    }
+                }
+
+                m_tests = createShard(m_tests, m_config->shardCount(), m_config->shardIndex());
+            }
+
+            Totals execute() {
+                Totals totals;
+                for (auto const& testCase : m_tests) {
+                    if (!m_context.aborting())
+                        totals += m_context.runTest(*testCase);
+                    else
+                        m_reporter->skipTest(testCase->getTestCaseInfo());
+                }
+
+                for (auto const& match : m_matches) {
+                    if (match.tests.empty()) {
+                        m_unmatchedTestSpecs = true;
+                        m_reporter->noMatchingTestCases( match.name );
+                    }
+                }
+
+                return totals;
+            }
+
+            bool hadUnmatchedTestSpecs() const {
+                return m_unmatchedTestSpecs;
+            }
+
+
+        private:
+            IEventListener* m_reporter;
+            Config const* m_config;
+            RunContext m_context;
+            std::set<TestCaseHandle const*> m_tests;
+            TestSpec::Matches m_matches;
+            bool m_unmatchedTestSpecs = false;
+        };
+
+        void applyFilenamesAsTags() {
+            for (auto const& testInfo : getRegistryHub().getTestCaseRegistry().getAllInfos()) {
+                testInfo->addFilenameTag();
+            }
+        }
+
+    } // anon namespace
+
+    Session::Session() {
+        static bool alreadyInstantiated = false;
+        if( alreadyInstantiated ) {
+            CATCH_TRY { CATCH_INTERNAL_ERROR( "Only one instance of Catch::Session can ever be used" ); }
+            CATCH_CATCH_ALL { getMutableRegistryHub().registerStartupException(); }
+        }
+
+        // There cannot be exceptions at startup in no-exception mode.
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+        const auto& exceptions = getRegistryHub().getStartupExceptionRegistry().getExceptions();
+        if ( !exceptions.empty() ) {
+            config();
+            getCurrentMutableContext().setConfig(m_config.get());
+
+            m_startupExceptions = true;
+            auto errStream = makeStream( "%stderr" );
+            auto colourImpl = makeColourImpl(
+                ColourMode::PlatformDefault, errStream.get() );
+            auto guard = colourImpl->guardColour( Colour::Red );
+            errStream->stream() << "Errors occurred during startup!" << '\n';
+            // iterate over all exceptions and notify user
+            for ( const auto& ex_ptr : exceptions ) {
+                try {
+                    std::rethrow_exception(ex_ptr);
+                } catch ( std::exception const& ex ) {
+                    errStream->stream() << TextFlow::Column( ex.what() ).indent(2) << '\n';
+                }
+            }
+        }
+#endif
+
+        alreadyInstantiated = true;
+        m_cli = makeCommandLineParser( m_configData );
+    }
+    Session::~Session() {
+        Catch::cleanUp();
+    }
+
+    void Session::showHelp() const {
+        Catch::cout()
+                << "\nCatch2 v" << libraryVersion() << '\n'
+                << m_cli << '\n'
+                << "For more detailed usage please see the project docs\n\n" << std::flush;
+    }
+    void Session::libIdentify() {
+        Catch::cout()
+                << std::left << std::setw(16) << "description: " << "A Catch2 test executable\n"
+                << std::left << std::setw(16) << "category: " << "testframework\n"
+                << std::left << std::setw(16) << "framework: " << "Catch2\n"
+                << std::left << std::setw(16) << "version: " << libraryVersion() << '\n' << std::flush;
+    }
+
+    int Session::applyCommandLine( int argc, char const * const * argv ) {
+        if ( m_startupExceptions ) { return UnspecifiedErrorExitCode; }
+
+        auto result = m_cli.parse( Clara::Args( argc, argv ) );
+
+        if( !result ) {
+            config();
+            getCurrentMutableContext().setConfig(m_config.get());
+            auto errStream = makeStream( "%stderr" );
+            auto colour = makeColourImpl( ColourMode::PlatformDefault, errStream.get() );
+
+            errStream->stream()
+                << colour->guardColour( Colour::Red )
+                << "\nError(s) in input:\n"
+                << TextFlow::Column( result.errorMessage() ).indent( 2 )
+                << "\n\n";
+            errStream->stream() << "Run with -? for usage\n\n" << std::flush;
+            return UnspecifiedErrorExitCode;
+        }
+
+        if( m_configData.showHelp )
+            showHelp();
+        if( m_configData.libIdentify )
+            libIdentify();
+
+        m_config.reset();
+        return 0;
+    }
+
+#if defined(CATCH_CONFIG_WCHAR) && defined(_WIN32) && defined(UNICODE)
+    int Session::applyCommandLine( int argc, wchar_t const * const * argv ) {
+
+        char **utf8Argv = new char *[ argc ];
+
+        for ( int i = 0; i < argc; ++i ) {
+            int bufSize = WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, nullptr, 0, nullptr, nullptr );
+
+            utf8Argv[ i ] = new char[ bufSize ];
+
+            WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, utf8Argv[i], bufSize, nullptr, nullptr );
+        }
+
+        int returnCode = applyCommandLine( argc, utf8Argv );
+
+        for ( int i = 0; i < argc; ++i )
+            delete [] utf8Argv[ i ];
+
+        delete [] utf8Argv;
+
+        return returnCode;
+    }
+#endif
+
+    void Session::useConfigData( ConfigData const& configData ) {
+        m_configData = configData;
+        m_config.reset();
+    }
+
+    int Session::run() {
+        if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeStart ) != 0 ) {
+            Catch::cout() << "...waiting for enter/ return before starting\n" << std::flush;
+            static_cast<void>(std::getchar());
+        }
+        int exitCode = runInternal();
+        if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeExit ) != 0 ) {
+            Catch::cout() << "...waiting for enter/ return before exiting, with code: " << exitCode << '\n' << std::flush;
+            static_cast<void>(std::getchar());
+        }
+        return exitCode;
+    }
+
+    Clara::Parser const& Session::cli() const {
+        return m_cli;
+    }
+    void Session::cli( Clara::Parser const& newParser ) {
+        m_cli = newParser;
+    }
+    ConfigData& Session::configData() {
+        return m_configData;
+    }
+    Config& Session::config() {
+        if( !m_config )
+            m_config = Detail::make_unique<Config>( m_configData );
+        return *m_config;
+    }
+
+    int Session::runInternal() {
+        if ( m_startupExceptions ) { return UnspecifiedErrorExitCode; }
+
+        if (m_configData.showHelp || m_configData.libIdentify) {
+            return 0;
+        }
+
+        if ( m_configData.shardIndex >= m_configData.shardCount ) {
+            Catch::cerr() << "The shard count (" << m_configData.shardCount
+                          << ") must be greater than the shard index ("
+                          << m_configData.shardIndex << ")\n"
+                          << std::flush;
+            return UnspecifiedErrorExitCode;
+        }
+
+        CATCH_TRY {
+            config(); // Force config to be constructed
+
+            seedRng( *m_config );
+
+            if (m_configData.filenamesAsTags) {
+                applyFilenamesAsTags();
+            }
+
+            // Set up global config instance before we start calling into other functions
+            getCurrentMutableContext().setConfig(m_config.get());
+
+            // Create reporter(s) so we can route listings through them
+            auto reporter = prepareReporters(m_config.get());
+
+            auto const& invalidSpecs = m_config->testSpec().getInvalidSpecs();
+            if ( !invalidSpecs.empty() ) {
+                for ( auto const& spec : invalidSpecs ) {
+                    reporter->reportInvalidTestSpec( spec );
+                }
+                return InvalidTestSpecExitCode;
+            }
+
+
+            // Handle list request
+            if (list(*reporter, *m_config)) {
+                return 0;
+            }
+
+            TestGroup tests { CATCH_MOVE(reporter), m_config.get() };
+            auto const totals = tests.execute();
+
+            if ( tests.hadUnmatchedTestSpecs()
+                && m_config->warnAboutUnmatchedTestSpecs() ) {
+                // UnmatchedTestSpecExitCode
+                return UnmatchedTestSpecExitCode;
+            }
+
+            if ( totals.testCases.total() == 0
+                && !m_config->zeroTestsCountAsSuccess() ) {
+                return NoTestsRunExitCode;
+            }
+
+            if ( totals.testCases.total() > 0 &&
+                 totals.testCases.total() == totals.testCases.skipped
+                && !m_config->zeroTestsCountAsSuccess() ) {
+                return AllTestsSkippedExitCode;
+            }
+
+            if ( totals.assertions.failed ) { return TestFailureExitCode; }
+            return 0;
+
+        }
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+        catch( std::exception& ex ) {
+            Catch::cerr() << ex.what() << '\n' << std::flush;
+            return UnspecifiedErrorExitCode;
+        }
+#endif
+    }
+
+} // end namespace Catch
+
+
+
+
+namespace Catch {
+
+    RegistrarForTagAliases::RegistrarForTagAliases(char const* alias, char const* tag, SourceLineInfo const& lineInfo) {
+        CATCH_TRY {
+            getMutableRegistryHub().registerTagAlias(alias, tag, lineInfo);
+        } CATCH_CATCH_ALL {
+            // Do not throw when constructing global objects, instead register the exception to be processed later
+            getMutableRegistryHub().registerStartupException();
+        }
+    }
+
+}
+
+
+
+#include <cassert>
+#include <cctype>
+#include <algorithm>
+
+namespace Catch {
+
+    namespace {
+        using TCP_underlying_type = uint8_t;
+        static_assert(sizeof(TestCaseProperties) == sizeof(TCP_underlying_type),
+                      "The size of the TestCaseProperties is different from the assumed size");
+
+        constexpr TestCaseProperties operator|(TestCaseProperties lhs, TestCaseProperties rhs) {
+            return static_cast<TestCaseProperties>(
+                static_cast<TCP_underlying_type>(lhs) | static_cast<TCP_underlying_type>(rhs)
+            );
+        }
+
+        constexpr TestCaseProperties& operator|=(TestCaseProperties& lhs, TestCaseProperties rhs) {
+            lhs = static_cast<TestCaseProperties>(
+                static_cast<TCP_underlying_type>(lhs) | static_cast<TCP_underlying_type>(rhs)
+            );
+            return lhs;
+        }
+
+        constexpr TestCaseProperties operator&(TestCaseProperties lhs, TestCaseProperties rhs) {
+            return static_cast<TestCaseProperties>(
+                static_cast<TCP_underlying_type>(lhs) & static_cast<TCP_underlying_type>(rhs)
+            );
+        }
+
+        constexpr bool applies(TestCaseProperties tcp) {
+            static_assert(static_cast<TCP_underlying_type>(TestCaseProperties::None) == 0,
+                          "TestCaseProperties::None must be equal to 0");
+            return tcp != TestCaseProperties::None;
+        }
+
+        TestCaseProperties parseSpecialTag( StringRef tag ) {
+            if( !tag.empty() && tag[0] == '.' )
+                return TestCaseProperties::IsHidden;
+            else if( tag == "!throws"_sr )
+                return TestCaseProperties::Throws;
+            else if( tag == "!shouldfail"_sr )
+                return TestCaseProperties::ShouldFail;
+            else if( tag == "!mayfail"_sr )
+                return TestCaseProperties::MayFail;
+            else if( tag == "!nonportable"_sr )
+                return TestCaseProperties::NonPortable;
+            else if( tag == "!benchmark"_sr )
+                return TestCaseProperties::Benchmark | TestCaseProperties::IsHidden;
+            else
+                return TestCaseProperties::None;
+        }
+        bool isReservedTag( StringRef tag ) {
+            return parseSpecialTag( tag ) == TestCaseProperties::None
+                && tag.size() > 0
+                && !std::isalnum( static_cast<unsigned char>(tag[0]) );
+        }
+        void enforceNotReservedTag( StringRef tag, SourceLineInfo const& _lineInfo ) {
+            CATCH_ENFORCE( !isReservedTag(tag),
+                          "Tag name: [" << tag << "] is not allowed.\n"
+                          << "Tag names starting with non alphanumeric characters are reserved\n"
+                          << _lineInfo );
+        }
+
+        std::string makeDefaultName() {
+            static size_t counter = 0;
+            return "Anonymous test case " + std::to_string(++counter);
+        }
+
+        constexpr StringRef extractFilenamePart(StringRef filename) {
+            size_t lastDot = filename.size();
+            while (lastDot > 0 && filename[lastDot - 1] != '.') {
+                --lastDot;
+            }
+            // In theory we could have filename without any extension in it
+            if ( lastDot == 0 ) { return StringRef(); }
+
+            --lastDot;
+            size_t nameStart = lastDot;
+            while (nameStart > 0 && filename[nameStart - 1] != '/' && filename[nameStart - 1] != '\\') {
+                --nameStart;
+            }
+
+            return filename.substr(nameStart, lastDot - nameStart);
+        }
+
+        // Returns the upper bound on size of extra tags ([#file]+[.])
+        constexpr size_t sizeOfExtraTags(StringRef filepath) {
+            // [.] is 3, [#] is another 3
+            const size_t extras = 3 + 3;
+            return extractFilenamePart(filepath).size() + extras;
+        }
+    } // end unnamed namespace
+
+    bool operator<(  Tag const& lhs, Tag const& rhs ) {
+        Detail::CaseInsensitiveLess cmp;
+        return cmp( lhs.original, rhs.original );
+    }
+    bool operator==( Tag const& lhs, Tag const& rhs ) {
+        Detail::CaseInsensitiveEqualTo cmp;
+        return cmp( lhs.original, rhs.original );
+    }
+
+    Detail::unique_ptr<TestCaseInfo>
+        makeTestCaseInfo(StringRef _className,
+                         NameAndTags const& nameAndTags,
+                         SourceLineInfo const& _lineInfo ) {
+        return Detail::make_unique<TestCaseInfo>(_className, nameAndTags, _lineInfo);
+    }
+
+    TestCaseInfo::TestCaseInfo(StringRef _className,
+                               NameAndTags const& _nameAndTags,
+                               SourceLineInfo const& _lineInfo):
+        name( _nameAndTags.name.empty() ? makeDefaultName() : _nameAndTags.name ),
+        className( _className ),
+        lineInfo( _lineInfo )
+    {
+        StringRef originalTags = _nameAndTags.tags;
+        // We need to reserve enough space to store all of the tags
+        // (including optional hidden tag and filename tag)
+        auto requiredSize = originalTags.size() + sizeOfExtraTags(_lineInfo.file);
+        backingTags.reserve(requiredSize);
+
+        // We cannot copy the tags directly, as we need to normalize
+        // some tags, so that [.foo] is copied as [.][foo].
+        size_t tagStart = 0;
+        size_t tagEnd = 0;
+        bool inTag = false;
+        for (size_t idx = 0; idx < originalTags.size(); ++idx) {
+            auto c = originalTags[idx];
+            if (c == '[') {
+                CATCH_ENFORCE(
+                    !inTag,
+                    "Found '[' inside a tag while registering test case '"
+                        << _nameAndTags.name << "' at " << _lineInfo );
+
+                inTag = true;
+                tagStart = idx;
+            }
+            if (c == ']') {
+                CATCH_ENFORCE(
+                    inTag,
+                    "Found unmatched ']' while registering test case '"
+                        << _nameAndTags.name << "' at " << _lineInfo );
+
+                inTag = false;
+                tagEnd = idx;
+                assert(tagStart < tagEnd);
+
+                // We need to check the tag for special meanings, copy
+                // it over to backing storage and actually reference the
+                // backing storage in the saved tags
+                StringRef tagStr = originalTags.substr(tagStart+1, tagEnd - tagStart - 1);
+                CATCH_ENFORCE( !tagStr.empty(),
+                               "Found an empty tag while registering test case '"
+                                   << _nameAndTags.name << "' at "
+                                   << _lineInfo );
+
+                enforceNotReservedTag(tagStr, lineInfo);
+                properties |= parseSpecialTag(tagStr);
+                // When copying a tag to the backing storage, we need to
+                // check if it is a merged hide tag, such as [.foo], and
+                // if it is, we need to handle it as if it was [foo].
+                if (tagStr.size() > 1 && tagStr[0] == '.') {
+                    tagStr = tagStr.substr(1, tagStr.size() - 1);
+                }
+                // We skip over dealing with the [.] tag, as we will add
+                // it later unconditionally and then sort and unique all
+                // the tags.
+                internalAppendTag(tagStr);
+            }
+        }
+        CATCH_ENFORCE( !inTag,
+                       "Found an unclosed tag while registering test case '"
+                           << _nameAndTags.name << "' at " << _lineInfo );
+
+
+        // Add [.] if relevant
+        if (isHidden()) {
+            internalAppendTag("."_sr);
+        }
+
+        // Sort and prepare tags
+        std::sort(begin(tags), end(tags));
+        tags.erase(std::unique(begin(tags), end(tags)),
+                   end(tags));
+    }
+
+    bool TestCaseInfo::isHidden() const {
+        return applies( properties & TestCaseProperties::IsHidden );
+    }
+    bool TestCaseInfo::throws() const {
+        return applies( properties & TestCaseProperties::Throws );
+    }
+    bool TestCaseInfo::okToFail() const {
+        return applies( properties & (TestCaseProperties::ShouldFail | TestCaseProperties::MayFail ) );
+    }
+    bool TestCaseInfo::expectedToFail() const {
+        return applies( properties & (TestCaseProperties::ShouldFail) );
+    }
+
+    void TestCaseInfo::addFilenameTag() {
+        std::string combined("#");
+        combined += extractFilenamePart(lineInfo.file);
+        internalAppendTag(combined);
+    }
+
+    std::string TestCaseInfo::tagsAsString() const {
+        std::string ret;
+        // '[' and ']' per tag
+        std::size_t full_size = 2 * tags.size();
+        for (const auto& tag : tags) {
+            full_size += tag.original.size();
+        }
+        ret.reserve(full_size);
+        for (const auto& tag : tags) {
+            ret.push_back('[');
+            ret += tag.original;
+            ret.push_back(']');
+        }
+
+        return ret;
+    }
+
+    void TestCaseInfo::internalAppendTag(StringRef tagStr) {
+        backingTags += '[';
+        const auto backingStart = backingTags.size();
+        backingTags += tagStr;
+        const auto backingEnd = backingTags.size();
+        backingTags += ']';
+        tags.emplace_back(StringRef(backingTags.c_str() + backingStart, backingEnd - backingStart));
+    }
+
+    bool operator<( TestCaseInfo const& lhs, TestCaseInfo const& rhs ) {
+        // We want to avoid redoing the string comparisons multiple times,
+        // so we store the result of a three-way comparison before using
+        // it in the actual comparison logic.
+        const auto cmpName = lhs.name.compare( rhs.name );
+        if ( cmpName != 0 ) {
+            return cmpName < 0;
+        }
+        const auto cmpClassName = lhs.className.compare( rhs.className );
+        if ( cmpClassName != 0 ) {
+            return cmpClassName < 0;
+        }
+        return lhs.tags < rhs.tags;
+    }
+
+} // end namespace Catch
+
+
+
+#include <algorithm>
+#include <string>
+#include <vector>
+#include <ostream>
+
+namespace Catch {
+
+    TestSpec::Pattern::Pattern( std::string const& name )
+    : m_name( name )
+    {}
+
+    TestSpec::Pattern::~Pattern() = default;
+
+    std::string const& TestSpec::Pattern::name() const {
+        return m_name;
+    }
+
+
+    TestSpec::NamePattern::NamePattern( std::string const& name, std::string const& filterString )
+    : Pattern( filterString )
+    , m_wildcardPattern( toLower( name ), CaseSensitive::No )
+    {}
+
+    bool TestSpec::NamePattern::matches( TestCaseInfo const& testCase ) const {
+        return m_wildcardPattern.matches( testCase.name );
+    }
+
+    void TestSpec::NamePattern::serializeTo( std::ostream& out ) const {
+        out << '"' << name() << '"';
+    }
+
+
+    TestSpec::TagPattern::TagPattern( std::string const& tag, std::string const& filterString )
+    : Pattern( filterString )
+    , m_tag( tag )
+    {}
+
+    bool TestSpec::TagPattern::matches( TestCaseInfo const& testCase ) const {
+        return std::find( begin( testCase.tags ),
+                          end( testCase.tags ),
+                          Tag( m_tag ) ) != end( testCase.tags );
+    }
+
+    void TestSpec::TagPattern::serializeTo( std::ostream& out ) const {
+        out << name();
+    }
+
+    bool TestSpec::Filter::matches( TestCaseInfo const& testCase ) const {
+        bool should_use = !testCase.isHidden();
+        for (auto const& pattern : m_required) {
+            should_use = true;
+            if (!pattern->matches(testCase)) {
+                return false;
+            }
+        }
+        for (auto const& pattern : m_forbidden) {
+            if (pattern->matches(testCase)) {
+                return false;
+            }
+        }
+        return should_use;
+    }
+
+    void TestSpec::Filter::serializeTo( std::ostream& out ) const {
+        bool first = true;
+        for ( auto const& pattern : m_required ) {
+            if ( !first ) {
+                out << ' ';
+            }
+            out << *pattern;
+            first = false;
+        }
+        for ( auto const& pattern : m_forbidden ) {
+            if ( !first ) {
+                out << ' ';
+            }
+            out << *pattern;
+            first = false;
+        }
+    }
+
+
+    std::string TestSpec::extractFilterName( Filter const& filter ) {
+        Catch::ReusableStringStream sstr;
+        sstr << filter;
+        return sstr.str();
+    }
+
+    bool TestSpec::hasFilters() const {
+        return !m_filters.empty();
+    }
+
+    bool TestSpec::matches( TestCaseInfo const& testCase ) const {
+        return std::any_of( m_filters.begin(), m_filters.end(), [&]( Filter const& f ){ return f.matches( testCase ); } );
+    }
+
+    TestSpec::Matches TestSpec::matchesByFilter( std::vector<TestCaseHandle> const& testCases, IConfig const& config ) const {
+        Matches matches;
+        matches.reserve( m_filters.size() );
+        for ( auto const& filter : m_filters ) {
+            std::vector<TestCaseHandle const*> currentMatches;
+            for ( auto const& test : testCases )
+                if ( isThrowSafe( test, config ) &&
+                     filter.matches( test.getTestCaseInfo() ) )
+                    currentMatches.emplace_back( &test );
+            matches.push_back(
+                FilterMatch{ extractFilterName( filter ), currentMatches } );
+        }
+        return matches;
+    }
+
+    const TestSpec::vectorStrings& TestSpec::getInvalidSpecs() const {
+        return m_invalidSpecs;
+    }
+
+    void TestSpec::serializeTo( std::ostream& out ) const {
+        bool first = true;
+        for ( auto const& filter : m_filters ) {
+            if ( !first ) {
+                out << ',';
+            }
+            out << filter;
+            first = false;
+        }
+    }
+
+}
+
+
+
+#include <chrono>
+
+namespace Catch {
+
+    namespace {
+        static auto getCurrentNanosecondsSinceEpoch() -> uint64_t {
+            return std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::steady_clock::now().time_since_epoch()).count();
+        }
+    } // end unnamed namespace
+
+    void Timer::start() {
+       m_nanoseconds = getCurrentNanosecondsSinceEpoch();
+    }
+    auto Timer::getElapsedNanoseconds() const -> uint64_t {
+        return getCurrentNanosecondsSinceEpoch() - m_nanoseconds;
+    }
+    auto Timer::getElapsedMicroseconds() const -> uint64_t {
+        return getElapsedNanoseconds()/1000;
+    }
+    auto Timer::getElapsedMilliseconds() const -> unsigned int {
+        return static_cast<unsigned int>(getElapsedMicroseconds()/1000);
+    }
+    auto Timer::getElapsedSeconds() const -> double {
+        return getElapsedMicroseconds()/1000000.0;
+    }
+
+
+} // namespace Catch
+
+
+
+
+#include <cmath>
+#include <iomanip>
+
+namespace Catch {
+
+namespace Detail {
+
+    namespace {
+        const int hexThreshold = 255;
+
+        struct Endianness {
+            enum Arch { Big, Little };
+
+            static Arch which() {
+                int one = 1;
+                // If the lowest byte we read is non-zero, we can assume
+                // that little endian format is used.
+                auto value = *reinterpret_cast<char*>(&one);
+                return value ? Little : Big;
+            }
+        };
+
+        template<typename T>
+        std::string fpToString(T value, int precision) {
+            if (Catch::isnan(value)) {
+                return "nan";
+            }
+
+            ReusableStringStream rss;
+            rss << std::setprecision(precision)
+                << std::fixed
+                << value;
+            std::string d = rss.str();
+            std::size_t i = d.find_last_not_of('0');
+            if (i != std::string::npos && i != d.size() - 1) {
+                if (d[i] == '.')
+                    i++;
+                d = d.substr(0, i + 1);
+            }
+            return d;
+        }
+    } // end unnamed namespace
+
+    std::string convertIntoString(StringRef string, bool escapeInvisibles) {
+        std::string ret;
+        // This is enough for the "don't escape invisibles" case, and a good
+        // lower bound on the "escape invisibles" case.
+        ret.reserve(string.size() + 2);
+
+        if (!escapeInvisibles) {
+            ret += '"';
+            ret += string;
+            ret += '"';
+            return ret;
+        }
+
+        ret += '"';
+        for (char c : string) {
+            switch (c) {
+            case '\r':
+                ret.append("\\r");
+                break;
+            case '\n':
+                ret.append("\\n");
+                break;
+            case '\t':
+                ret.append("\\t");
+                break;
+            case '\f':
+                ret.append("\\f");
+                break;
+            default:
+                ret.push_back(c);
+                break;
+            }
+        }
+        ret += '"';
+
+        return ret;
+    }
+
+    std::string convertIntoString(StringRef string) {
+        return convertIntoString(string, getCurrentContext().getConfig()->showInvisibles());
+    }
+
+    std::string rawMemoryToString( const void *object, std::size_t size ) {
+        // Reverse order for little endian architectures
+        int i = 0, end = static_cast<int>( size ), inc = 1;
+        if( Endianness::which() == Endianness::Little ) {
+            i = end-1;
+            end = inc = -1;
+        }
+
+        unsigned char const *bytes = static_cast<unsigned char const *>(object);
+        ReusableStringStream rss;
+        rss << "0x" << std::setfill('0') << std::hex;
+        for( ; i != end; i += inc )
+             rss << std::setw(2) << static_cast<unsigned>(bytes[i]);
+       return rss.str();
+    }
+} // end Detail namespace
+
+
+
+//// ======================================================= ////
+//
+//   Out-of-line defs for full specialization of StringMaker
+//
+//// ======================================================= ////
+
+std::string StringMaker<std::string>::convert(const std::string& str) {
+    return Detail::convertIntoString( str );
+}
+
+#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+std::string StringMaker<std::string_view>::convert(std::string_view str) {
+    return Detail::convertIntoString( StringRef( str.data(), str.size() ) );
+}
+#endif
+
+std::string StringMaker<char const*>::convert(char const* str) {
+    if (str) {
+        return Detail::convertIntoString( str );
+    } else {
+        return{ "{null string}" };
+    }
+}
+std::string StringMaker<char*>::convert(char* str) { // NOLINT(readability-non-const-parameter)
+    if (str) {
+        return Detail::convertIntoString( str );
+    } else {
+        return{ "{null string}" };
+    }
+}
+
+#ifdef CATCH_CONFIG_WCHAR
+std::string StringMaker<std::wstring>::convert(const std::wstring& wstr) {
+    std::string s;
+    s.reserve(wstr.size());
+    for (auto c : wstr) {
+        s += (c <= 0xff) ? static_cast<char>(c) : '?';
+    }
+    return ::Catch::Detail::stringify(s);
+}
+
+# ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+std::string StringMaker<std::wstring_view>::convert(std::wstring_view str) {
+    return StringMaker<std::wstring>::convert(std::wstring(str));
+}
+# endif
+
+std::string StringMaker<wchar_t const*>::convert(wchar_t const * str) {
+    if (str) {
+        return ::Catch::Detail::stringify(std::wstring{ str });
+    } else {
+        return{ "{null string}" };
+    }
+}
+std::string StringMaker<wchar_t *>::convert(wchar_t * str) {
+    if (str) {
+        return ::Catch::Detail::stringify(std::wstring{ str });
+    } else {
+        return{ "{null string}" };
+    }
+}
+#endif
+
+#if defined(CATCH_CONFIG_CPP17_BYTE)
+#include <cstddef>
+std::string StringMaker<std::byte>::convert(std::byte value) {
+    return ::Catch::Detail::stringify(std::to_integer<unsigned long long>(value));
+}
+#endif // defined(CATCH_CONFIG_CPP17_BYTE)
+
+std::string StringMaker<int>::convert(int value) {
+    return ::Catch::Detail::stringify(static_cast<long long>(value));
+}
+std::string StringMaker<long>::convert(long value) {
+    return ::Catch::Detail::stringify(static_cast<long long>(value));
+}
+std::string StringMaker<long long>::convert(long long value) {
+    ReusableStringStream rss;
+    rss << value;
+    if (value > Detail::hexThreshold) {
+        rss << " (0x" << std::hex << value << ')';
+    }
+    return rss.str();
+}
+
+std::string StringMaker<unsigned int>::convert(unsigned int value) {
+    return ::Catch::Detail::stringify(static_cast<unsigned long long>(value));
+}
+std::string StringMaker<unsigned long>::convert(unsigned long value) {
+    return ::Catch::Detail::stringify(static_cast<unsigned long long>(value));
+}
+std::string StringMaker<unsigned long long>::convert(unsigned long long value) {
+    ReusableStringStream rss;
+    rss << value;
+    if (value > Detail::hexThreshold) {
+        rss << " (0x" << std::hex << value << ')';
+    }
+    return rss.str();
+}
+
+std::string StringMaker<signed char>::convert(signed char value) {
+    if (value == '\r') {
+        return "'\\r'";
+    } else if (value == '\f') {
+        return "'\\f'";
+    } else if (value == '\n') {
+        return "'\\n'";
+    } else if (value == '\t') {
+        return "'\\t'";
+    } else if ('\0' <= value && value < ' ') {
+        return ::Catch::Detail::stringify(static_cast<unsigned int>(value));
+    } else {
+        char chstr[] = "' '";
+        chstr[1] = value;
+        return chstr;
+    }
+}
+std::string StringMaker<char>::convert(char c) {
+    return ::Catch::Detail::stringify(static_cast<signed char>(c));
+}
+std::string StringMaker<unsigned char>::convert(unsigned char value) {
+    return ::Catch::Detail::stringify(static_cast<char>(value));
+}
+
+int StringMaker<float>::precision = std::numeric_limits<float>::max_digits10;
+
+std::string StringMaker<float>::convert(float value) {
+    return Detail::fpToString(value, precision) + 'f';
+}
+
+int StringMaker<double>::precision = std::numeric_limits<double>::max_digits10;
+
+std::string StringMaker<double>::convert(double value) {
+    return Detail::fpToString(value, precision);
+}
+
+} // end namespace Catch
+
+
+
+namespace Catch {
+
+    Counts Counts::operator - ( Counts const& other ) const {
+        Counts diff;
+        diff.passed = passed - other.passed;
+        diff.failed = failed - other.failed;
+        diff.failedButOk = failedButOk - other.failedButOk;
+        diff.skipped = skipped - other.skipped;
+        return diff;
+    }
+
+    Counts& Counts::operator += ( Counts const& other ) {
+        passed += other.passed;
+        failed += other.failed;
+        failedButOk += other.failedButOk;
+        skipped += other.skipped;
+        return *this;
+    }
+
+    std::uint64_t Counts::total() const {
+        return passed + failed + failedButOk + skipped;
+    }
+    bool Counts::allPassed() const {
+        return failed == 0 && failedButOk == 0 && skipped == 0;
+    }
+    bool Counts::allOk() const {
+        return failed == 0;
+    }
+
+    Totals Totals::operator - ( Totals const& other ) const {
+        Totals diff;
+        diff.assertions = assertions - other.assertions;
+        diff.testCases = testCases - other.testCases;
+        return diff;
+    }
+
+    Totals& Totals::operator += ( Totals const& other ) {
+        assertions += other.assertions;
+        testCases += other.testCases;
+        return *this;
+    }
+
+    Totals Totals::delta( Totals const& prevTotals ) const {
+        Totals diff = *this - prevTotals;
+        if( diff.assertions.failed > 0 )
+            ++diff.testCases.failed;
+        else if( diff.assertions.failedButOk > 0 )
+            ++diff.testCases.failedButOk;
+        else if ( diff.assertions.skipped > 0 )
+            ++ diff.testCases.skipped;
+        else
+            ++diff.testCases.passed;
+        return diff;
+    }
+
+}
+
+
+
+
+namespace Catch {
+    namespace Detail {
+        void registerTranslatorImpl(
+            Detail::unique_ptr<IExceptionTranslator>&& translator ) {
+            getMutableRegistryHub().registerTranslator(
+                CATCH_MOVE( translator ) );
+        }
+    } // namespace Detail
+} // namespace Catch
+
+
+#include <ostream>
+
+namespace Catch {
+
+    Version::Version
+        (   unsigned int _majorVersion,
+            unsigned int _minorVersion,
+            unsigned int _patchNumber,
+            char const * const _branchName,
+            unsigned int _buildNumber )
+    :   majorVersion( _majorVersion ),
+        minorVersion( _minorVersion ),
+        patchNumber( _patchNumber ),
+        branchName( _branchName ),
+        buildNumber( _buildNumber )
+    {}
+
+    std::ostream& operator << ( std::ostream& os, Version const& version ) {
+        os  << version.majorVersion << '.'
+            << version.minorVersion << '.'
+            << version.patchNumber;
+        // branchName is never null -> 0th char is \0 if it is empty
+        if (version.branchName[0]) {
+            os << '-' << version.branchName
+               << '.' << version.buildNumber;
+        }
+        return os;
+    }
+
+    Version const& libraryVersion() {
+        static Version version( 3, 7, 1, "", 0 );
+        return version;
+    }
+
+}
+
+
+
+
+namespace Catch {
+
+    const char* GeneratorException::what() const noexcept {
+        return m_msg;
+    }
+
+} // end namespace Catch
+
+
+
+
+namespace Catch {
+
+    IGeneratorTracker::~IGeneratorTracker() = default;
+
+namespace Generators {
+
+namespace Detail {
+
+    [[noreturn]]
+    void throw_generator_exception(char const* msg) {
+        Catch::throw_exception(GeneratorException{ msg });
+    }
+} // end namespace Detail
+
+    GeneratorUntypedBase::~GeneratorUntypedBase() = default;
+
+    IGeneratorTracker* acquireGeneratorTracker(StringRef generatorName, SourceLineInfo const& lineInfo ) {
+        return getResultCapture().acquireGeneratorTracker( generatorName, lineInfo );
+    }
+
+    IGeneratorTracker* createGeneratorTracker( StringRef generatorName,
+                                 SourceLineInfo lineInfo,
+                                 GeneratorBasePtr&& generator ) {
+        return getResultCapture().createGeneratorTracker(
+            generatorName, lineInfo, CATCH_MOVE( generator ) );
+    }
+
+} // namespace Generators
+} // namespace Catch
+
+
+
+
+#include <random>
+
+namespace Catch {
+    namespace Generators {
+        namespace Detail {
+            std::uint32_t getSeed() { return sharedRng()(); }
+        } // namespace Detail
+
+        struct RandomFloatingGenerator<long double>::PImpl {
+            PImpl( long double a, long double b, uint32_t seed ):
+                rng( seed ), dist( a, b ) {}
+
+            Catch::SimplePcg32 rng;
+            std::uniform_real_distribution<long double> dist;
+        };
+
+        RandomFloatingGenerator<long double>::RandomFloatingGenerator(
+            long double a, long double b, std::uint32_t seed) :
+            m_pimpl(Catch::Detail::make_unique<PImpl>(a, b, seed)) {
+            static_cast<void>( next() );
+        }
+
+        RandomFloatingGenerator<long double>::~RandomFloatingGenerator() =
+            default;
+        bool RandomFloatingGenerator<long double>::next() {
+            m_current_number = m_pimpl->dist( m_pimpl->rng );
+            return true;
+        }
+    } // namespace Generators
+} // namespace Catch
+
+
+
+
+namespace Catch {
+    IResultCapture::~IResultCapture() = default;
+}
+
+
+
+
+namespace Catch {
+    IConfig::~IConfig() = default;
+}
+
+
+
+
+namespace Catch {
+    IExceptionTranslator::~IExceptionTranslator() = default;
+    IExceptionTranslatorRegistry::~IExceptionTranslatorRegistry() = default;
+}
+
+
+
+#include <string>
+
+namespace Catch {
+    namespace Generators {
+
+        bool GeneratorUntypedBase::countedNext() {
+            auto ret = next();
+            if ( ret ) {
+                m_stringReprCache.clear();
+                ++m_currentElementIndex;
+            }
+            return ret;
+        }
+
+        StringRef GeneratorUntypedBase::currentElementAsString() const {
+            if ( m_stringReprCache.empty() ) {
+                m_stringReprCache = stringifyImpl();
+            }
+            return m_stringReprCache;
+        }
+
+    } // namespace Generators
+} // namespace Catch
+
+
+
+
+namespace Catch {
+    IRegistryHub::~IRegistryHub() = default;
+    IMutableRegistryHub::~IMutableRegistryHub() = default;
+}
+
+
+
+#include <cassert>
+
+namespace Catch {
+
+    ReporterConfig::ReporterConfig(
+        IConfig const* _fullConfig,
+        Detail::unique_ptr<IStream> _stream,
+        ColourMode colourMode,
+        std::map<std::string, std::string> customOptions ):
+        m_stream( CATCH_MOVE(_stream) ),
+        m_fullConfig( _fullConfig ),
+        m_colourMode( colourMode ),
+        m_customOptions( CATCH_MOVE( customOptions ) ) {}
+
+    Detail::unique_ptr<IStream> ReporterConfig::takeStream() && {
+        assert( m_stream );
+        return CATCH_MOVE( m_stream );
+    }
+    IConfig const * ReporterConfig::fullConfig() const { return m_fullConfig; }
+    ColourMode ReporterConfig::colourMode() const { return m_colourMode; }
+
+    std::map<std::string, std::string> const&
+    ReporterConfig::customOptions() const {
+        return m_customOptions;
+    }
+
+    ReporterConfig::~ReporterConfig() = default;
+
+    AssertionStats::AssertionStats( AssertionResult const& _assertionResult,
+                                    std::vector<MessageInfo> const& _infoMessages,
+                                    Totals const& _totals )
+    :   assertionResult( _assertionResult ),
+        infoMessages( _infoMessages ),
+        totals( _totals )
+    {
+        if( assertionResult.hasMessage() ) {
+            // Copy message into messages list.
+            // !TBD This should have been done earlier, somewhere
+            MessageBuilder builder( assertionResult.getTestMacroName(), assertionResult.getSourceInfo(), assertionResult.getResultType() );
+            builder.m_info.message = static_cast<std::string>(assertionResult.getMessage());
+
+            infoMessages.push_back( CATCH_MOVE(builder.m_info) );
+        }
+    }
+
+    SectionStats::SectionStats(  SectionInfo&& _sectionInfo,
+                                 Counts const& _assertions,
+                                 double _durationInSeconds,
+                                 bool _missingAssertions )
+    :   sectionInfo( CATCH_MOVE(_sectionInfo) ),
+        assertions( _assertions ),
+        durationInSeconds( _durationInSeconds ),
+        missingAssertions( _missingAssertions )
+    {}
+
+
+    TestCaseStats::TestCaseStats(  TestCaseInfo const& _testInfo,
+                                   Totals const& _totals,
+                                   std::string&& _stdOut,
+                                   std::string&& _stdErr,
+                                   bool _aborting )
+    : testInfo( &_testInfo ),
+        totals( _totals ),
+        stdOut( CATCH_MOVE(_stdOut) ),
+        stdErr( CATCH_MOVE(_stdErr) ),
+        aborting( _aborting )
+    {}
+
+
+    TestRunStats::TestRunStats(   TestRunInfo const& _runInfo,
+                    Totals const& _totals,
+                    bool _aborting )
+    :   runInfo( _runInfo ),
+        totals( _totals ),
+        aborting( _aborting )
+    {}
+
+    IEventListener::~IEventListener() = default;
+
+} // end namespace Catch
+
+
+
+
+namespace Catch {
+    IReporterFactory::~IReporterFactory() = default;
+    EventListenerFactory::~EventListenerFactory() = default;
+}
+
+
+
+
+namespace Catch {
+    ITestCaseRegistry::~ITestCaseRegistry() = default;
+}
+
+
+
+namespace Catch {
+
+    AssertionHandler::AssertionHandler
+        (   StringRef macroName,
+            SourceLineInfo const& lineInfo,
+            StringRef capturedExpression,
+            ResultDisposition::Flags resultDisposition )
+    :   m_assertionInfo{ macroName, lineInfo, capturedExpression, resultDisposition },
+        m_resultCapture( getResultCapture() )
+    {
+        m_resultCapture.notifyAssertionStarted( m_assertionInfo );
+    }
+
+    void AssertionHandler::handleExpr( ITransientExpression const& expr ) {
+        m_resultCapture.handleExpr( m_assertionInfo, expr, m_reaction );
+    }
+    void AssertionHandler::handleMessage(ResultWas::OfType resultType, std::string&& message) {
+        m_resultCapture.handleMessage( m_assertionInfo, resultType, CATCH_MOVE(message), m_reaction );
+    }
+
+    auto AssertionHandler::allowThrows() const -> bool {
+        return getCurrentContext().getConfig()->allowThrows();
+    }
+
+    void AssertionHandler::complete() {
+        m_completed = true;
+        if( m_reaction.shouldDebugBreak ) {
+
+            // If you find your debugger stopping you here then go one level up on the
+            // call-stack for the code that caused it (typically a failed assertion)
+
+            // (To go back to the test and change execution, jump over the throw, next)
+            CATCH_BREAK_INTO_DEBUGGER();
+        }
+        if (m_reaction.shouldThrow) {
+            throw_test_failure_exception();
+        }
+        if ( m_reaction.shouldSkip ) {
+            throw_test_skip_exception();
+        }
+    }
+
+    void AssertionHandler::handleUnexpectedInflightException() {
+        m_resultCapture.handleUnexpectedInflightException( m_assertionInfo, Catch::translateActiveException(), m_reaction );
+    }
+
+    void AssertionHandler::handleExceptionThrownAsExpected() {
+        m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
+    }
+    void AssertionHandler::handleExceptionNotThrownAsExpected() {
+        m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
+    }
+
+    void AssertionHandler::handleUnexpectedExceptionNotThrown() {
+        m_resultCapture.handleUnexpectedExceptionNotThrown( m_assertionInfo, m_reaction );
+    }
+
+    void AssertionHandler::handleThrowingCallSkipped() {
+        m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
+    }
+
+    // This is the overload that takes a string and infers the Equals matcher from it
+    // The more general overload, that takes any string matcher, is in catch_capture_matchers.cpp
+    void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str ) {
+        handleExceptionMatchExpr( handler, Matchers::Equals( str ) );
+    }
+
+} // namespace Catch
+
+
+
+
+#include <algorithm>
+
+namespace Catch {
+    namespace Detail {
+
+        bool CaseInsensitiveLess::operator()( StringRef lhs,
+                                              StringRef rhs ) const {
+            return std::lexicographical_compare(
+                lhs.begin(), lhs.end(),
+                rhs.begin(), rhs.end(),
+                []( char l, char r ) { return toLower( l ) < toLower( r ); } );
+        }
+
+        bool
+        CaseInsensitiveEqualTo::operator()( StringRef lhs,
+                                            StringRef rhs ) const {
+            return std::equal(
+                lhs.begin(), lhs.end(),
+                rhs.begin(), rhs.end(),
+                []( char l, char r ) { return toLower( l ) == toLower( r ); } );
+        }
+
+    } // namespace Detail
+} // namespace Catch
+
+
+
+
+#include <algorithm>
+#include <ostream>
+
+namespace {
+    bool isOptPrefix( char c ) {
+        return c == '-'
+#ifdef CATCH_PLATFORM_WINDOWS
+               || c == '/'
+#endif
+            ;
+    }
+
+    Catch::StringRef normaliseOpt( Catch::StringRef optName ) {
+        if ( optName[0] == '-'
+#if defined(CATCH_PLATFORM_WINDOWS)
+             || optName[0] == '/'
+#endif
+        ) {
+            return optName.substr( 1, optName.size() );
+        }
+
+        return optName;
+    }
+
+    static size_t find_first_separator(Catch::StringRef sr) {
+        auto is_separator = []( char c ) {
+            return c == ' ' || c == ':' || c == '=';
+        };
+        size_t pos = 0;
+        while (pos < sr.size()) {
+            if (is_separator(sr[pos])) { return pos; }
+            ++pos;
+        }
+
+        return Catch::StringRef::npos;
+    }
+
+} // namespace
+
+namespace Catch {
+    namespace Clara {
+        namespace Detail {
+
+            void TokenStream::loadBuffer() {
+                m_tokenBuffer.clear();
+
+                // Skip any empty strings
+                while ( it != itEnd && it->empty() ) {
+                    ++it;
+                }
+
+                if ( it != itEnd ) {
+                    StringRef next = *it;
+                    if ( isOptPrefix( next[0] ) ) {
+                        auto delimiterPos = find_first_separator(next);
+                        if ( delimiterPos != StringRef::npos ) {
+                            m_tokenBuffer.push_back(
+                                { TokenType::Option,
+                                  next.substr( 0, delimiterPos ) } );
+                            m_tokenBuffer.push_back(
+                                { TokenType::Argument,
+                                  next.substr( delimiterPos + 1, next.size() ) } );
+                        } else {
+                            if ( next.size() > 1 && next[1] != '-' && next.size() > 2 ) {
+                                // Combined short args, e.g. "-ab" for "-a -b"
+                                for ( size_t i = 1; i < next.size(); ++i ) {
+                                    m_tokenBuffer.push_back(
+                                        { TokenType::Option,
+                                          next.substr( i, 1 ) } );
+                                }
+                            } else {
+                                m_tokenBuffer.push_back(
+                                    { TokenType::Option, next } );
+                            }
+                        }
+                    } else {
+                        m_tokenBuffer.push_back(
+                            { TokenType::Argument, next } );
+                    }
+                }
+            }
+
+            TokenStream::TokenStream( Args const& args ):
+                TokenStream( args.m_args.begin(), args.m_args.end() ) {}
+
+            TokenStream::TokenStream( Iterator it_, Iterator itEnd_ ):
+                it( it_ ), itEnd( itEnd_ ) {
+                loadBuffer();
+            }
+
+            TokenStream& TokenStream::operator++() {
+                if ( m_tokenBuffer.size() >= 2 ) {
+                    m_tokenBuffer.erase( m_tokenBuffer.begin() );
+                } else {
+                    if ( it != itEnd )
+                        ++it;
+                    loadBuffer();
+                }
+                return *this;
+            }
+
+            ParserResult convertInto( std::string const& source,
+                                      std::string& target ) {
+                target = source;
+                return ParserResult::ok( ParseResultType::Matched );
+            }
+
+            ParserResult convertInto( std::string const& source,
+                                      bool& target ) {
+                std::string srcLC = toLower( source );
+
+                if ( srcLC == "y" || srcLC == "1" || srcLC == "true" ||
+                     srcLC == "yes" || srcLC == "on" ) {
+                    target = true;
+                } else if ( srcLC == "n" || srcLC == "0" || srcLC == "false" ||
+                            srcLC == "no" || srcLC == "off" ) {
+                    target = false;
+                } else {
+                    return ParserResult::runtimeError(
+                        "Expected a boolean value but did not recognise: '" +
+                        source + '\'' );
+                }
+                return ParserResult::ok( ParseResultType::Matched );
+            }
+
+            size_t ParserBase::cardinality() const { return 1; }
+
+            InternalParseResult ParserBase::parse( Args const& args ) const {
+                return parse( static_cast<std::string>(args.exeName()), TokenStream( args ) );
+            }
+
+            ParseState::ParseState( ParseResultType type,
+                                    TokenStream remainingTokens ):
+                m_type( type ), m_remainingTokens( CATCH_MOVE(remainingTokens) ) {}
+
+            ParserResult BoundFlagRef::setFlag( bool flag ) {
+                m_ref = flag;
+                return ParserResult::ok( ParseResultType::Matched );
+            }
+
+            ResultBase::~ResultBase() = default;
+
+            bool BoundRef::isContainer() const { return false; }
+
+            bool BoundRef::isFlag() const { return false; }
+
+            bool BoundFlagRefBase::isFlag() const { return true; }
+
+} // namespace Detail
+
+        Detail::InternalParseResult Arg::parse(std::string const&,
+                                               Detail::TokenStream tokens) const {
+            auto validationResult = validate();
+            if (!validationResult)
+                return Detail::InternalParseResult(validationResult);
+
+            auto token = *tokens;
+            if (token.type != Detail::TokenType::Argument)
+                return Detail::InternalParseResult::ok(Detail::ParseState(
+                    ParseResultType::NoMatch, CATCH_MOVE(tokens)));
+
+            assert(!m_ref->isFlag());
+            auto valueRef =
+                static_cast<Detail::BoundValueRefBase*>(m_ref.get());
+
+            auto result = valueRef->setValue(static_cast<std::string>(token.token));
+            if ( !result )
+                return Detail::InternalParseResult( result );
+            else
+                return Detail::InternalParseResult::ok(
+                    Detail::ParseState( ParseResultType::Matched,
+                                        CATCH_MOVE( ++tokens ) ) );
+        }
+
+        Opt::Opt(bool& ref) :
+            ParserRefImpl(std::make_shared<Detail::BoundFlagRef>(ref)) {}
+
+        Detail::HelpColumns Opt::getHelpColumns() const {
+            ReusableStringStream oss;
+            bool first = true;
+            for (auto const& opt : m_optNames) {
+                if (first)
+                    first = false;
+                else
+                    oss << ", ";
+                oss << opt;
+            }
+            if (!m_hint.empty())
+                oss << " <" << m_hint << '>';
+            return { oss.str(), m_description };
+        }
+
+        bool Opt::isMatch(StringRef optToken) const {
+            auto normalisedToken = normaliseOpt(optToken);
+            for (auto const& name : m_optNames) {
+                if (normaliseOpt(name) == normalisedToken)
+                    return true;
+            }
+            return false;
+        }
+
+        Detail::InternalParseResult Opt::parse(std::string const&,
+                                       Detail::TokenStream tokens) const {
+            auto validationResult = validate();
+            if (!validationResult)
+                return Detail::InternalParseResult(validationResult);
+
+            if (tokens &&
+                tokens->type == Detail::TokenType::Option) {
+                auto const& token = *tokens;
+                if (isMatch(token.token)) {
+                    if (m_ref->isFlag()) {
+                        auto flagRef =
+                            static_cast<Detail::BoundFlagRefBase*>(
+                                m_ref.get());
+                        auto result = flagRef->setFlag(true);
+                        if (!result)
+                            return Detail::InternalParseResult(result);
+                        if (result.value() ==
+                            ParseResultType::ShortCircuitAll)
+                            return Detail::InternalParseResult::ok(Detail::ParseState(
+                                result.value(), CATCH_MOVE(tokens)));
+                    } else {
+                        auto valueRef =
+                            static_cast<Detail::BoundValueRefBase*>(
+                                m_ref.get());
+                        ++tokens;
+                        if (!tokens)
+                            return Detail::InternalParseResult::runtimeError(
+                                "Expected argument following " +
+                                token.token);
+                        auto const& argToken = *tokens;
+                        if (argToken.type != Detail::TokenType::Argument)
+                            return Detail::InternalParseResult::runtimeError(
+                                "Expected argument following " +
+                                token.token);
+                        const auto result = valueRef->setValue(static_cast<std::string>(argToken.token));
+                        if (!result)
+                            return Detail::InternalParseResult(result);
+                        if (result.value() ==
+                            ParseResultType::ShortCircuitAll)
+                            return Detail::InternalParseResult::ok(Detail::ParseState(
+                                result.value(), CATCH_MOVE(tokens)));
+                    }
+                    return Detail::InternalParseResult::ok(Detail::ParseState(
+                        ParseResultType::Matched, CATCH_MOVE(++tokens)));
+                }
+            }
+            return Detail::InternalParseResult::ok(
+                Detail::ParseState(ParseResultType::NoMatch, CATCH_MOVE(tokens)));
+        }
+
+        Detail::Result Opt::validate() const {
+            if (m_optNames.empty())
+                return Detail::Result::logicError("No options supplied to Opt");
+            for (auto const& name : m_optNames) {
+                if (name.empty())
+                    return Detail::Result::logicError(
+                        "Option name cannot be empty");
+#ifdef CATCH_PLATFORM_WINDOWS
+                if (name[0] != '-' && name[0] != '/')
+                    return Detail::Result::logicError(
+                        "Option name must begin with '-' or '/'");
+#else
+                if (name[0] != '-')
+                    return Detail::Result::logicError(
+                        "Option name must begin with '-'");
+#endif
+            }
+            return ParserRefImpl::validate();
+        }
+
+        ExeName::ExeName() :
+            m_name(std::make_shared<std::string>("<executable>")) {}
+
+        ExeName::ExeName(std::string& ref) : ExeName() {
+            m_ref = std::make_shared<Detail::BoundValueRef<std::string>>(ref);
+        }
+
+        Detail::InternalParseResult
+            ExeName::parse(std::string const&,
+                           Detail::TokenStream tokens) const {
+            return Detail::InternalParseResult::ok(
+                Detail::ParseState(ParseResultType::NoMatch, CATCH_MOVE(tokens)));
+        }
+
+        ParserResult ExeName::set(std::string const& newName) {
+            auto lastSlash = newName.find_last_of("\\/");
+            auto filename = (lastSlash == std::string::npos)
+                ? newName
+                : newName.substr(lastSlash + 1);
+
+            *m_name = filename;
+            if (m_ref)
+                return m_ref->setValue(filename);
+            else
+                return ParserResult::ok(ParseResultType::Matched);
+        }
+
+
+
+
+        Parser& Parser::operator|=( Parser const& other ) {
+            m_options.insert( m_options.end(),
+                              other.m_options.begin(),
+                              other.m_options.end() );
+            m_args.insert(
+                m_args.end(), other.m_args.begin(), other.m_args.end() );
+            return *this;
+        }
+
+        std::vector<Detail::HelpColumns> Parser::getHelpColumns() const {
+            std::vector<Detail::HelpColumns> cols;
+            cols.reserve( m_options.size() );
+            for ( auto const& o : m_options ) {
+                cols.push_back(o.getHelpColumns());
+            }
+            return cols;
+        }
+
+        void Parser::writeToStream( std::ostream& os ) const {
+            if ( !m_exeName.name().empty() ) {
+                os << "usage:\n"
+                   << "  " << m_exeName.name() << ' ';
+                bool required = true, first = true;
+                for ( auto const& arg : m_args ) {
+                    if ( first )
+                        first = false;
+                    else
+                        os << ' ';
+                    if ( arg.isOptional() && required ) {
+                        os << '[';
+                        required = false;
+                    }
+                    os << '<' << arg.hint() << '>';
+                    if ( arg.cardinality() == 0 )
+                        os << " ... ";
+                }
+                if ( !required )
+                    os << ']';
+                if ( !m_options.empty() )
+                    os << " options";
+                os << "\n\nwhere options are:\n";
+            }
+
+            auto rows = getHelpColumns();
+            size_t consoleWidth = CATCH_CONFIG_CONSOLE_WIDTH;
+            size_t optWidth = 0;
+            for ( auto const& cols : rows )
+                optWidth = ( std::max )( optWidth, cols.left.size() + 2 );
+
+            optWidth = ( std::min )( optWidth, consoleWidth / 2 );
+
+            for ( auto& cols : rows ) {
+                auto row = TextFlow::Column( CATCH_MOVE(cols.left) )
+                               .width( optWidth )
+                               .indent( 2 ) +
+                           TextFlow::Spacer( 4 ) +
+                           TextFlow::Column( static_cast<std::string>(cols.descriptions) )
+                               .width( consoleWidth - 7 - optWidth );
+                os << row << '\n';
+            }
+        }
+
+        Detail::Result Parser::validate() const {
+            for ( auto const& opt : m_options ) {
+                auto result = opt.validate();
+                if ( !result )
+                    return result;
+            }
+            for ( auto const& arg : m_args ) {
+                auto result = arg.validate();
+                if ( !result )
+                    return result;
+            }
+            return Detail::Result::ok();
+        }
+
+        Detail::InternalParseResult
+        Parser::parse( std::string const& exeName,
+                       Detail::TokenStream tokens ) const {
+
+            struct ParserInfo {
+                ParserBase const* parser = nullptr;
+                size_t count = 0;
+            };
+            std::vector<ParserInfo> parseInfos;
+            parseInfos.reserve( m_options.size() + m_args.size() );
+            for ( auto const& opt : m_options ) {
+                parseInfos.push_back( { &opt, 0 } );
+            }
+            for ( auto const& arg : m_args ) {
+                parseInfos.push_back( { &arg, 0 } );
+            }
+
+            m_exeName.set( exeName );
+
+            auto result = Detail::InternalParseResult::ok(
+                Detail::ParseState( ParseResultType::NoMatch, CATCH_MOVE(tokens) ) );
+            while ( result.value().remainingTokens() ) {
+                bool tokenParsed = false;
+
+                for ( auto& parseInfo : parseInfos ) {
+                    if ( parseInfo.parser->cardinality() == 0 ||
+                         parseInfo.count < parseInfo.parser->cardinality() ) {
+                        result = parseInfo.parser->parse(
+                            exeName, CATCH_MOVE(result).value().remainingTokens() );
+                        if ( !result )
+                            return result;
+                        if ( result.value().type() !=
+                             ParseResultType::NoMatch ) {
+                            tokenParsed = true;
+                            ++parseInfo.count;
+                            break;
+                        }
+                    }
+                }
+
+                if ( result.value().type() == ParseResultType::ShortCircuitAll )
+                    return result;
+                if ( !tokenParsed )
+                    return Detail::InternalParseResult::runtimeError(
+                        "Unrecognised token: " +
+                        result.value().remainingTokens()->token );
+            }
+            // !TBD Check missing required options
+            return result;
+        }
+
+        Args::Args(int argc, char const* const* argv) :
+            m_exeName(argv[0]), m_args(argv + 1, argv + argc) {}
+
+        Args::Args(std::initializer_list<StringRef> args) :
+            m_exeName(*args.begin()),
+            m_args(args.begin() + 1, args.end()) {}
+
+
+        Help::Help( bool& showHelpFlag ):
+            Opt( [&]( bool flag ) {
+                showHelpFlag = flag;
+                return ParserResult::ok( ParseResultType::ShortCircuitAll );
+            } ) {
+            static_cast<Opt&> ( *this )(
+                "display usage information" )["-?"]["-h"]["--help"]
+                .optional();
+        }
+
+    } // namespace Clara
+} // namespace Catch
+
+
+
+
+#include <fstream>
+#include <string>
+
+namespace Catch {
+
+    Clara::Parser makeCommandLineParser( ConfigData& config ) {
+
+        using namespace Clara;
+
+        auto const setWarning = [&]( std::string const& warning ) {
+            if ( warning == "NoAssertions" ) {
+                config.warnings = static_cast<WarnAbout::What>(config.warnings | WarnAbout::NoAssertions);
+                return ParserResult::ok( ParseResultType::Matched );
+            } else if ( warning == "UnmatchedTestSpec" ) {
+                config.warnings = static_cast<WarnAbout::What>(config.warnings | WarnAbout::UnmatchedTestSpec);
+                return ParserResult::ok( ParseResultType::Matched );
+            }
+
+            return ParserResult ::runtimeError(
+                "Unrecognised warning option: '" + warning + '\'' );
+        };
+        auto const loadTestNamesFromFile = [&]( std::string const& filename ) {
+                std::ifstream f( filename.c_str() );
+                if( !f.is_open() )
+                    return ParserResult::runtimeError( "Unable to load input file: '" + filename + '\'' );
+
+                std::string line;
+                while( std::getline( f, line ) ) {
+                    line = trim(line);
+                    if( !line.empty() && !startsWith( line, '#' ) ) {
+                        if( !startsWith( line, '"' ) )
+                            line = '"' + CATCH_MOVE(line) + '"';
+                        config.testsOrTags.push_back( line );
+                        config.testsOrTags.emplace_back( "," );
+                    }
+                }
+                //Remove comma in the end
+                if(!config.testsOrTags.empty())
+                    config.testsOrTags.erase( config.testsOrTags.end()-1 );
+
+                return ParserResult::ok( ParseResultType::Matched );
+            };
+        auto const setTestOrder = [&]( std::string const& order ) {
+                if( startsWith( "declared", order ) )
+                    config.runOrder = TestRunOrder::Declared;
+                else if( startsWith( "lexical", order ) )
+                    config.runOrder = TestRunOrder::LexicographicallySorted;
+                else if( startsWith( "random", order ) )
+                    config.runOrder = TestRunOrder::Randomized;
+                else
+                    return ParserResult::runtimeError( "Unrecognised ordering: '" + order + '\'' );
+                return ParserResult::ok( ParseResultType::Matched );
+            };
+        auto const setRngSeed = [&]( std::string const& seed ) {
+                if( seed == "time" ) {
+                    config.rngSeed = generateRandomSeed(GenerateFrom::Time);
+                    return ParserResult::ok(ParseResultType::Matched);
+                } else if (seed == "random-device") {
+                    config.rngSeed = generateRandomSeed(GenerateFrom::RandomDevice);
+                    return ParserResult::ok(ParseResultType::Matched);
+                }
+
+                // TODO: ideally we should be parsing uint32_t directly
+                //       fix this later when we add new parse overload
+                auto parsedSeed = parseUInt( seed, 0 );
+                if ( !parsedSeed ) {
+                    return ParserResult::runtimeError( "Could not parse '" + seed + "' as seed" );
+                }
+                config.rngSeed = *parsedSeed;
+                return ParserResult::ok( ParseResultType::Matched );
+            };
+        auto const setDefaultColourMode = [&]( std::string const& colourMode ) {
+            Optional<ColourMode> maybeMode = Catch::Detail::stringToColourMode(toLower( colourMode ));
+            if ( !maybeMode ) {
+                return ParserResult::runtimeError(
+                    "colour mode must be one of: default, ansi, win32, "
+                    "or none. '" +
+                    colourMode + "' is not recognised" );
+            }
+            auto mode = *maybeMode;
+            if ( !isColourImplAvailable( mode ) ) {
+                return ParserResult::runtimeError(
+                    "colour mode '" + colourMode +
+                    "' is not supported in this binary" );
+            }
+            config.defaultColourMode = mode;
+            return ParserResult::ok( ParseResultType::Matched );
+        };
+        auto const setWaitForKeypress = [&]( std::string const& keypress ) {
+                auto keypressLc = toLower( keypress );
+                if (keypressLc == "never")
+                    config.waitForKeypress = WaitForKeypress::Never;
+                else if( keypressLc == "start" )
+                    config.waitForKeypress = WaitForKeypress::BeforeStart;
+                else if( keypressLc == "exit" )
+                    config.waitForKeypress = WaitForKeypress::BeforeExit;
+                else if( keypressLc == "both" )
+                    config.waitForKeypress = WaitForKeypress::BeforeStartAndExit;
+                else
+                    return ParserResult::runtimeError( "keypress argument must be one of: never, start, exit or both. '" + keypress + "' not recognised" );
+            return ParserResult::ok( ParseResultType::Matched );
+            };
+        auto const setVerbosity = [&]( std::string const& verbosity ) {
+            auto lcVerbosity = toLower( verbosity );
+            if( lcVerbosity == "quiet" )
+                config.verbosity = Verbosity::Quiet;
+            else if( lcVerbosity == "normal" )
+                config.verbosity = Verbosity::Normal;
+            else if( lcVerbosity == "high" )
+                config.verbosity = Verbosity::High;
+            else
+                return ParserResult::runtimeError( "Unrecognised verbosity, '" + verbosity + '\'' );
+            return ParserResult::ok( ParseResultType::Matched );
+        };
+        auto const setReporter = [&]( std::string const& userReporterSpec ) {
+            if ( userReporterSpec.empty() ) {
+                return ParserResult::runtimeError( "Received empty reporter spec." );
+            }
+
+            Optional<ReporterSpec> parsed =
+                parseReporterSpec( userReporterSpec );
+            if ( !parsed ) {
+                return ParserResult::runtimeError(
+                    "Could not parse reporter spec '" + userReporterSpec +
+                    "'" );
+            }
+
+            auto const& reporterSpec = *parsed;
+
+            auto const& factories =
+                getRegistryHub().getReporterRegistry().getFactories();
+            auto result = factories.find( reporterSpec.name() );
+
+            if ( result == factories.end() ) {
+                return ParserResult::runtimeError(
+                    "Unrecognized reporter, '" + reporterSpec.name() +
+                    "'. Check available with --list-reporters" );
+            }
+
+
+            const bool hadOutputFile = reporterSpec.outputFile().some();
+            config.reporterSpecifications.push_back( CATCH_MOVE( *parsed ) );
+            // It would be enough to check this only once at the very end, but
+            // there is  not a place where we could call this check, so do it
+            // every time it could fail. For valid inputs, this is still called
+            // at most once.
+            if (!hadOutputFile) {
+                int n_reporters_without_file = 0;
+                for (auto const& spec : config.reporterSpecifications) {
+                    if (spec.outputFile().none()) {
+                        n_reporters_without_file++;
+                    }
+                }
+                if (n_reporters_without_file > 1) {
+                    return ParserResult::runtimeError( "Only one reporter may have unspecified output file." );
+                }
+            }
+
+            return ParserResult::ok( ParseResultType::Matched );
+        };
+        auto const setShardCount = [&]( std::string const& shardCount ) {
+            auto parsedCount = parseUInt( shardCount );
+            if ( !parsedCount ) {
+                return ParserResult::runtimeError(
+                    "Could not parse '" + shardCount + "' as shard count" );
+            }
+            if ( *parsedCount == 0 ) {
+                return ParserResult::runtimeError(
+                    "Shard count must be positive" );
+            }
+            config.shardCount = *parsedCount;
+            return ParserResult::ok( ParseResultType::Matched );
+        };
+
+        auto const setShardIndex = [&](std::string const& shardIndex) {
+            auto parsedIndex = parseUInt( shardIndex );
+            if ( !parsedIndex ) {
+                return ParserResult::runtimeError(
+                    "Could not parse '" + shardIndex + "' as shard index" );
+            }
+            config.shardIndex = *parsedIndex;
+            return ParserResult::ok( ParseResultType::Matched );
+        };
+
+        auto cli
+            = ExeName( config.processName )
+            | Help( config.showHelp )
+            | Opt( config.showSuccessfulTests )
+                ["-s"]["--success"]
+                ( "include successful tests in output" )
+            | Opt( config.shouldDebugBreak )
+                ["-b"]["--break"]
+                ( "break into debugger on failure" )
+            | Opt( config.noThrow )
+                ["-e"]["--nothrow"]
+                ( "skip exception tests" )
+            | Opt( config.showInvisibles )
+                ["-i"]["--invisibles"]
+                ( "show invisibles (tabs, newlines)" )
+            | Opt( config.defaultOutputFilename, "filename" )
+                ["-o"]["--out"]
+                ( "default output filename" )
+            | Opt( accept_many, setReporter, "name[::key=value]*" )
+                ["-r"]["--reporter"]
+                ( "reporter to use (defaults to console)" )
+            | Opt( config.name, "name" )
+                ["-n"]["--name"]
+                ( "suite name" )
+            | Opt( [&]( bool ){ config.abortAfter = 1; } )
+                ["-a"]["--abort"]
+                ( "abort at first failure" )
+            | Opt( [&]( int x ){ config.abortAfter = x; }, "no. failures" )
+                ["-x"]["--abortx"]
+                ( "abort after x failures" )
+            | Opt( accept_many, setWarning, "warning name" )
+                ["-w"]["--warn"]
+                ( "enable warnings" )
+            | Opt( [&]( bool flag ) { config.showDurations = flag ? ShowDurations::Always : ShowDurations::Never; }, "yes|no" )
+                ["-d"]["--durations"]
+                ( "show test durations" )
+            | Opt( config.minDuration, "seconds" )
+                ["-D"]["--min-duration"]
+                ( "show test durations for tests taking at least the given number of seconds" )
+            | Opt( loadTestNamesFromFile, "filename" )
+                ["-f"]["--input-file"]
+                ( "load test names to run from a file" )
+            | Opt( config.filenamesAsTags )
+                ["-#"]["--filenames-as-tags"]
+                ( "adds a tag for the filename" )
+            | Opt( config.sectionsToRun, "section name" )
+                ["-c"]["--section"]
+                ( "specify section to run" )
+            | Opt( setVerbosity, "quiet|normal|high" )
+                ["-v"]["--verbosity"]
+                ( "set output verbosity" )
+            | Opt( config.listTests )
+                ["--list-tests"]
+                ( "list all/matching test cases" )
+            | Opt( config.listTags )
+                ["--list-tags"]
+                ( "list all/matching tags" )
+            | Opt( config.listReporters )
+                ["--list-reporters"]
+                ( "list all available reporters" )
+            | Opt( config.listListeners )
+                ["--list-listeners"]
+                ( "list all listeners" )
+            | Opt( setTestOrder, "decl|lex|rand" )
+                ["--order"]
+                ( "test case order (defaults to decl)" )
+            | Opt( setRngSeed, "'time'|'random-device'|number" )
+                ["--rng-seed"]
+                ( "set a specific seed for random numbers" )
+            | Opt( setDefaultColourMode, "ansi|win32|none|default" )
+                ["--colour-mode"]
+                ( "what color mode should be used as default" )
+            | Opt( config.libIdentify )
+                ["--libidentify"]
+                ( "report name and version according to libidentify standard" )
+            | Opt( setWaitForKeypress, "never|start|exit|both" )
+                ["--wait-for-keypress"]
+                ( "waits for a keypress before exiting" )
+            | Opt( config.skipBenchmarks)
+                ["--skip-benchmarks"]
+                ( "disable running benchmarks")
+            | Opt( config.benchmarkSamples, "samples" )
+                ["--benchmark-samples"]
+                ( "number of samples to collect (default: 100)" )
+            | Opt( config.benchmarkResamples, "resamples" )
+                ["--benchmark-resamples"]
+                ( "number of resamples for the bootstrap (default: 100000)" )
+            | Opt( config.benchmarkConfidenceInterval, "confidence interval" )
+                ["--benchmark-confidence-interval"]
+                ( "confidence interval for the bootstrap (between 0 and 1, default: 0.95)" )
+            | Opt( config.benchmarkNoAnalysis )
+                ["--benchmark-no-analysis"]
+                ( "perform only measurements; do not perform any analysis" )
+            | Opt( config.benchmarkWarmupTime, "benchmarkWarmupTime" )
+                ["--benchmark-warmup-time"]
+                ( "amount of time in milliseconds spent on warming up each test (default: 100)" )
+            | Opt( setShardCount, "shard count" )
+                ["--shard-count"]
+                ( "split the tests to execute into this many groups" )
+            | Opt( setShardIndex, "shard index" )
+                ["--shard-index"]
+                ( "index of the group of tests to execute (see --shard-count)" )
+            | Opt( config.allowZeroTests )
+                ["--allow-running-no-tests"]
+                ( "Treat 'No tests run' as a success" )
+            | Arg( config.testsOrTags, "test name|pattern|tags" )
+                ( "which test or tests to use" );
+
+        return cli;
+    }
+
+} // end namespace Catch
+
+
+#if defined(__clang__)
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wexit-time-destructors"
+#endif
+
+
+
+#include <cassert>
+#include <ostream>
+#include <utility>
+
+namespace Catch {
+
+    ColourImpl::~ColourImpl() = default;
+
+    ColourImpl::ColourGuard ColourImpl::guardColour( Colour::Code colourCode ) {
+        return ColourGuard(colourCode, this );
+    }
+
+    void ColourImpl::ColourGuard::engageImpl( std::ostream& stream ) {
+        assert( &stream == &m_colourImpl->m_stream->stream() &&
+                "Engaging colour guard for different stream than used by the "
+                "parent colour implementation" );
+        static_cast<void>( stream );
+
+        m_engaged = true;
+        m_colourImpl->use( m_code );
+    }
+
+    ColourImpl::ColourGuard::ColourGuard( Colour::Code code,
+                                          ColourImpl const* colour ):
+        m_colourImpl( colour ), m_code( code ) {
+    }
+    ColourImpl::ColourGuard::ColourGuard( ColourGuard&& rhs ) noexcept:
+        m_colourImpl( rhs.m_colourImpl ),
+        m_code( rhs.m_code ),
+        m_engaged( rhs.m_engaged ) {
+        rhs.m_engaged = false;
+    }
+    ColourImpl::ColourGuard&
+    ColourImpl::ColourGuard::operator=( ColourGuard&& rhs ) noexcept {
+        using std::swap;
+        swap( m_colourImpl, rhs.m_colourImpl );
+        swap( m_code, rhs.m_code );
+        swap( m_engaged, rhs.m_engaged );
+
+        return *this;
+    }
+    ColourImpl::ColourGuard::~ColourGuard() {
+        if ( m_engaged ) {
+            m_colourImpl->use( Colour::None );
+        }
+    }
+
+    ColourImpl::ColourGuard&
+    ColourImpl::ColourGuard::engage( std::ostream& stream ) & {
+        engageImpl( stream );
+        return *this;
+    }
+
+    ColourImpl::ColourGuard&&
+    ColourImpl::ColourGuard::engage( std::ostream& stream ) && {
+        engageImpl( stream );
+        return CATCH_MOVE(*this);
+    }
+
+    namespace {
+        //! A do-nothing implementation of colour, used as fallback for unknown
+        //! platforms, and when the user asks to deactivate all colours.
+        class NoColourImpl final : public ColourImpl {
+        public:
+            NoColourImpl( IStream* stream ): ColourImpl( stream ) {}
+
+        private:
+            void use( Colour::Code ) const override {}
+        };
+    } // namespace
+
+
+} // namespace Catch
+
+
+#if defined ( CATCH_CONFIG_COLOUR_WIN32 ) /////////////////////////////////////////
+
+namespace Catch {
+namespace {
+
+    class Win32ColourImpl final : public ColourImpl {
+    public:
+        Win32ColourImpl(IStream* stream):
+            ColourImpl(stream) {
+            CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
+            GetConsoleScreenBufferInfo( GetStdHandle( STD_OUTPUT_HANDLE ),
+                                        &csbiInfo );
+            originalForegroundAttributes = csbiInfo.wAttributes & ~( BACKGROUND_GREEN | BACKGROUND_RED | BACKGROUND_BLUE | BACKGROUND_INTENSITY );
+            originalBackgroundAttributes = csbiInfo.wAttributes & ~( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY );
+        }
+
+        static bool useImplementationForStream(IStream const& stream) {
+            // Win32 text colour APIs can only be used on console streams
+            // We cannot check that the output hasn't been redirected,
+            // so we just check that the original stream is console stream.
+            return stream.isConsole();
+        }
+
+    private:
+        void use( Colour::Code _colourCode ) const override {
+            switch( _colourCode ) {
+                case Colour::None:      return setTextAttribute( originalForegroundAttributes );
+                case Colour::White:     return setTextAttribute( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
+                case Colour::Red:       return setTextAttribute( FOREGROUND_RED );
+                case Colour::Green:     return setTextAttribute( FOREGROUND_GREEN );
+                case Colour::Blue:      return setTextAttribute( FOREGROUND_BLUE );
+                case Colour::Cyan:      return setTextAttribute( FOREGROUND_BLUE | FOREGROUND_GREEN );
+                case Colour::Yellow:    return setTextAttribute( FOREGROUND_RED | FOREGROUND_GREEN );
+                case Colour::Grey:      return setTextAttribute( 0 );
+
+                case Colour::LightGrey:     return setTextAttribute( FOREGROUND_INTENSITY );
+                case Colour::BrightRed:     return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED );
+                case Colour::BrightGreen:   return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN );
+                case Colour::BrightWhite:   return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
+                case Colour::BrightYellow:  return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN );
+
+                case Colour::Bright: CATCH_INTERNAL_ERROR( "not a colour" );
+
+                default:
+                    CATCH_ERROR( "Unknown colour requested" );
+            }
+        }
+
+        void setTextAttribute( WORD _textAttribute ) const {
+            SetConsoleTextAttribute( GetStdHandle( STD_OUTPUT_HANDLE ),
+                                     _textAttribute |
+                                         originalBackgroundAttributes );
+        }
+        WORD originalForegroundAttributes;
+        WORD originalBackgroundAttributes;
+    };
+
+} // end anon namespace
+} // end namespace Catch
+
+#endif // Windows/ ANSI/ None
+
+
+#if defined( CATCH_PLATFORM_LINUX ) || defined( CATCH_PLATFORM_MAC )
+#    define CATCH_INTERNAL_HAS_ISATTY
+#    include <unistd.h>
+#endif
+
+namespace Catch {
+namespace {
+
+    class ANSIColourImpl final : public ColourImpl {
+    public:
+        ANSIColourImpl( IStream* stream ): ColourImpl( stream ) {}
+
+        static bool useImplementationForStream(IStream const& stream) {
+            // This is kinda messy due to trying to support a bunch of
+            // different platforms at once.
+            // The basic idea is that if we are asked to do autodetection (as
+            // opposed to being told to use posixy colours outright), then we
+            // only want to use the colours if we are writing to console.
+            // However, console might be redirected, so we make an attempt at
+            // checking for that on platforms where we know how to do that.
+            bool useColour = stream.isConsole();
+#if defined( CATCH_INTERNAL_HAS_ISATTY ) && \
+    !( defined( __DJGPP__ ) && defined( __STRICT_ANSI__ ) )
+            ErrnoGuard _; // for isatty
+            useColour = useColour && isatty( STDOUT_FILENO );
+#    endif
+#    if defined( CATCH_PLATFORM_MAC ) || defined( CATCH_PLATFORM_IPHONE )
+            useColour = useColour && !isDebuggerActive();
+#    endif
+
+            return useColour;
+        }
+
+    private:
+        void use( Colour::Code _colourCode ) const override {
+            auto setColour = [&out =
+                                  m_stream->stream()]( char const* escapeCode ) {
+                // The escape sequence must be flushed to console, otherwise
+                // if stdin and stderr are intermixed, we'd get accidentally
+                // coloured output.
+                out << '\033' << escapeCode << std::flush;
+            };
+            switch( _colourCode ) {
+                case Colour::None:
+                case Colour::White:     return setColour( "[0m" );
+                case Colour::Red:       return setColour( "[0;31m" );
+                case Colour::Green:     return setColour( "[0;32m" );
+                case Colour::Blue:      return setColour( "[0;34m" );
+                case Colour::Cyan:      return setColour( "[0;36m" );
+                case Colour::Yellow:    return setColour( "[0;33m" );
+                case Colour::Grey:      return setColour( "[1;30m" );
+
+                case Colour::LightGrey:     return setColour( "[0;37m" );
+                case Colour::BrightRed:     return setColour( "[1;31m" );
+                case Colour::BrightGreen:   return setColour( "[1;32m" );
+                case Colour::BrightWhite:   return setColour( "[1;37m" );
+                case Colour::BrightYellow:  return setColour( "[1;33m" );
+
+                case Colour::Bright: CATCH_INTERNAL_ERROR( "not a colour" );
+                default: CATCH_INTERNAL_ERROR( "Unknown colour requested" );
+            }
+        }
+    };
+
+} // end anon namespace
+} // end namespace Catch
+
+namespace Catch {
+
+    Detail::unique_ptr<ColourImpl> makeColourImpl( ColourMode colourSelection,
+                                                   IStream* stream ) {
+#if defined( CATCH_CONFIG_COLOUR_WIN32 )
+        if ( colourSelection == ColourMode::Win32 ) {
+            return Detail::make_unique<Win32ColourImpl>( stream );
+        }
+#endif
+        if ( colourSelection == ColourMode::ANSI ) {
+            return Detail::make_unique<ANSIColourImpl>( stream );
+        }
+        if ( colourSelection == ColourMode::None ) {
+            return Detail::make_unique<NoColourImpl>( stream );
+        }
+
+        if ( colourSelection == ColourMode::PlatformDefault) {
+#if defined( CATCH_CONFIG_COLOUR_WIN32 )
+            if ( Win32ColourImpl::useImplementationForStream( *stream ) ) {
+                return Detail::make_unique<Win32ColourImpl>( stream );
+            }
+#endif
+            if ( ANSIColourImpl::useImplementationForStream( *stream ) ) {
+                return Detail::make_unique<ANSIColourImpl>( stream );
+            }
+            return Detail::make_unique<NoColourImpl>( stream );
+        }
+
+        CATCH_ERROR( "Could not create colour impl for selection " << static_cast<int>(colourSelection) );
+    }
+
+    bool isColourImplAvailable( ColourMode colourSelection ) {
+        switch ( colourSelection ) {
+#if defined( CATCH_CONFIG_COLOUR_WIN32 )
+        case ColourMode::Win32:
+#endif
+        case ColourMode::ANSI:
+        case ColourMode::None:
+        case ColourMode::PlatformDefault:
+            return true;
+        default:
+            return false;
+        }
+    }
+
+
+} // end namespace Catch
+
+#if defined(__clang__)
+#    pragma clang diagnostic pop
+#endif
+
+
+
+
+namespace Catch {
+
+    Context* Context::currentContext = nullptr;
+
+    void cleanUpContext() {
+        delete Context::currentContext;
+        Context::currentContext = nullptr;
+    }
+    void Context::createContext() {
+        currentContext = new Context();
+    }
+
+    Context& getCurrentMutableContext() {
+        if ( !Context::currentContext ) { Context::createContext(); }
+        // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
+        return *Context::currentContext;
+    }
+
+    SimplePcg32& sharedRng() {
+        static SimplePcg32 s_rng;
+        return s_rng;
+    }
+
+}
+
+
+
+
+
+#include <ostream>
+
+#if defined(CATCH_CONFIG_ANDROID_LOGWRITE)
+#include <android/log.h>
+
+    namespace Catch {
+        void writeToDebugConsole( std::string const& text ) {
+            __android_log_write( ANDROID_LOG_DEBUG, "Catch", text.c_str() );
+        }
+    }
+
+#elif defined(CATCH_PLATFORM_WINDOWS)
+
+    namespace Catch {
+        void writeToDebugConsole( std::string const& text ) {
+            ::OutputDebugStringA( text.c_str() );
+        }
+    }
+
+#else
+
+    namespace Catch {
+        void writeToDebugConsole( std::string const& text ) {
+            // !TBD: Need a version for Mac/ XCode and other IDEs
+            Catch::cout() << text;
+        }
+    }
+
+#endif // Platform
+
+
+
+#if defined(CATCH_PLATFORM_MAC) || defined(CATCH_PLATFORM_IPHONE)
+
+#  include <cassert>
+#  include <sys/types.h>
+#  include <unistd.h>
+#  include <cstddef>
+#  include <ostream>
+
+#ifdef __apple_build_version__
+    // These headers will only compile with AppleClang (XCode)
+    // For other compilers (Clang, GCC, ... ) we need to exclude them
+#  include <sys/sysctl.h>
+#endif
+
+    namespace Catch {
+        #ifdef __apple_build_version__
+        // The following function is taken directly from the following technical note:
+        // https://developer.apple.com/library/archive/qa/qa1361/_index.html
+
+        // Returns true if the current process is being debugged (either
+        // running under the debugger or has a debugger attached post facto).
+        bool isDebuggerActive(){
+            int                 mib[4];
+            struct kinfo_proc   info;
+            std::size_t         size;
+
+            // Initialize the flags so that, if sysctl fails for some bizarre
+            // reason, we get a predictable result.
+
+            info.kp_proc.p_flag = 0;
+
+            // Initialize mib, which tells sysctl the info we want, in this case
+            // we're looking for information about a specific process ID.
+
+            mib[0] = CTL_KERN;
+            mib[1] = KERN_PROC;
+            mib[2] = KERN_PROC_PID;
+            mib[3] = getpid();
+
+            // Call sysctl.
+
+            size = sizeof(info);
+            if( sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, nullptr, 0) != 0 ) {
+                Catch::cerr() << "\n** Call to sysctl failed - unable to determine if debugger is active **\n\n" << std::flush;
+                return false;
+            }
+
+            // We're being debugged if the P_TRACED flag is set.
+
+            return ( (info.kp_proc.p_flag & P_TRACED) != 0 );
+        }
+        #else
+        bool isDebuggerActive() {
+            // We need to find another way to determine this for non-appleclang compilers on macOS
+            return false;
+        }
+        #endif
+    } // namespace Catch
+
+#elif defined(CATCH_PLATFORM_LINUX)
+    #include <fstream>
+    #include <string>
+
+    namespace Catch{
+        // The standard POSIX way of detecting a debugger is to attempt to
+        // ptrace() the process, but this needs to be done from a child and not
+        // this process itself to still allow attaching to this process later
+        // if wanted, so is rather heavy. Under Linux we have the PID of the
+        // "debugger" (which doesn't need to be gdb, of course, it could also
+        // be strace, for example) in /proc/$PID/status, so just get it from
+        // there instead.
+        bool isDebuggerActive(){
+            // Libstdc++ has a bug, where std::ifstream sets errno to 0
+            // This way our users can properly assert over errno values
+            ErrnoGuard guard;
+            std::ifstream in("/proc/self/status");
+            for( std::string line; std::getline(in, line); ) {
+                static const int PREFIX_LEN = 11;
+                if( line.compare(0, PREFIX_LEN, "TracerPid:\t") == 0 ) {
+                    // We're traced if the PID is not 0 and no other PID starts
+                    // with 0 digit, so it's enough to check for just a single
+                    // character.
+                    return line.length() > PREFIX_LEN && line[PREFIX_LEN] != '0';
+                }
+            }
+
+            return false;
+        }
+    } // namespace Catch
+#elif defined(_MSC_VER)
+    extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
+    namespace Catch {
+        bool isDebuggerActive() {
+            return IsDebuggerPresent() != 0;
+        }
+    }
+#elif defined(__MINGW32__)
+    extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
+    namespace Catch {
+        bool isDebuggerActive() {
+            return IsDebuggerPresent() != 0;
+        }
+    }
+#else
+    namespace Catch {
+       bool isDebuggerActive() { return false; }
+    }
+#endif // Platform
+
+
+
+
+namespace Catch {
+
+    void ITransientExpression::streamReconstructedExpression(
+        std::ostream& os ) const {
+        // We can't make this function pure virtual to keep ITransientExpression
+        // constexpr, so we write error message instead
+        os << "Some class derived from ITransientExpression without overriding streamReconstructedExpression";
+    }
+
+    void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs ) {
+        if( lhs.size() + rhs.size() < 40 &&
+                lhs.find('\n') == std::string::npos &&
+                rhs.find('\n') == std::string::npos )
+            os << lhs << ' ' << op << ' ' << rhs;
+        else
+            os << lhs << '\n' << op << '\n' << rhs;
+    }
+}
+
+
+
+#include <stdexcept>
+
+
+namespace Catch {
+#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS_CUSTOM_HANDLER)
+    [[noreturn]]
+    void throw_exception(std::exception const& e) {
+        Catch::cerr() << "Catch will terminate because it needed to throw an exception.\n"
+                      << "The message was: " << e.what() << '\n';
+        std::terminate();
+    }
+#endif
+
+    [[noreturn]]
+    void throw_logic_error(std::string const& msg) {
+        throw_exception(std::logic_error(msg));
+    }
+
+    [[noreturn]]
+    void throw_domain_error(std::string const& msg) {
+        throw_exception(std::domain_error(msg));
+    }
+
+    [[noreturn]]
+    void throw_runtime_error(std::string const& msg) {
+        throw_exception(std::runtime_error(msg));
+    }
+
+
+
+} // namespace Catch;
+
+
+
+#include <cassert>
+
+namespace Catch {
+
+    IMutableEnumValuesRegistry::~IMutableEnumValuesRegistry() = default;
+
+    namespace Detail {
+
+        namespace {
+            // Extracts the actual name part of an enum instance
+            // In other words, it returns the Blue part of Bikeshed::Colour::Blue
+            StringRef extractInstanceName(StringRef enumInstance) {
+                // Find last occurrence of ":"
+                size_t name_start = enumInstance.size();
+                while (name_start > 0 && enumInstance[name_start - 1] != ':') {
+                    --name_start;
+                }
+                return enumInstance.substr(name_start, enumInstance.size() - name_start);
+            }
+        }
+
+        std::vector<StringRef> parseEnums( StringRef enums ) {
+            auto enumValues = splitStringRef( enums, ',' );
+            std::vector<StringRef> parsed;
+            parsed.reserve( enumValues.size() );
+            for( auto const& enumValue : enumValues ) {
+                parsed.push_back(trim(extractInstanceName(enumValue)));
+            }
+            return parsed;
+        }
+
+        EnumInfo::~EnumInfo() = default;
+
+        StringRef EnumInfo::lookup( int value ) const {
+            for( auto const& valueToName : m_values ) {
+                if( valueToName.first == value )
+                    return valueToName.second;
+            }
+            return "{** unexpected enum value **}"_sr;
+        }
+
+        Catch::Detail::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
+            auto enumInfo = Catch::Detail::make_unique<EnumInfo>();
+            enumInfo->m_name = enumName;
+            enumInfo->m_values.reserve( values.size() );
+
+            const auto valueNames = Catch::Detail::parseEnums( allValueNames );
+            assert( valueNames.size() == values.size() );
+            std::size_t i = 0;
+            for( auto value : values )
+                enumInfo->m_values.emplace_back(value, valueNames[i++]);
+
+            return enumInfo;
+        }
+
+        EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
+            m_enumInfos.push_back(makeEnumInfo(enumName, allValueNames, values));
+            return *m_enumInfos.back();
+        }
+
+    } // Detail
+} // Catch
+
+
+
+
+
+#include <cerrno>
+
+namespace Catch {
+        ErrnoGuard::ErrnoGuard():m_oldErrno(errno){}
+        ErrnoGuard::~ErrnoGuard() { errno = m_oldErrno; }
+}
+
+
+
+#include <exception>
+
+namespace Catch {
+
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+    namespace {
+        static std::string tryTranslators(
+            std::vector<
+                Detail::unique_ptr<IExceptionTranslator const>> const& translators ) {
+            if ( translators.empty() ) {
+                std::rethrow_exception( std::current_exception() );
+            } else {
+                return translators[0]->translate( translators.begin() + 1,
+                                                  translators.end() );
+            }
+        }
+
+    }
+#endif //!defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+
+    ExceptionTranslatorRegistry::~ExceptionTranslatorRegistry() = default;
+
+    void ExceptionTranslatorRegistry::registerTranslator( Detail::unique_ptr<IExceptionTranslator>&& translator ) {
+        m_translators.push_back( CATCH_MOVE( translator ) );
+    }
+
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+    std::string ExceptionTranslatorRegistry::translateActiveException() const {
+        // Compiling a mixed mode project with MSVC means that CLR
+        // exceptions will be caught in (...) as well. However, these do
+        // do not fill-in std::current_exception and thus lead to crash
+        // when attempting rethrow.
+        // /EHa switch also causes structured exceptions to be caught
+        // here, but they fill-in current_exception properly, so
+        // at worst the output should be a little weird, instead of
+        // causing a crash.
+        if ( std::current_exception() == nullptr ) {
+            return "Non C++ exception. Possibly a CLR exception.";
+        }
+
+        // First we try user-registered translators. If none of them can
+        // handle the exception, it will be rethrown handled by our defaults.
+        try {
+            return tryTranslators(m_translators);
+        }
+        // To avoid having to handle TFE explicitly everywhere, we just
+        // rethrow it so that it goes back up the caller.
+        catch( TestFailureException& ) {
+            std::rethrow_exception(std::current_exception());
+        }
+        catch( TestSkipException& ) {
+            std::rethrow_exception(std::current_exception());
+        }
+        catch( std::exception const& ex ) {
+            return ex.what();
+        }
+        catch( std::string const& msg ) {
+            return msg;
+        }
+        catch( const char* msg ) {
+            return msg;
+        }
+        catch(...) {
+            return "Unknown exception";
+        }
+    }
+
+#else // ^^ Exceptions are enabled // Exceptions are disabled vv
+    std::string ExceptionTranslatorRegistry::translateActiveException() const {
+        CATCH_INTERNAL_ERROR("Attempted to translate active exception under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
+    }
+#endif
+
+}
+
+
+
+/** \file
+ * This file provides platform specific implementations of FatalConditionHandler
+ *
+ * This means that there is a lot of conditional compilation, and platform
+ * specific code. Currently, Catch2 supports a dummy handler (if no
+ * handler is desired), and 2 platform specific handlers:
+ *  * Windows' SEH
+ *  * POSIX signals
+ *
+ * Consequently, various pieces of code below are compiled if either of
+ * the platform specific handlers is enabled, or if none of them are
+ * enabled. It is assumed that both cannot be enabled at the same time,
+ * and doing so should cause a compilation error.
+ *
+ * If another platform specific handler is added, the compile guards
+ * below will need to be updated taking these assumptions into account.
+ */
+
+
+
+#include <algorithm>
+
+#if !defined( CATCH_CONFIG_WINDOWS_SEH ) && !defined( CATCH_CONFIG_POSIX_SIGNALS )
+
+namespace Catch {
+
+    // If neither SEH nor signal handling is required, the handler impls
+    // do not have to do anything, and can be empty.
+    void FatalConditionHandler::engage_platform() {}
+    void FatalConditionHandler::disengage_platform() noexcept {}
+    FatalConditionHandler::FatalConditionHandler() = default;
+    FatalConditionHandler::~FatalConditionHandler() = default;
+
+} // end namespace Catch
+
+#endif // !CATCH_CONFIG_WINDOWS_SEH && !CATCH_CONFIG_POSIX_SIGNALS
+
+#if defined( CATCH_CONFIG_WINDOWS_SEH ) && defined( CATCH_CONFIG_POSIX_SIGNALS )
+#error "Inconsistent configuration: Windows' SEH handling and POSIX signals cannot be enabled at the same time"
+#endif // CATCH_CONFIG_WINDOWS_SEH && CATCH_CONFIG_POSIX_SIGNALS
+
+#if defined( CATCH_CONFIG_WINDOWS_SEH ) || defined( CATCH_CONFIG_POSIX_SIGNALS )
+
+namespace {
+    //! Signals fatal error message to the run context
+    void reportFatal( char const * const message ) {
+        Catch::getCurrentContext().getResultCapture()->handleFatalErrorCondition( message );
+    }
+
+    //! Minimal size Catch2 needs for its own fatal error handling.
+    //! Picked empirically, so it might not be sufficient on all
+    //! platforms, and for all configurations.
+    constexpr std::size_t minStackSizeForErrors = 32 * 1024;
+} // end unnamed namespace
+
+#endif // CATCH_CONFIG_WINDOWS_SEH || CATCH_CONFIG_POSIX_SIGNALS
+
+#if defined( CATCH_CONFIG_WINDOWS_SEH )
+
+namespace Catch {
+
+    struct SignalDefs { DWORD id; const char* name; };
+
+    // There is no 1-1 mapping between signals and windows exceptions.
+    // Windows can easily distinguish between SO and SigSegV,
+    // but SigInt, SigTerm, etc are handled differently.
+    static SignalDefs signalDefs[] = {
+        { EXCEPTION_ILLEGAL_INSTRUCTION,  "SIGILL - Illegal instruction signal" },
+        { EXCEPTION_STACK_OVERFLOW, "SIGSEGV - Stack overflow" },
+        { EXCEPTION_ACCESS_VIOLATION, "SIGSEGV - Segmentation violation signal" },
+        { EXCEPTION_INT_DIVIDE_BY_ZERO, "Divide by zero error" },
+    };
+
+    static LONG CALLBACK topLevelExceptionFilter(PEXCEPTION_POINTERS ExceptionInfo) {
+        for (auto const& def : signalDefs) {
+            if (ExceptionInfo->ExceptionRecord->ExceptionCode == def.id) {
+                reportFatal(def.name);
+            }
+        }
+        // If its not an exception we care about, pass it along.
+        // This stops us from eating debugger breaks etc.
+        return EXCEPTION_CONTINUE_SEARCH;
+    }
+
+    // Since we do not support multiple instantiations, we put these
+    // into global variables and rely on cleaning them up in outlined
+    // constructors/destructors
+    static LPTOP_LEVEL_EXCEPTION_FILTER previousTopLevelExceptionFilter = nullptr;
+
+
+    // For MSVC, we reserve part of the stack memory for handling
+    // memory overflow structured exception.
+    FatalConditionHandler::FatalConditionHandler() {
+        ULONG guaranteeSize = static_cast<ULONG>(minStackSizeForErrors);
+        if (!SetThreadStackGuarantee(&guaranteeSize)) {
+            // We do not want to fully error out, because needing
+            // the stack reserve should be rare enough anyway.
+            Catch::cerr()
+                << "Failed to reserve piece of stack."
+                << " Stack overflows will not be reported successfully.";
+        }
+    }
+
+    // We do not attempt to unset the stack guarantee, because
+    // Windows does not support lowering the stack size guarantee.
+    FatalConditionHandler::~FatalConditionHandler() = default;
+
+
+    void FatalConditionHandler::engage_platform() {
+        // Register as a the top level exception filter.
+        previousTopLevelExceptionFilter = SetUnhandledExceptionFilter(topLevelExceptionFilter);
+    }
+
+    void FatalConditionHandler::disengage_platform() noexcept {
+        if (SetUnhandledExceptionFilter(previousTopLevelExceptionFilter) != topLevelExceptionFilter) {
+            Catch::cerr()
+                << "Unexpected SEH unhandled exception filter on disengage."
+                << " The filter was restored, but might be rolled back unexpectedly.";
+        }
+        previousTopLevelExceptionFilter = nullptr;
+    }
+
+} // end namespace Catch
+
+#endif // CATCH_CONFIG_WINDOWS_SEH
+
+#if defined( CATCH_CONFIG_POSIX_SIGNALS )
+
+#include <signal.h>
+
+namespace Catch {
+
+    struct SignalDefs {
+        int id;
+        const char* name;
+    };
+
+    static SignalDefs signalDefs[] = {
+        { SIGINT,  "SIGINT - Terminal interrupt signal" },
+        { SIGILL,  "SIGILL - Illegal instruction signal" },
+        { SIGFPE,  "SIGFPE - Floating point error signal" },
+        { SIGSEGV, "SIGSEGV - Segmentation violation signal" },
+        { SIGTERM, "SIGTERM - Termination request signal" },
+        { SIGABRT, "SIGABRT - Abort (abnormal termination) signal" }
+    };
+
+// Older GCCs trigger -Wmissing-field-initializers for T foo = {}
+// which is zero initialization, but not explicit. We want to avoid
+// that.
+#if defined(__GNUC__)
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wmissing-field-initializers"
+#endif
+
+    static char* altStackMem = nullptr;
+    static std::size_t altStackSize = 0;
+    static stack_t oldSigStack{};
+    static struct sigaction oldSigActions[sizeof(signalDefs) / sizeof(SignalDefs)]{};
+
+    static void restorePreviousSignalHandlers() noexcept {
+        // We set signal handlers back to the previous ones. Hopefully
+        // nobody overwrote them in the meantime, and doesn't expect
+        // their signal handlers to live past ours given that they
+        // installed them after ours..
+        for (std::size_t i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i) {
+            sigaction(signalDefs[i].id, &oldSigActions[i], nullptr);
+        }
+        // Return the old stack
+        sigaltstack(&oldSigStack, nullptr);
+    }
+
+    static void handleSignal( int sig ) {
+        char const * name = "<unknown signal>";
+        for (auto const& def : signalDefs) {
+            if (sig == def.id) {
+                name = def.name;
+                break;
+            }
+        }
+        // We need to restore previous signal handlers and let them do
+        // their thing, so that the users can have the debugger break
+        // when a signal is raised, and so on.
+        restorePreviousSignalHandlers();
+        reportFatal( name );
+        raise( sig );
+    }
+
+    FatalConditionHandler::FatalConditionHandler() {
+        assert(!altStackMem && "Cannot initialize POSIX signal handler when one already exists");
+        if (altStackSize == 0) {
+            altStackSize = std::max(static_cast<size_t>(SIGSTKSZ), minStackSizeForErrors);
+        }
+        altStackMem = new char[altStackSize]();
+    }
+
+    FatalConditionHandler::~FatalConditionHandler() {
+        delete[] altStackMem;
+        // We signal that another instance can be constructed by zeroing
+        // out the pointer.
+        altStackMem = nullptr;
+    }
+
+    void FatalConditionHandler::engage_platform() {
+        stack_t sigStack;
+        sigStack.ss_sp = altStackMem;
+        sigStack.ss_size = altStackSize;
+        sigStack.ss_flags = 0;
+        sigaltstack(&sigStack, &oldSigStack);
+        struct sigaction sa = { };
+
+        sa.sa_handler = handleSignal;
+        sa.sa_flags = SA_ONSTACK;
+        for (std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i) {
+            sigaction(signalDefs[i].id, &sa, &oldSigActions[i]);
+        }
+    }
+
+#if defined(__GNUC__)
+#    pragma GCC diagnostic pop
+#endif
+
+
+    void FatalConditionHandler::disengage_platform() noexcept {
+        restorePreviousSignalHandlers();
+    }
+
+} // end namespace Catch
+
+#endif // CATCH_CONFIG_POSIX_SIGNALS
+
+
+
+
+#include <cstring>
+
+namespace Catch {
+    namespace Detail {
+
+        uint32_t convertToBits(float f) {
+            static_assert(sizeof(float) == sizeof(uint32_t), "Important ULP matcher assumption violated");
+            uint32_t i;
+            std::memcpy(&i, &f, sizeof(f));
+            return i;
+        }
+
+        uint64_t convertToBits(double d) {
+            static_assert(sizeof(double) == sizeof(uint64_t), "Important ULP matcher assumption violated");
+            uint64_t i;
+            std::memcpy(&i, &d, sizeof(d));
+            return i;
+        }
+
+#if defined( __GNUC__ ) || defined( __clang__ )
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+        bool directCompare( float lhs, float rhs ) { return lhs == rhs; }
+        bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
+#if defined( __GNUC__ ) || defined( __clang__ )
+#    pragma GCC diagnostic pop
+#endif
+
+
+    } // end namespace Detail
+} // end namespace Catch
+
+
+
+
+
+
+#include <cstdlib>
+
+namespace Catch {
+    namespace Detail {
+
+#if !defined (CATCH_CONFIG_GETENV)
+        char const* getEnv( char const* ) { return nullptr; }
+#else
+
+        char const* getEnv( char const* varName ) {
+#    if defined( _MSC_VER )
+#        pragma warning( push )
+#        pragma warning( disable : 4996 ) // use getenv_s instead of getenv
+#    endif
+
+            return std::getenv( varName );
+
+#    if defined( _MSC_VER )
+#        pragma warning( pop )
+#    endif
+        }
+#endif
+} // namespace Detail
+} // namespace Catch
+
+
+
+
+#include <cstdio>
+#include <fstream>
+#include <sstream>
+#include <vector>
+
+namespace Catch {
+
+    Catch::IStream::~IStream() = default;
+
+namespace Detail {
+    namespace {
+        template<typename WriterF, std::size_t bufferSize=256>
+        class StreamBufImpl final : public std::streambuf {
+            char data[bufferSize];
+            WriterF m_writer;
+
+        public:
+            StreamBufImpl() {
+                setp( data, data + sizeof(data) );
+            }
+
+            ~StreamBufImpl() noexcept override {
+                StreamBufImpl::sync();
+            }
+
+        private:
+            int overflow( int c ) override {
+                sync();
+
+                if( c != EOF ) {
+                    if( pbase() == epptr() )
+                        m_writer( std::string( 1, static_cast<char>( c ) ) );
+                    else
+                        sputc( static_cast<char>( c ) );
+                }
+                return 0;
+            }
+
+            int sync() override {
+                if( pbase() != pptr() ) {
+                    m_writer( std::string( pbase(), static_cast<std::string::size_type>( pptr() - pbase() ) ) );
+                    setp( pbase(), epptr() );
+                }
+                return 0;
+            }
+        };
+
+        ///////////////////////////////////////////////////////////////////////////
+
+        struct OutputDebugWriter {
+
+            void operator()( std::string const& str ) {
+                if ( !str.empty() ) {
+                    writeToDebugConsole( str );
+                }
+            }
+        };
+
+        ///////////////////////////////////////////////////////////////////////////
+
+        class FileStream final : public IStream {
+            std::ofstream m_ofs;
+        public:
+            FileStream( std::string const& filename ) {
+                m_ofs.open( filename.c_str() );
+                CATCH_ENFORCE( !m_ofs.fail(), "Unable to open file: '" << filename << '\'' );
+                m_ofs << std::unitbuf;
+            }
+        public: // IStream
+            std::ostream& stream() override {
+                return m_ofs;
+            }
+        };
+
+        ///////////////////////////////////////////////////////////////////////////
+
+        class CoutStream final : public IStream {
+            std::ostream m_os;
+        public:
+            // Store the streambuf from cout up-front because
+            // cout may get redirected when running tests
+            CoutStream() : m_os( Catch::cout().rdbuf() ) {}
+
+        public: // IStream
+            std::ostream& stream() override { return m_os; }
+            bool isConsole() const override { return true; }
+        };
+
+        class CerrStream : public IStream {
+            std::ostream m_os;
+
+        public:
+            // Store the streambuf from cerr up-front because
+            // cout may get redirected when running tests
+            CerrStream(): m_os( Catch::cerr().rdbuf() ) {}
+
+        public: // IStream
+            std::ostream& stream() override { return m_os; }
+            bool isConsole() const override { return true; }
+        };
+
+        ///////////////////////////////////////////////////////////////////////////
+
+        class DebugOutStream final : public IStream {
+            Detail::unique_ptr<StreamBufImpl<OutputDebugWriter>> m_streamBuf;
+            std::ostream m_os;
+        public:
+            DebugOutStream()
+            :   m_streamBuf( Detail::make_unique<StreamBufImpl<OutputDebugWriter>>() ),
+                m_os( m_streamBuf.get() )
+            {}
+
+        public: // IStream
+            std::ostream& stream() override { return m_os; }
+        };
+
+    } // unnamed namespace
+} // namespace Detail
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    auto makeStream( std::string const& filename ) -> Detail::unique_ptr<IStream> {
+        if ( filename.empty() || filename == "-" ) {
+            return Detail::make_unique<Detail::CoutStream>();
+        }
+        if( filename[0] == '%' ) {
+            if ( filename == "%debug" ) {
+                return Detail::make_unique<Detail::DebugOutStream>();
+            } else if ( filename == "%stderr" ) {
+                return Detail::make_unique<Detail::CerrStream>();
+            } else if ( filename == "%stdout" ) {
+                return Detail::make_unique<Detail::CoutStream>();
+            } else {
+                CATCH_ERROR( "Unrecognised stream: '" << filename << '\'' );
+            }
+        }
+        return Detail::make_unique<Detail::FileStream>( filename );
+    }
+
+}
+
+
+
+namespace Catch {
+    void JsonUtils::indent( std::ostream& os, std::uint64_t level ) {
+        for ( std::uint64_t i = 0; i < level; ++i ) {
+            os << "  ";
+        }
+    }
+    void JsonUtils::appendCommaNewline( std::ostream& os,
+                                        bool& should_comma,
+                                        std::uint64_t level ) {
+        if ( should_comma ) { os << ','; }
+        should_comma = true;
+        os << '\n';
+        indent( os, level );
+    }
+
+    JsonObjectWriter::JsonObjectWriter( std::ostream& os ):
+        JsonObjectWriter{ os, 0 } {}
+
+    JsonObjectWriter::JsonObjectWriter( std::ostream& os,
+                                        std::uint64_t indent_level ):
+        m_os{ os }, m_indent_level{ indent_level } {
+        m_os << '{';
+    }
+    JsonObjectWriter::JsonObjectWriter( JsonObjectWriter&& source ) noexcept:
+        m_os{ source.m_os },
+        m_indent_level{ source.m_indent_level },
+        m_should_comma{ source.m_should_comma },
+        m_active{ source.m_active } {
+        source.m_active = false;
+    }
+
+    JsonObjectWriter::~JsonObjectWriter() {
+        if ( !m_active ) { return; }
+
+        m_os << '\n';
+        JsonUtils::indent( m_os, m_indent_level );
+        m_os << '}';
+    }
+
+    JsonValueWriter JsonObjectWriter::write( StringRef key ) {
+        JsonUtils::appendCommaNewline(
+            m_os, m_should_comma, m_indent_level + 1 );
+
+        m_os << '"' << key << "\": ";
+        return JsonValueWriter{ m_os, m_indent_level + 1 };
+    }
+
+    JsonArrayWriter::JsonArrayWriter( std::ostream& os ):
+        JsonArrayWriter{ os, 0 } {}
+    JsonArrayWriter::JsonArrayWriter( std::ostream& os,
+                                      std::uint64_t indent_level ):
+        m_os{ os }, m_indent_level{ indent_level } {
+        m_os << '[';
+    }
+    JsonArrayWriter::JsonArrayWriter( JsonArrayWriter&& source ) noexcept:
+        m_os{ source.m_os },
+        m_indent_level{ source.m_indent_level },
+        m_should_comma{ source.m_should_comma },
+        m_active{ source.m_active } {
+        source.m_active = false;
+    }
+    JsonArrayWriter::~JsonArrayWriter() {
+        if ( !m_active ) { return; }
+
+        m_os << '\n';
+        JsonUtils::indent( m_os, m_indent_level );
+        m_os << ']';
+    }
+
+    JsonObjectWriter JsonArrayWriter::writeObject() {
+        JsonUtils::appendCommaNewline(
+            m_os, m_should_comma, m_indent_level + 1 );
+        return JsonObjectWriter{ m_os, m_indent_level + 1 };
+    }
+
+    JsonArrayWriter JsonArrayWriter::writeArray() {
+        JsonUtils::appendCommaNewline(
+            m_os, m_should_comma, m_indent_level + 1 );
+        return JsonArrayWriter{ m_os, m_indent_level + 1 };
+    }
+
+    JsonArrayWriter& JsonArrayWriter::write( bool value ) {
+        return writeImpl( value );
+    }
+
+    JsonValueWriter::JsonValueWriter( std::ostream& os ):
+        JsonValueWriter{ os, 0 } {}
+
+    JsonValueWriter::JsonValueWriter( std::ostream& os,
+                                      std::uint64_t indent_level ):
+        m_os{ os }, m_indent_level{ indent_level } {}
+
+    JsonObjectWriter JsonValueWriter::writeObject() && {
+        return JsonObjectWriter{ m_os, m_indent_level };
+    }
+
+    JsonArrayWriter JsonValueWriter::writeArray() && {
+        return JsonArrayWriter{ m_os, m_indent_level };
+    }
+
+    void JsonValueWriter::write( Catch::StringRef value ) && {
+        writeImpl( value, true );
+    }
+
+    void JsonValueWriter::write( bool value ) && {
+        writeImpl( value ? "true"_sr : "false"_sr, false );
+    }
+
+    void JsonValueWriter::writeImpl( Catch::StringRef value, bool quote ) {
+        if ( quote ) { m_os << '"'; }
+        for (char c : value) {
+            // Escape list taken from https://www.json.org/json-en.html,
+            // string definition.
+            // Note that while forward slash _can_ be escaped, it does
+            // not have to be, if JSON is not further embedded somewhere
+            // where forward slash is meaningful.
+            if ( c == '"' ) {
+                m_os << "\\\"";
+            } else if ( c == '\\' ) {
+                m_os << "\\\\";
+            } else if ( c == '\b' ) {
+                m_os << "\\b";
+            } else if ( c == '\f' ) {
+                m_os << "\\f";
+            } else if ( c == '\n' ) {
+                m_os << "\\n";
+            } else if ( c == '\r' ) {
+                m_os << "\\r";
+            } else if ( c == '\t' ) {
+                m_os << "\\t";
+            } else {
+                m_os << c;
+            }
+        }
+        if ( quote ) { m_os << '"'; }
+    }
+
+} // namespace Catch
+
+
+
+
+namespace Catch {
+
+    auto operator << (std::ostream& os, LazyExpression const& lazyExpr) -> std::ostream& {
+        if (lazyExpr.m_isNegated)
+            os << '!';
+
+        if (lazyExpr) {
+            if (lazyExpr.m_isNegated && lazyExpr.m_transientExpression->isBinaryExpression())
+                os << '(' << *lazyExpr.m_transientExpression << ')';
+            else
+                os << *lazyExpr.m_transientExpression;
+        } else {
+            os << "{** error - unchecked empty expression requested **}";
+        }
+        return os;
+    }
+
+} // namespace Catch
+
+
+
+
+#ifdef CATCH_CONFIG_WINDOWS_CRTDBG
+#include <crtdbg.h>
+
+namespace Catch {
+
+    LeakDetector::LeakDetector() {
+        int flag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
+        flag |= _CRTDBG_LEAK_CHECK_DF;
+        flag |= _CRTDBG_ALLOC_MEM_DF;
+        _CrtSetDbgFlag(flag);
+        _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
+        _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
+        // Change this to leaking allocation's number to break there
+        _CrtSetBreakAlloc(-1);
+    }
+}
+
+#else // ^^ Windows crt debug heap enabled // Windows crt debug heap disabled vv
+
+    Catch::LeakDetector::LeakDetector() = default;
+
+#endif // CATCH_CONFIG_WINDOWS_CRTDBG
+
+Catch::LeakDetector::~LeakDetector() {
+    Catch::cleanUp();
+}
+
+
+
+
+namespace Catch {
+    namespace {
+
+        void listTests(IEventListener& reporter, IConfig const& config) {
+            auto const& testSpec = config.testSpec();
+            auto matchedTestCases = filterTests(getAllTestCasesSorted(config), testSpec, config);
+            reporter.listTests(matchedTestCases);
+        }
+
+        void listTags(IEventListener& reporter, IConfig const& config) {
+            auto const& testSpec = config.testSpec();
+            std::vector<TestCaseHandle> matchedTestCases = filterTests(getAllTestCasesSorted(config), testSpec, config);
+
+            std::map<StringRef, TagInfo, Detail::CaseInsensitiveLess> tagCounts;
+            for (auto const& testCase : matchedTestCases) {
+                for (auto const& tagName : testCase.getTestCaseInfo().tags) {
+                    auto it = tagCounts.find(tagName.original);
+                    if (it == tagCounts.end())
+                        it = tagCounts.insert(std::make_pair(tagName.original, TagInfo())).first;
+                    it->second.add(tagName.original);
+                }
+            }
+
+            std::vector<TagInfo> infos; infos.reserve(tagCounts.size());
+            for (auto& tagc : tagCounts) {
+                infos.push_back(CATCH_MOVE(tagc.second));
+            }
+
+            reporter.listTags(infos);
+        }
+
+        void listReporters(IEventListener& reporter) {
+            std::vector<ReporterDescription> descriptions;
+
+            auto const& factories = getRegistryHub().getReporterRegistry().getFactories();
+            descriptions.reserve(factories.size());
+            for (auto const& fac : factories) {
+                descriptions.push_back({ fac.first, fac.second->getDescription() });
+            }
+
+            reporter.listReporters(descriptions);
+        }
+
+        void listListeners(IEventListener& reporter) {
+            std::vector<ListenerDescription> descriptions;
+
+            auto const& factories =
+                getRegistryHub().getReporterRegistry().getListeners();
+            descriptions.reserve( factories.size() );
+            for ( auto const& fac : factories ) {
+                descriptions.push_back( { fac->getName(), fac->getDescription() } );
+            }
+
+            reporter.listListeners( descriptions );
+        }
+
+    } // end anonymous namespace
+
+    void TagInfo::add( StringRef spelling ) {
+        ++count;
+        spellings.insert( spelling );
+    }
+
+    std::string TagInfo::all() const {
+        // 2 per tag for brackets '[' and ']'
+        size_t size =  spellings.size() * 2;
+        for (auto const& spelling : spellings) {
+            size += spelling.size();
+        }
+
+        std::string out; out.reserve(size);
+        for (auto const& spelling : spellings) {
+            out += '[';
+            out += spelling;
+            out += ']';
+        }
+        return out;
+    }
+
+    bool list( IEventListener& reporter, Config const& config ) {
+        bool listed = false;
+        if (config.listTests()) {
+            listed = true;
+            listTests(reporter, config);
+        }
+        if (config.listTags()) {
+            listed = true;
+            listTags(reporter, config);
+        }
+        if (config.listReporters()) {
+            listed = true;
+            listReporters(reporter);
+        }
+        if ( config.listListeners() ) {
+            listed = true;
+            listListeners( reporter );
+        }
+        return listed;
+    }
+
+} // end namespace Catch
+
+
+
+namespace Catch {
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
+    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
+    static LeakDetector leakDetector;
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+}
+
+// Allow users of amalgamated .cpp file to remove our main and provide their own.
+#if !defined(CATCH_AMALGAMATED_CUSTOM_MAIN)
+
+#if defined(CATCH_CONFIG_WCHAR) && defined(CATCH_PLATFORM_WINDOWS) && defined(_UNICODE) && !defined(DO_NOT_USE_WMAIN)
+// Standard C/C++ Win32 Unicode wmain entry point
+extern "C" int __cdecl wmain (int argc, wchar_t * argv[], wchar_t * []) {
+#else
+// Standard C/C++ main entry point
+int main (int argc, char * argv[]) {
+#endif
+
+    // We want to force the linker not to discard the global variable
+    // and its constructor, as it (optionally) registers leak detector
+    (void)&Catch::leakDetector;
+
+    return Catch::Session().run( argc, argv );
+}
+
+#endif // !defined(CATCH_AMALGAMATED_CUSTOM_MAIN
+
+
+
+
+namespace Catch {
+
+    MessageInfo::MessageInfo(   StringRef _macroName,
+                                SourceLineInfo const& _lineInfo,
+                                ResultWas::OfType _type )
+    :   macroName( _macroName ),
+        lineInfo( _lineInfo ),
+        type( _type ),
+        sequence( ++globalCount )
+    {}
+
+    // This may need protecting if threading support is added
+    unsigned int MessageInfo::globalCount = 0;
+
+} // end namespace Catch
+
+
+
+#include <cstdio>
+#include <cstring>
+#include <iosfwd>
+#include <sstream>
+
+#if defined( CATCH_CONFIG_NEW_CAPTURE )
+#    if defined( _MSC_VER )
+#        include <io.h> //_dup and _dup2
+#        define dup _dup
+#        define dup2 _dup2
+#        define fileno _fileno
+#    else
+#        include <unistd.h> // dup and dup2
+#    endif
+#endif
+
+namespace Catch {
+
+    namespace {
+        //! A no-op implementation, used if no reporter wants output
+        //! redirection.
+        class NoopRedirect : public OutputRedirect {
+            void activateImpl() override {}
+            void deactivateImpl() override {}
+            std::string getStdout() override { return {}; }
+            std::string getStderr() override { return {}; }
+            void clearBuffers() override {}
+        };
+
+        /**
+         * Redirects specific stream's rdbuf with another's.
+         *
+         * Redirection can be stopped and started on-demand, assumes
+         * that the underlying stream's rdbuf aren't changed by other
+         * users.
+         */
+        class RedirectedStreamNew {
+            std::ostream& m_originalStream;
+            std::ostream& m_redirectionStream;
+            std::streambuf* m_prevBuf;
+
+        public:
+            RedirectedStreamNew( std::ostream& originalStream,
+                                 std::ostream& redirectionStream ):
+                m_originalStream( originalStream ),
+                m_redirectionStream( redirectionStream ),
+                m_prevBuf( m_originalStream.rdbuf() ) {}
+
+            void startRedirect() {
+                m_originalStream.rdbuf( m_redirectionStream.rdbuf() );
+            }
+            void stopRedirect() { m_originalStream.rdbuf( m_prevBuf ); }
+        };
+
+        /**
+         * Redirects the `std::cout`, `std::cerr`, `std::clog` streams,
+         * but does not touch the actual `stdout`/`stderr` file descriptors.
+         */
+        class StreamRedirect : public OutputRedirect {
+            ReusableStringStream m_redirectedOut, m_redirectedErr;
+            RedirectedStreamNew m_cout, m_cerr, m_clog;
+
+        public:
+            StreamRedirect():
+                m_cout( Catch::cout(), m_redirectedOut.get() ),
+                m_cerr( Catch::cerr(), m_redirectedErr.get() ),
+                m_clog( Catch::clog(), m_redirectedErr.get() ) {}
+
+            void activateImpl() override {
+                m_cout.startRedirect();
+                m_cerr.startRedirect();
+                m_clog.startRedirect();
+            }
+            void deactivateImpl() override {
+                m_cout.stopRedirect();
+                m_cerr.stopRedirect();
+                m_clog.stopRedirect();
+            }
+            std::string getStdout() override { return m_redirectedOut.str(); }
+            std::string getStderr() override { return m_redirectedErr.str(); }
+            void clearBuffers() override {
+                m_redirectedOut.str( "" );
+                m_redirectedErr.str( "" );
+            }
+        };
+
+#if defined( CATCH_CONFIG_NEW_CAPTURE )
+
+        // Windows's implementation of std::tmpfile is terrible (it tries
+        // to create a file inside system folder, thus requiring elevated
+        // privileges for the binary), so we have to use tmpnam(_s) and
+        // create the file ourselves there.
+        class TempFile {
+        public:
+            TempFile( TempFile const& ) = delete;
+            TempFile& operator=( TempFile const& ) = delete;
+            TempFile( TempFile&& ) = delete;
+            TempFile& operator=( TempFile&& ) = delete;
+
+#    if defined( _MSC_VER )
+            TempFile() {
+                if ( tmpnam_s( m_buffer ) ) {
+                    CATCH_RUNTIME_ERROR( "Could not get a temp filename" );
+                }
+                if ( fopen_s( &m_file, m_buffer, "wb+" ) ) {
+                    char buffer[100];
+                    if ( strerror_s( buffer, errno ) ) {
+                        CATCH_RUNTIME_ERROR(
+                            "Could not translate errno to a string" );
+                    }
+                    CATCH_RUNTIME_ERROR( "Could not open the temp file: '"
+                                         << m_buffer
+                                         << "' because: " << buffer );
+                }
+            }
+#    else
+            TempFile() {
+                m_file = std::tmpfile();
+                if ( !m_file ) {
+                    CATCH_RUNTIME_ERROR( "Could not create a temp file." );
+                }
+            }
+#    endif
+
+            ~TempFile() {
+                // TBD: What to do about errors here?
+                std::fclose( m_file );
+                // We manually create the file on Windows only, on Linux
+                // it will be autodeleted
+#    if defined( _MSC_VER )
+                std::remove( m_buffer );
+#    endif
+            }
+
+            std::FILE* getFile() { return m_file; }
+            std::string getContents() {
+                ReusableStringStream sstr;
+                constexpr long buffer_size = 100;
+                char buffer[buffer_size + 1] = {};
+                long current_pos = ftell( m_file );
+                CATCH_ENFORCE( current_pos >= 0,
+                               "ftell failed, errno: " << errno );
+                std::rewind( m_file );
+                while ( current_pos > 0 ) {
+                    auto read_characters =
+                        std::fread( buffer,
+                                    1,
+                                    std::min( buffer_size, current_pos ),
+                                    m_file );
+                    buffer[read_characters] = '\0';
+                    sstr << buffer;
+                    current_pos -= static_cast<long>( read_characters );
+                }
+                return sstr.str();
+            }
+
+            void clear() { std::rewind( m_file ); }
+
+        private:
+            std::FILE* m_file = nullptr;
+            char m_buffer[L_tmpnam] = { 0 };
+        };
+
+        /**
+         * Redirects the actual `stdout`/`stderr` file descriptors.
+         *
+         * Works by replacing the file descriptors numbered 1 and 2
+         * with an open temporary file.
+         */
+        class FileRedirect : public OutputRedirect {
+            TempFile m_outFile, m_errFile;
+            int m_originalOut = -1;
+            int m_originalErr = -1;
+
+            // Flushes cout/cerr/clog streams and stdout/stderr FDs
+            void flushEverything() {
+                Catch::cout() << std::flush;
+                fflush( stdout );
+                // Since we support overriding these streams, we flush cerr
+                // even though std::cerr is unbuffered
+                Catch::cerr() << std::flush;
+                Catch::clog() << std::flush;
+                fflush( stderr );
+            }
+
+        public:
+            FileRedirect():
+                m_originalOut( dup( fileno( stdout ) ) ),
+                m_originalErr( dup( fileno( stderr ) ) ) {
+                CATCH_ENFORCE( m_originalOut >= 0, "Could not dup stdout" );
+                CATCH_ENFORCE( m_originalErr >= 0, "Could not dup stderr" );
+            }
+
+            std::string getStdout() override { return m_outFile.getContents(); }
+            std::string getStderr() override { return m_errFile.getContents(); }
+            void clearBuffers() override {
+                m_outFile.clear();
+                m_errFile.clear();
+            }
+
+            void activateImpl() override {
+                // We flush before starting redirect, to ensure that we do
+                // not capture the end of message sent before activation.
+                flushEverything();
+
+                int ret;
+                ret = dup2( fileno( m_outFile.getFile() ), fileno( stdout ) );
+                CATCH_ENFORCE( ret >= 0,
+                               "dup2 to stdout has failed, errno: " << errno );
+                ret = dup2( fileno( m_errFile.getFile() ), fileno( stderr ) );
+                CATCH_ENFORCE( ret >= 0,
+                               "dup2 to stderr has failed, errno: " << errno );
+            }
+            void deactivateImpl() override {
+                // We flush before ending redirect, to ensure that we
+                // capture all messages sent while the redirect was active.
+                flushEverything();
+
+                int ret;
+                ret = dup2( m_originalOut, fileno( stdout ) );
+                CATCH_ENFORCE(
+                    ret >= 0,
+                    "dup2 of original stdout has failed, errno: " << errno );
+                ret = dup2( m_originalErr, fileno( stderr ) );
+                CATCH_ENFORCE(
+                    ret >= 0,
+                    "dup2 of original stderr has failed, errno: " << errno );
+            }
+        };
+
+#endif // CATCH_CONFIG_NEW_CAPTURE
+
+    } // end namespace
+
+    bool isRedirectAvailable( OutputRedirect::Kind kind ) {
+        switch ( kind ) {
+        // These two are always available
+        case OutputRedirect::None:
+        case OutputRedirect::Streams:
+            return true;
+#if defined( CATCH_CONFIG_NEW_CAPTURE )
+        case OutputRedirect::FileDescriptors:
+            return true;
+#endif
+        default:
+            return false;
+        }
+    }
+
+    Detail::unique_ptr<OutputRedirect> makeOutputRedirect( bool actual ) {
+        if ( actual ) {
+            // TODO: Clean this up later
+#if defined( CATCH_CONFIG_NEW_CAPTURE )
+            return Detail::make_unique<FileRedirect>();
+#else
+            return Detail::make_unique<StreamRedirect>();
+#endif
+        } else {
+            return Detail::make_unique<NoopRedirect>();
+        }
+    }
+
+    RedirectGuard scopedActivate( OutputRedirect& redirectImpl ) {
+        return RedirectGuard( true, redirectImpl );
+    }
+
+    RedirectGuard scopedDeactivate( OutputRedirect& redirectImpl ) {
+        return RedirectGuard( false, redirectImpl );
+    }
+
+    OutputRedirect::~OutputRedirect() = default;
+
+    RedirectGuard::RedirectGuard( bool activate, OutputRedirect& redirectImpl ):
+        m_redirect( &redirectImpl ),
+        m_activate( activate ),
+        m_previouslyActive( redirectImpl.isActive() ) {
+
+        // Skip cases where there is no actual state change.
+        if ( m_activate == m_previouslyActive ) { return; }
+
+        if ( m_activate ) {
+            m_redirect->activate();
+        } else {
+            m_redirect->deactivate();
+        }
+    }
+
+    RedirectGuard::~RedirectGuard() noexcept( false ) {
+        if ( m_moved ) { return; }
+        // Skip cases where there is no actual state change.
+        if ( m_activate == m_previouslyActive ) { return; }
+
+        if ( m_activate ) {
+            m_redirect->deactivate();
+        } else {
+            m_redirect->activate();
+        }
+    }
+
+    RedirectGuard::RedirectGuard( RedirectGuard&& rhs ) noexcept:
+        m_redirect( rhs.m_redirect ),
+        m_activate( rhs.m_activate ),
+        m_previouslyActive( rhs.m_previouslyActive ),
+        m_moved( false ) {
+        rhs.m_moved = true;
+    }
+
+    RedirectGuard& RedirectGuard::operator=( RedirectGuard&& rhs ) noexcept {
+        m_redirect = rhs.m_redirect;
+        m_activate = rhs.m_activate;
+        m_previouslyActive = rhs.m_previouslyActive;
+        m_moved = false;
+        rhs.m_moved = true;
+        return *this;
+    }
+
+} // namespace Catch
+
+#if defined( CATCH_CONFIG_NEW_CAPTURE )
+#    if defined( _MSC_VER )
+#        undef dup
+#        undef dup2
+#        undef fileno
+#    endif
+#endif
+
+
+
+
+#include <limits>
+#include <stdexcept>
+
+namespace Catch {
+
+    Optional<unsigned int> parseUInt(std::string const& input, int base) {
+        auto trimmed = trim( input );
+        // std::stoull is annoying and accepts numbers starting with '-',
+        // it just negates them into unsigned int
+        if ( trimmed.empty() || trimmed[0] == '-' ) {
+            return {};
+        }
+
+        CATCH_TRY {
+            size_t pos = 0;
+            const auto ret = std::stoull( trimmed, &pos, base );
+
+            // We did not consume the whole input, so there is an issue
+            // This can be bunch of different stuff, like multiple numbers
+            // in the input, or invalid digits/characters and so on. Either
+            // way, we do not want to return the partially parsed result.
+            if ( pos != trimmed.size() ) {
+                return {};
+            }
+            // Too large
+            if ( ret > std::numeric_limits<unsigned int>::max() ) {
+                return {};
+            }
+            return static_cast<unsigned int>(ret);
+        }
+        CATCH_CATCH_ANON( std::invalid_argument const& ) {
+            // no conversion could be performed
+        }
+        CATCH_CATCH_ANON( std::out_of_range const& ) {
+            // the input does not fit into an unsigned long long
+        }
+        return {};
+    }
+
+} // namespace Catch
+
+
+
+
+#include <cmath>
+
+namespace Catch {
+
+#if !defined(CATCH_CONFIG_POLYFILL_ISNAN)
+    bool isnan(float f) {
+        return std::isnan(f);
+    }
+    bool isnan(double d) {
+        return std::isnan(d);
+    }
+#else
+    // For now we only use this for embarcadero
+    bool isnan(float f) {
+        return std::_isnan(f);
+    }
+    bool isnan(double d) {
+        return std::_isnan(d);
+    }
+#endif
+
+#if !defined( CATCH_CONFIG_GLOBAL_NEXTAFTER )
+    float nextafter( float x, float y ) { return std::nextafter( x, y ); }
+    double nextafter( double x, double y ) { return std::nextafter( x, y ); }
+#else
+    float nextafter( float x, float y ) { return ::nextafterf( x, y ); }
+    double nextafter( double x, double y ) { return ::nextafter( x, y ); }
+#endif
+
+} // end namespace Catch
+
+
+
+namespace Catch {
+
+namespace {
+
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4146) // we negate uint32 during the rotate
+#endif
+        // Safe rotr implementation thanks to John Regehr
+        uint32_t rotate_right(uint32_t val, uint32_t count) {
+            const uint32_t mask = 31;
+            count &= mask;
+            return (val >> count) | (val << (-count & mask));
+        }
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+}
+
+
+    SimplePcg32::SimplePcg32(result_type seed_) {
+        seed(seed_);
+    }
+
+
+    void SimplePcg32::seed(result_type seed_) {
+        m_state = 0;
+        (*this)();
+        m_state += seed_;
+        (*this)();
+    }
+
+    void SimplePcg32::discard(uint64_t skip) {
+        // We could implement this to run in O(log n) steps, but this
+        // should suffice for our use case.
+        for (uint64_t s = 0; s < skip; ++s) {
+            static_cast<void>((*this)());
+        }
+    }
+
+    SimplePcg32::result_type SimplePcg32::operator()() {
+        // prepare the output value
+        const uint32_t xorshifted = static_cast<uint32_t>(((m_state >> 18u) ^ m_state) >> 27u);
+        const auto output = rotate_right(xorshifted, m_state >> 59u);
+
+        // advance state
+        m_state = m_state * 6364136223846793005ULL + s_inc;
+
+        return output;
+    }
+
+    bool operator==(SimplePcg32 const& lhs, SimplePcg32 const& rhs) {
+        return lhs.m_state == rhs.m_state;
+    }
+
+    bool operator!=(SimplePcg32 const& lhs, SimplePcg32 const& rhs) {
+        return lhs.m_state != rhs.m_state;
+    }
+}
+
+
+
+
+
+#include <ctime>
+#include <random>
+
+namespace Catch {
+
+    std::uint32_t generateRandomSeed( GenerateFrom from ) {
+        switch ( from ) {
+        case GenerateFrom::Time:
+            return static_cast<std::uint32_t>( std::time( nullptr ) );
+
+        case GenerateFrom::Default:
+        case GenerateFrom::RandomDevice: {
+            std::random_device rd;
+            return Detail::fillBitsFrom<std::uint32_t>( rd );
+        }
+
+        default:
+            CATCH_ERROR("Unknown generation method");
+        }
+    }
+
+} // end namespace Catch
+
+
+
+
+namespace Catch {
+    struct ReporterRegistry::ReporterRegistryImpl {
+        std::vector<Detail::unique_ptr<EventListenerFactory>> listeners;
+        std::map<std::string, IReporterFactoryPtr, Detail::CaseInsensitiveLess>
+            factories;
+    };
+
+    ReporterRegistry::ReporterRegistry():
+        m_impl( Detail::make_unique<ReporterRegistryImpl>() ) {
+        // Because it is impossible to move out of initializer list,
+        // we have to add the elements manually
+        m_impl->factories["Automake"] =
+            Detail::make_unique<ReporterFactory<AutomakeReporter>>();
+        m_impl->factories["compact"] =
+            Detail::make_unique<ReporterFactory<CompactReporter>>();
+        m_impl->factories["console"] =
+            Detail::make_unique<ReporterFactory<ConsoleReporter>>();
+        m_impl->factories["JUnit"] =
+            Detail::make_unique<ReporterFactory<JunitReporter>>();
+        m_impl->factories["SonarQube"] =
+            Detail::make_unique<ReporterFactory<SonarQubeReporter>>();
+        m_impl->factories["TAP"] =
+            Detail::make_unique<ReporterFactory<TAPReporter>>();
+        m_impl->factories["TeamCity"] =
+            Detail::make_unique<ReporterFactory<TeamCityReporter>>();
+        m_impl->factories["XML"] =
+            Detail::make_unique<ReporterFactory<XmlReporter>>();
+        m_impl->factories["JSON"] =
+            Detail::make_unique<ReporterFactory<JsonReporter>>();
+    }
+
+    ReporterRegistry::~ReporterRegistry() = default;
+
+    IEventListenerPtr
+    ReporterRegistry::create( std::string const& name,
+                              ReporterConfig&& config ) const {
+        auto it = m_impl->factories.find( name );
+        if ( it == m_impl->factories.end() ) return nullptr;
+        return it->second->create( CATCH_MOVE( config ) );
+    }
+
+    void ReporterRegistry::registerReporter( std::string const& name,
+                                             IReporterFactoryPtr factory ) {
+        CATCH_ENFORCE( name.find( "::" ) == name.npos,
+                       "'::' is not allowed in reporter name: '" + name +
+                           '\'' );
+        auto ret = m_impl->factories.emplace( name, CATCH_MOVE( factory ) );
+        CATCH_ENFORCE( ret.second,
+                       "reporter using '" + name +
+                           "' as name was already registered" );
+    }
+    void ReporterRegistry::registerListener(
+        Detail::unique_ptr<EventListenerFactory> factory ) {
+        m_impl->listeners.push_back( CATCH_MOVE( factory ) );
+    }
+
+    std::map<std::string,
+             IReporterFactoryPtr,
+             Detail::CaseInsensitiveLess> const&
+    ReporterRegistry::getFactories() const {
+        return m_impl->factories;
+    }
+
+    std::vector<Detail::unique_ptr<EventListenerFactory>> const&
+    ReporterRegistry::getListeners() const {
+        return m_impl->listeners;
+    }
+} // namespace Catch
+
+
+
+
+
+#include <algorithm>
+
+namespace Catch {
+
+    namespace {
+        struct kvPair {
+            StringRef key, value;
+        };
+
+        kvPair splitKVPair(StringRef kvString) {
+            auto splitPos = static_cast<size_t>(
+                std::find( kvString.begin(), kvString.end(), '=' ) -
+                kvString.begin() );
+
+            return { kvString.substr( 0, splitPos ),
+                     kvString.substr( splitPos + 1, kvString.size() ) };
+        }
+    }
+
+    namespace Detail {
+        std::vector<std::string> splitReporterSpec( StringRef reporterSpec ) {
+            static constexpr auto separator = "::";
+            static constexpr size_t separatorSize = 2;
+
+            size_t separatorPos = 0;
+            auto findNextSeparator = [&reporterSpec]( size_t startPos ) {
+                static_assert(
+                    separatorSize == 2,
+                    "The code below currently assumes 2 char separator" );
+
+                auto currentPos = startPos;
+                do {
+                    while ( currentPos < reporterSpec.size() &&
+                            reporterSpec[currentPos] != separator[0] ) {
+                        ++currentPos;
+                    }
+                    if ( currentPos + 1 < reporterSpec.size() &&
+                         reporterSpec[currentPos + 1] == separator[1] ) {
+                        return currentPos;
+                    }
+                    ++currentPos;
+                } while ( currentPos < reporterSpec.size() );
+
+                return static_cast<size_t>( -1 );
+            };
+
+            std::vector<std::string> parts;
+
+            while ( separatorPos < reporterSpec.size() ) {
+                const auto nextSeparator = findNextSeparator( separatorPos );
+                parts.push_back( static_cast<std::string>( reporterSpec.substr(
+                    separatorPos, nextSeparator - separatorPos ) ) );
+
+                if ( nextSeparator == static_cast<size_t>( -1 ) ) {
+                    break;
+                }
+                separatorPos = nextSeparator + separatorSize;
+            }
+
+            // Handle a separator at the end.
+            // This is not a valid spec, but we want to do validation in a
+            // centralized place
+            if ( separatorPos == reporterSpec.size() ) {
+                parts.emplace_back();
+            }
+
+            return parts;
+        }
+
+        Optional<ColourMode> stringToColourMode( StringRef colourMode ) {
+            if ( colourMode == "default" ) {
+                return ColourMode::PlatformDefault;
+            } else if ( colourMode == "ansi" ) {
+                return ColourMode::ANSI;
+            } else if ( colourMode == "win32" ) {
+                return ColourMode::Win32;
+            } else if ( colourMode == "none" ) {
+                return ColourMode::None;
+            } else {
+                return {};
+            }
+        }
+    } // namespace Detail
+
+
+    bool operator==( ReporterSpec const& lhs, ReporterSpec const& rhs ) {
+        return lhs.m_name == rhs.m_name &&
+               lhs.m_outputFileName == rhs.m_outputFileName &&
+               lhs.m_colourMode == rhs.m_colourMode &&
+               lhs.m_customOptions == rhs.m_customOptions;
+    }
+
+    Optional<ReporterSpec> parseReporterSpec( StringRef reporterSpec ) {
+        auto parts = Detail::splitReporterSpec( reporterSpec );
+
+        assert( parts.size() > 0 && "Split should never return empty vector" );
+
+        std::map<std::string, std::string> kvPairs;
+        Optional<std::string> outputFileName;
+        Optional<ColourMode> colourMode;
+
+        // First part is always reporter name, so we skip it
+        for ( size_t i = 1; i < parts.size(); ++i ) {
+            auto kv = splitKVPair( parts[i] );
+            auto key = kv.key, value = kv.value;
+
+            if ( key.empty() || value.empty() ) { // NOLINT(bugprone-branch-clone)
+                return {};
+            } else if ( key[0] == 'X' ) {
+                // This is a reporter-specific option, we don't check these
+                // apart from basic sanity checks
+                if ( key.size() == 1 ) {
+                    return {};
+                }
+
+                auto ret = kvPairs.emplace( std::string(kv.key), std::string(kv.value) );
+                if ( !ret.second ) {
+                    // Duplicated key. We might want to handle this differently,
+                    // e.g. by overwriting the existing value?
+                    return {};
+                }
+            } else if ( key == "out" ) {
+                // Duplicated key
+                if ( outputFileName ) {
+                    return {};
+                }
+                outputFileName = static_cast<std::string>( value );
+            } else if ( key == "colour-mode" ) {
+                // Duplicated key
+                if ( colourMode ) {
+                    return {};
+                }
+                colourMode = Detail::stringToColourMode( value );
+                // Parsing failed
+                if ( !colourMode ) {
+                    return {};
+                }
+            } else {
+                // Unrecognized option
+                return {};
+            }
+        }
+
+        return ReporterSpec{ CATCH_MOVE( parts[0] ),
+                             CATCH_MOVE( outputFileName ),
+                             CATCH_MOVE( colourMode ),
+                             CATCH_MOVE( kvPairs ) };
+    }
+
+ReporterSpec::ReporterSpec(
+        std::string name,
+        Optional<std::string> outputFileName,
+        Optional<ColourMode> colourMode,
+        std::map<std::string, std::string> customOptions ):
+        m_name( CATCH_MOVE( name ) ),
+        m_outputFileName( CATCH_MOVE( outputFileName ) ),
+        m_colourMode( CATCH_MOVE( colourMode ) ),
+        m_customOptions( CATCH_MOVE( customOptions ) ) {}
+
+} // namespace Catch
+
+
+
+#include <cstdio>
+#include <sstream>
+#include <vector>
+
+namespace Catch {
+
+    // This class encapsulates the idea of a pool of ostringstreams that can be reused.
+    struct StringStreams {
+        std::vector<Detail::unique_ptr<std::ostringstream>> m_streams;
+        std::vector<std::size_t> m_unused;
+        std::ostringstream m_referenceStream; // Used for copy state/ flags from
+
+        auto add() -> std::size_t {
+            if( m_unused.empty() ) {
+                m_streams.push_back( Detail::make_unique<std::ostringstream>() );
+                return m_streams.size()-1;
+            }
+            else {
+                auto index = m_unused.back();
+                m_unused.pop_back();
+                return index;
+            }
+        }
+
+        void release( std::size_t index ) {
+            m_streams[index]->copyfmt( m_referenceStream ); // Restore initial flags and other state
+            m_unused.push_back(index);
+        }
+    };
+
+    ReusableStringStream::ReusableStringStream()
+    :   m_index( Singleton<StringStreams>::getMutable().add() ),
+        m_oss( Singleton<StringStreams>::getMutable().m_streams[m_index].get() )
+    {}
+
+    ReusableStringStream::~ReusableStringStream() {
+        static_cast<std::ostringstream*>( m_oss )->str("");
+        m_oss->clear();
+        Singleton<StringStreams>::getMutable().release( m_index );
+    }
+
+    std::string ReusableStringStream::str() const {
+        return static_cast<std::ostringstream*>( m_oss )->str();
+    }
+
+    void ReusableStringStream::str( std::string const& str ) {
+        static_cast<std::ostringstream*>( m_oss )->str( str );
+    }
+
+
+}
+
+
+
+
+#include <cassert>
+#include <algorithm>
+
+namespace Catch {
+
+    namespace Generators {
+        namespace {
+            struct GeneratorTracker final : TestCaseTracking::TrackerBase,
+                                      IGeneratorTracker {
+                GeneratorBasePtr m_generator;
+
+                GeneratorTracker(
+                    TestCaseTracking::NameAndLocation&& nameAndLocation,
+                    TrackerContext& ctx,
+                    ITracker* parent ):
+                    TrackerBase( CATCH_MOVE( nameAndLocation ), ctx, parent ) {}
+
+                static GeneratorTracker*
+                acquire( TrackerContext& ctx,
+                         TestCaseTracking::NameAndLocationRef const&
+                             nameAndLocation ) {
+                    GeneratorTracker* tracker;
+
+                    ITracker& currentTracker = ctx.currentTracker();
+                    // Under specific circumstances, the generator we want
+                    // to acquire is also the current tracker. If this is
+                    // the case, we have to avoid looking through current
+                    // tracker's children, and instead return the current
+                    // tracker.
+                    // A case where this check is important is e.g.
+                    //     for (int i = 0; i < 5; ++i) {
+                    //         int n = GENERATE(1, 2);
+                    //     }
+                    //
+                    // without it, the code above creates 5 nested generators.
+                    if ( currentTracker.nameAndLocation() == nameAndLocation ) {
+                        auto thisTracker = currentTracker.parent()->findChild(
+                            nameAndLocation );
+                        assert( thisTracker );
+                        assert( thisTracker->isGeneratorTracker() );
+                        tracker = static_cast<GeneratorTracker*>( thisTracker );
+                    } else if ( ITracker* childTracker =
+                                    currentTracker.findChild(
+                                        nameAndLocation ) ) {
+                        assert( childTracker );
+                        assert( childTracker->isGeneratorTracker() );
+                        tracker =
+                            static_cast<GeneratorTracker*>( childTracker );
+                    } else {
+                        return nullptr;
+                    }
+
+                    if ( !tracker->isComplete() ) { tracker->open(); }
+
+                    return tracker;
+                }
+
+                // TrackerBase interface
+                bool isGeneratorTracker() const override { return true; }
+                auto hasGenerator() const -> bool override {
+                    return !!m_generator;
+                }
+                void close() override {
+                    TrackerBase::close();
+                    // If a generator has a child (it is followed by a section)
+                    // and none of its children have started, then we must wait
+                    // until later to start consuming its values.
+                    // This catches cases where `GENERATE` is placed between two
+                    // `SECTION`s.
+                    // **The check for m_children.empty cannot be removed**.
+                    // doing so would break `GENERATE` _not_ followed by
+                    // `SECTION`s.
+                    const bool should_wait_for_child = [&]() {
+                        // No children -> nobody to wait for
+                        if ( m_children.empty() ) { return false; }
+                        // If at least one child started executing, don't wait
+                        if ( std::find_if(
+                                 m_children.begin(),
+                                 m_children.end(),
+                                 []( TestCaseTracking::ITrackerPtr const&
+                                         tracker ) {
+                                     return tracker->hasStarted();
+                                 } ) != m_children.end() ) {
+                            return false;
+                        }
+
+                        // No children have started. We need to check if they
+                        // _can_ start, and thus we should wait for them, or
+                        // they cannot start (due to filters), and we shouldn't
+                        // wait for them
+                        ITracker* parent = m_parent;
+                        // This is safe: there is always at least one section
+                        // tracker in a test case tracking tree
+                        while ( !parent->isSectionTracker() ) {
+                            parent = parent->parent();
+                        }
+                        assert( parent &&
+                                "Missing root (test case) level section" );
+
+                        auto const& parentSection =
+                            static_cast<SectionTracker const&>( *parent );
+                        auto const& filters = parentSection.getFilters();
+                        // No filters -> no restrictions on running sections
+                        if ( filters.empty() ) { return true; }
+
+                        for ( auto const& child : m_children ) {
+                            if ( child->isSectionTracker() &&
+                                 std::find( filters.begin(),
+                                            filters.end(),
+                                            static_cast<SectionTracker const&>(
+                                                *child )
+                                                .trimmedName() ) !=
+                                     filters.end() ) {
+                                return true;
+                            }
+                        }
+                        return false;
+                    }();
+
+                    // This check is a bit tricky, because m_generator->next()
+                    // has a side-effect, where it consumes generator's current
+                    // value, but we do not want to invoke the side-effect if
+                    // this generator is still waiting for any child to start.
+                    assert( m_generator && "Tracker without generator" );
+                    if ( should_wait_for_child ||
+                         ( m_runState == CompletedSuccessfully &&
+                           m_generator->countedNext() ) ) {
+                        m_children.clear();
+                        m_runState = Executing;
+                    }
+                }
+
+                // IGeneratorTracker interface
+                auto getGenerator() const -> GeneratorBasePtr const& override {
+                    return m_generator;
+                }
+                void setGenerator( GeneratorBasePtr&& generator ) override {
+                    m_generator = CATCH_MOVE( generator );
+                }
+            };
+        } // namespace
+    }
+
+    RunContext::RunContext(IConfig const* _config, IEventListenerPtr&& reporter)
+    :   m_runInfo(_config->name()),
+        m_config(_config),
+        m_reporter(CATCH_MOVE(reporter)),
+        m_lastAssertionInfo{ StringRef(), SourceLineInfo("",0), StringRef(), ResultDisposition::Normal },
+        m_outputRedirect( makeOutputRedirect( m_reporter->getPreferences().shouldRedirectStdOut ) ),
+        m_includeSuccessfulResults( m_config->includeSuccessfulResults() || m_reporter->getPreferences().shouldReportAllAssertions )
+    {
+        getCurrentMutableContext().setResultCapture( this );
+        m_reporter->testRunStarting(m_runInfo);
+    }
+
+    RunContext::~RunContext() {
+        m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, aborting()));
+    }
+
+    Totals RunContext::runTest(TestCaseHandle const& testCase) {
+        const Totals prevTotals = m_totals;
+
+        auto const& testInfo = testCase.getTestCaseInfo();
+        m_reporter->testCaseStarting(testInfo);
+        testCase.prepareTestCase();
+        m_activeTestCase = &testCase;
+
+
+        ITracker& rootTracker = m_trackerContext.startRun();
+        assert(rootTracker.isSectionTracker());
+        static_cast<SectionTracker&>(rootTracker).addInitialFilters(m_config->getSectionsToRun());
+
+        // We intentionally only seed the internal RNG once per test case,
+        // before it is first invoked. The reason for that is a complex
+        // interplay of generator/section implementation details and the
+        // Random*Generator types.
+        //
+        // The issue boils down to us needing to seed the Random*Generators
+        // with different seed each, so that they return different sequences
+        // of random numbers. We do this by giving them a number from the
+        // shared RNG instance as their seed.
+        //
+        // However, this runs into an issue if the reseeding happens each
+        // time the test case is entered (as opposed to first time only),
+        // because multiple generators could get the same seed, e.g. in
+        // ```cpp
+        // TEST_CASE() {
+        //     auto i = GENERATE(take(10, random(0, 100));
+        //     SECTION("A") {
+        //         auto j = GENERATE(take(10, random(0, 100));
+        //     }
+        //     SECTION("B") {
+        //         auto k = GENERATE(take(10, random(0, 100));
+        //     }
+        // }
+        // ```
+        // `i` and `j` would properly return values from different sequences,
+        // but `i` and `k` would return the same sequence, because their seed
+        // would be the same.
+        // (The reason their seeds would be the same is that the generator
+        //  for k would be initialized when the test case is entered the second
+        //  time, after the shared RNG instance was reset to the same value
+        //  it had when the generator for i was initialized.)
+        seedRng( *m_config );
+
+        uint64_t testRuns = 0;
+        std::string redirectedCout;
+        std::string redirectedCerr;
+        do {
+            m_trackerContext.startCycle();
+            m_testCaseTracker = &SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocationRef(testInfo.name, testInfo.lineInfo));
+
+            m_reporter->testCasePartialStarting(testInfo, testRuns);
+
+            const auto beforeRunTotals = m_totals;
+            runCurrentTest();
+            std::string oneRunCout = m_outputRedirect->getStdout();
+            std::string oneRunCerr = m_outputRedirect->getStderr();
+            m_outputRedirect->clearBuffers();
+            redirectedCout += oneRunCout;
+            redirectedCerr += oneRunCerr;
+
+            const auto singleRunTotals = m_totals.delta(beforeRunTotals);
+            auto statsForOneRun = TestCaseStats(testInfo, singleRunTotals, CATCH_MOVE(oneRunCout), CATCH_MOVE(oneRunCerr), aborting());
+            m_reporter->testCasePartialEnded(statsForOneRun, testRuns);
+
+            ++testRuns;
+        } while (!m_testCaseTracker->isSuccessfullyCompleted() && !aborting());
+
+        Totals deltaTotals = m_totals.delta(prevTotals);
+        if (testInfo.expectedToFail() && deltaTotals.testCases.passed > 0) {
+            deltaTotals.assertions.failed++;
+            deltaTotals.testCases.passed--;
+            deltaTotals.testCases.failed++;
+        }
+        m_totals.testCases += deltaTotals.testCases;
+        testCase.tearDownTestCase();
+        m_reporter->testCaseEnded(TestCaseStats(testInfo,
+                                  deltaTotals,
+                                  CATCH_MOVE(redirectedCout),
+                                  CATCH_MOVE(redirectedCerr),
+                                  aborting()));
+
+        m_activeTestCase = nullptr;
+        m_testCaseTracker = nullptr;
+
+        return deltaTotals;
+    }
+
+
+    void RunContext::assertionEnded(AssertionResult&& result) {
+        if (result.getResultType() == ResultWas::Ok) {
+            m_totals.assertions.passed++;
+            m_lastAssertionPassed = true;
+        } else if (result.getResultType() == ResultWas::ExplicitSkip) {
+            m_totals.assertions.skipped++;
+            m_lastAssertionPassed = true;
+        } else if (!result.succeeded()) {
+            m_lastAssertionPassed = false;
+            if (result.isOk()) {
+            }
+            else if( m_activeTestCase->getTestCaseInfo().okToFail() )
+                m_totals.assertions.failedButOk++;
+            else
+                m_totals.assertions.failed++;
+        }
+        else {
+            m_lastAssertionPassed = true;
+        }
+
+        {
+            auto _ = scopedDeactivate( *m_outputRedirect );
+            m_reporter->assertionEnded( AssertionStats( result, m_messages, m_totals ) );
+        }
+
+        if ( result.getResultType() != ResultWas::Warning ) {
+            m_messageScopes.clear();
+        }
+
+        // Reset working state. assertion info will be reset after
+        // populateReaction is run if it is needed
+        m_lastResult = CATCH_MOVE( result );
+    }
+    void RunContext::resetAssertionInfo() {
+        m_lastAssertionInfo.macroName = StringRef();
+        m_lastAssertionInfo.capturedExpression = "{Unknown expression after the reported line}"_sr;
+        m_lastAssertionInfo.resultDisposition = ResultDisposition::Normal;
+    }
+
+    void RunContext::notifyAssertionStarted( AssertionInfo const& info ) {
+        auto _ = scopedDeactivate( *m_outputRedirect );
+        m_reporter->assertionStarting( info );
+    }
+
+    bool RunContext::sectionStarted( StringRef sectionName,
+                                     SourceLineInfo const& sectionLineInfo,
+                                     Counts& assertions ) {
+        ITracker& sectionTracker =
+            SectionTracker::acquire( m_trackerContext,
+                                     TestCaseTracking::NameAndLocationRef(
+                                         sectionName, sectionLineInfo ) );
+
+        if (!sectionTracker.isOpen())
+            return false;
+        m_activeSections.push_back(&sectionTracker);
+
+        SectionInfo sectionInfo( sectionLineInfo, static_cast<std::string>(sectionName) );
+        m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo;
+
+        {
+            auto _ = scopedDeactivate( *m_outputRedirect );
+            m_reporter->sectionStarting( sectionInfo );
+        }
+
+        assertions = m_totals.assertions;
+
+        return true;
+    }
+    IGeneratorTracker*
+    RunContext::acquireGeneratorTracker( StringRef generatorName,
+                                         SourceLineInfo const& lineInfo ) {
+        using namespace Generators;
+        GeneratorTracker* tracker = GeneratorTracker::acquire(
+            m_trackerContext,
+            TestCaseTracking::NameAndLocationRef(
+                 generatorName, lineInfo ) );
+        m_lastAssertionInfo.lineInfo = lineInfo;
+        return tracker;
+    }
+
+    IGeneratorTracker* RunContext::createGeneratorTracker(
+        StringRef generatorName,
+        SourceLineInfo lineInfo,
+        Generators::GeneratorBasePtr&& generator ) {
+
+        auto nameAndLoc = TestCaseTracking::NameAndLocation( static_cast<std::string>( generatorName ), lineInfo );
+        auto& currentTracker = m_trackerContext.currentTracker();
+        assert(
+            currentTracker.nameAndLocation() != nameAndLoc &&
+            "Trying to create tracker for a genreator that already has one" );
+
+        auto newTracker = Catch::Detail::make_unique<Generators::GeneratorTracker>(
+            CATCH_MOVE(nameAndLoc), m_trackerContext, &currentTracker );
+        auto ret = newTracker.get();
+        currentTracker.addChild( CATCH_MOVE( newTracker ) );
+
+        ret->setGenerator( CATCH_MOVE( generator ) );
+        ret->open();
+        return ret;
+    }
+
+    bool RunContext::testForMissingAssertions(Counts& assertions) {
+        if (assertions.total() != 0)
+            return false;
+        if (!m_config->warnAboutMissingAssertions())
+            return false;
+        if (m_trackerContext.currentTracker().hasChildren())
+            return false;
+        m_totals.assertions.failed++;
+        assertions.failed++;
+        return true;
+    }
+
+    void RunContext::sectionEnded(SectionEndInfo&& endInfo) {
+        Counts assertions = m_totals.assertions - endInfo.prevAssertions;
+        bool missingAssertions = testForMissingAssertions(assertions);
+
+        if (!m_activeSections.empty()) {
+            m_activeSections.back()->close();
+            m_activeSections.pop_back();
+        }
+
+        {
+            auto _ = scopedDeactivate( *m_outputRedirect );
+            m_reporter->sectionEnded(
+                SectionStats( CATCH_MOVE( endInfo.sectionInfo ),
+                              assertions,
+                              endInfo.durationInSeconds,
+                              missingAssertions ) );
+        }
+
+        m_messages.clear();
+        m_messageScopes.clear();
+    }
+
+    void RunContext::sectionEndedEarly(SectionEndInfo&& endInfo) {
+        if ( m_unfinishedSections.empty() ) {
+            m_activeSections.back()->fail();
+        } else {
+            m_activeSections.back()->close();
+        }
+        m_activeSections.pop_back();
+
+        m_unfinishedSections.push_back(CATCH_MOVE(endInfo));
+    }
+
+    void RunContext::benchmarkPreparing( StringRef name ) {
+        auto _ = scopedDeactivate( *m_outputRedirect );
+        m_reporter->benchmarkPreparing( name );
+    }
+    void RunContext::benchmarkStarting( BenchmarkInfo const& info ) {
+        auto _ = scopedDeactivate( *m_outputRedirect );
+        m_reporter->benchmarkStarting( info );
+    }
+    void RunContext::benchmarkEnded( BenchmarkStats<> const& stats ) {
+        auto _ = scopedDeactivate( *m_outputRedirect );
+        m_reporter->benchmarkEnded( stats );
+    }
+    void RunContext::benchmarkFailed( StringRef error ) {
+        auto _ = scopedDeactivate( *m_outputRedirect );
+        m_reporter->benchmarkFailed( error );
+    }
+
+    void RunContext::pushScopedMessage(MessageInfo const & message) {
+        m_messages.push_back(message);
+    }
+
+    void RunContext::popScopedMessage(MessageInfo const & message) {
+        m_messages.erase(std::remove(m_messages.begin(), m_messages.end(), message), m_messages.end());
+    }
+
+    void RunContext::emplaceUnscopedMessage( MessageBuilder&& builder ) {
+        m_messageScopes.emplace_back( CATCH_MOVE(builder) );
+    }
+
+    std::string RunContext::getCurrentTestName() const {
+        return m_activeTestCase
+            ? m_activeTestCase->getTestCaseInfo().name
+            : std::string();
+    }
+
+    const AssertionResult * RunContext::getLastResult() const {
+        return &(*m_lastResult);
+    }
+
+    void RunContext::exceptionEarlyReported() {
+        m_shouldReportUnexpected = false;
+    }
+
+    void RunContext::handleFatalErrorCondition( StringRef message ) {
+        // TODO: scoped deactivate here? Just give up and do best effort?
+        //       the deactivation can break things further, OTOH so can the
+        //       capture
+        auto _ = scopedDeactivate( *m_outputRedirect );
+
+        // First notify reporter that bad things happened
+        m_reporter->fatalErrorEncountered( message );
+
+        // Don't rebuild the result -- the stringification itself can cause more fatal errors
+        // Instead, fake a result data.
+        AssertionResultData tempResult( ResultWas::FatalErrorCondition, { false } );
+        tempResult.message = static_cast<std::string>(message);
+        AssertionResult result(m_lastAssertionInfo, CATCH_MOVE(tempResult));
+
+        assertionEnded(CATCH_MOVE(result) );
+        resetAssertionInfo();
+
+        // Best effort cleanup for sections that have not been destructed yet
+        // Since this is a fatal error, we have not had and won't have the opportunity to destruct them properly
+        while (!m_activeSections.empty()) {
+            auto nl = m_activeSections.back()->nameAndLocation();
+            SectionEndInfo endInfo{ SectionInfo(CATCH_MOVE(nl.location), CATCH_MOVE(nl.name)), {}, 0.0 };
+            sectionEndedEarly(CATCH_MOVE(endInfo));
+        }
+        handleUnfinishedSections();
+
+        // Recreate section for test case (as we will lose the one that was in scope)
+        auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
+        SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
+
+        Counts assertions;
+        assertions.failed = 1;
+        SectionStats testCaseSectionStats(CATCH_MOVE(testCaseSection), assertions, 0, false);
+        m_reporter->sectionEnded( testCaseSectionStats );
+
+        auto const& testInfo = m_activeTestCase->getTestCaseInfo();
+
+        Totals deltaTotals;
+        deltaTotals.testCases.failed = 1;
+        deltaTotals.assertions.failed = 1;
+        m_reporter->testCaseEnded(TestCaseStats(testInfo,
+                                  deltaTotals,
+                                  std::string(),
+                                  std::string(),
+                                  false));
+        m_totals.testCases.failed++;
+        m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, false));
+    }
+
+    bool RunContext::lastAssertionPassed() {
+         return m_lastAssertionPassed;
+    }
+
+    void RunContext::assertionPassed() {
+        m_lastAssertionPassed = true;
+        ++m_totals.assertions.passed;
+        resetAssertionInfo();
+        m_messageScopes.clear();
+    }
+
+    bool RunContext::aborting() const {
+        return m_totals.assertions.failed >= static_cast<std::size_t>(m_config->abortAfter());
+    }
+
+    void RunContext::runCurrentTest() {
+        auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
+        SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
+        m_reporter->sectionStarting(testCaseSection);
+        Counts prevAssertions = m_totals.assertions;
+        double duration = 0;
+        m_shouldReportUnexpected = true;
+        m_lastAssertionInfo = { "TEST_CASE"_sr, testCaseInfo.lineInfo, StringRef(), ResultDisposition::Normal };
+
+        Timer timer;
+        CATCH_TRY {
+            {
+                auto _ = scopedActivate( *m_outputRedirect );
+                timer.start();
+                invokeActiveTestCase();
+            }
+            duration = timer.getElapsedSeconds();
+        } CATCH_CATCH_ANON (TestFailureException&) {
+            // This just means the test was aborted due to failure
+        } CATCH_CATCH_ANON (TestSkipException&) {
+            // This just means the test was explicitly skipped
+        } CATCH_CATCH_ALL {
+            // Under CATCH_CONFIG_FAST_COMPILE, unexpected exceptions under REQUIRE assertions
+            // are reported without translation at the point of origin.
+            if( m_shouldReportUnexpected ) {
+                AssertionReaction dummyReaction;
+                handleUnexpectedInflightException( m_lastAssertionInfo, translateActiveException(), dummyReaction );
+            }
+        }
+        Counts assertions = m_totals.assertions - prevAssertions;
+        bool missingAssertions = testForMissingAssertions(assertions);
+
+        m_testCaseTracker->close();
+        handleUnfinishedSections();
+        m_messages.clear();
+        m_messageScopes.clear();
+
+        SectionStats testCaseSectionStats(CATCH_MOVE(testCaseSection), assertions, duration, missingAssertions);
+        m_reporter->sectionEnded(testCaseSectionStats);
+    }
+
+    void RunContext::invokeActiveTestCase() {
+        // We need to engage a handler for signals/structured exceptions
+        // before running the tests themselves, or the binary can crash
+        // without failed test being reported.
+        FatalConditionHandlerGuard _(&m_fatalConditionhandler);
+        // We keep having issue where some compilers warn about an unused
+        // variable, even though the type has non-trivial constructor and
+        // destructor. This is annoying and ugly, but it makes them stfu.
+        (void)_;
+
+        m_activeTestCase->invoke();
+    }
+
+    void RunContext::handleUnfinishedSections() {
+        // If sections ended prematurely due to an exception we stored their
+        // infos here so we can tear them down outside the unwind process.
+        for ( auto it = m_unfinishedSections.rbegin(),
+                   itEnd = m_unfinishedSections.rend();
+              it != itEnd;
+              ++it ) {
+            sectionEnded( CATCH_MOVE( *it ) );
+        }
+        m_unfinishedSections.clear();
+    }
+
+    void RunContext::handleExpr(
+        AssertionInfo const& info,
+        ITransientExpression const& expr,
+        AssertionReaction& reaction
+    ) {
+        bool negated = isFalseTest( info.resultDisposition );
+        bool result = expr.getResult() != negated;
+
+        if( result ) {
+            if (!m_includeSuccessfulResults) {
+                assertionPassed();
+            }
+            else {
+                reportExpr(info, ResultWas::Ok, &expr, negated);
+            }
+        }
+        else {
+            reportExpr(info, ResultWas::ExpressionFailed, &expr, negated );
+            populateReaction( reaction );
+        }
+        resetAssertionInfo();
+    }
+    void RunContext::reportExpr(
+            AssertionInfo const &info,
+            ResultWas::OfType resultType,
+            ITransientExpression const *expr,
+            bool negated ) {
+
+        m_lastAssertionInfo = info;
+        AssertionResultData data( resultType, LazyExpression( negated ) );
+
+        AssertionResult assertionResult{ info, CATCH_MOVE( data ) };
+        assertionResult.m_resultData.lazyExpression.m_transientExpression = expr;
+
+        assertionEnded( CATCH_MOVE(assertionResult) );
+    }
+
+    void RunContext::handleMessage(
+            AssertionInfo const& info,
+            ResultWas::OfType resultType,
+            std::string&& message,
+            AssertionReaction& reaction
+    ) {
+        m_lastAssertionInfo = info;
+
+        AssertionResultData data( resultType, LazyExpression( false ) );
+        data.message = CATCH_MOVE( message );
+        AssertionResult assertionResult{ m_lastAssertionInfo,
+                                         CATCH_MOVE( data ) };
+
+        const auto isOk = assertionResult.isOk();
+        assertionEnded( CATCH_MOVE(assertionResult) );
+        if ( !isOk ) {
+            populateReaction( reaction );
+        } else if ( resultType == ResultWas::ExplicitSkip ) {
+            // TODO: Need to handle this explicitly, as ExplicitSkip is
+            // considered "OK"
+            reaction.shouldSkip = true;
+        }
+        resetAssertionInfo();
+    }
+    void RunContext::handleUnexpectedExceptionNotThrown(
+            AssertionInfo const& info,
+            AssertionReaction& reaction
+    ) {
+        handleNonExpr(info, Catch::ResultWas::DidntThrowException, reaction);
+    }
+
+    void RunContext::handleUnexpectedInflightException(
+            AssertionInfo const& info,
+            std::string&& message,
+            AssertionReaction& reaction
+    ) {
+        m_lastAssertionInfo = info;
+
+        AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
+        data.message = CATCH_MOVE(message);
+        AssertionResult assertionResult{ info, CATCH_MOVE(data) };
+        assertionEnded( CATCH_MOVE(assertionResult) );
+        populateReaction( reaction );
+        resetAssertionInfo();
+    }
+
+    void RunContext::populateReaction( AssertionReaction& reaction ) {
+        reaction.shouldDebugBreak = m_config->shouldDebugBreak();
+        reaction.shouldThrow = aborting() || (m_lastAssertionInfo.resultDisposition & ResultDisposition::Normal);
+    }
+
+    void RunContext::handleIncomplete(
+            AssertionInfo const& info
+    ) {
+        using namespace std::string_literals;
+        m_lastAssertionInfo = info;
+
+        AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
+        data.message = "Exception translation was disabled by CATCH_CONFIG_FAST_COMPILE"s;
+        AssertionResult assertionResult{ info, CATCH_MOVE( data ) };
+        assertionEnded( CATCH_MOVE(assertionResult) );
+        resetAssertionInfo();
+    }
+    void RunContext::handleNonExpr(
+            AssertionInfo const &info,
+            ResultWas::OfType resultType,
+            AssertionReaction &reaction
+    ) {
+        m_lastAssertionInfo = info;
+
+        AssertionResultData data( resultType, LazyExpression( false ) );
+        AssertionResult assertionResult{ info, CATCH_MOVE( data ) };
+
+        const auto isOk = assertionResult.isOk();
+        assertionEnded( CATCH_MOVE(assertionResult) );
+        if ( !isOk ) { populateReaction( reaction ); }
+        resetAssertionInfo();
+    }
+
+
+    IResultCapture& getResultCapture() {
+        if (auto* capture = getCurrentContext().getResultCapture())
+            return *capture;
+        else
+            CATCH_INTERNAL_ERROR("No result capture instance");
+    }
+
+    void seedRng(IConfig const& config) {
+        sharedRng().seed(config.rngSeed());
+    }
+
+    unsigned int rngSeed() {
+        return getCurrentContext().getConfig()->rngSeed();
+    }
+
+}
+
+
+
+namespace Catch {
+
+    Section::Section( SectionInfo&& info ):
+        m_info( CATCH_MOVE( info ) ),
+        m_sectionIncluded(
+            getResultCapture().sectionStarted( m_info.name, m_info.lineInfo, m_assertions ) ) {
+        // Non-"included" sections will not use the timing information
+        // anyway, so don't bother with the potential syscall.
+        if (m_sectionIncluded) {
+            m_timer.start();
+        }
+    }
+
+    Section::Section( SourceLineInfo const& _lineInfo,
+                      StringRef _name,
+                      const char* const ):
+        m_info( { "invalid", static_cast<std::size_t>( -1 ) }, std::string{} ),
+        m_sectionIncluded(
+            getResultCapture().sectionStarted( _name, _lineInfo, m_assertions ) ) {
+        // We delay initialization the SectionInfo member until we know
+        // this section needs it, so we avoid allocating std::string for name.
+        // We also delay timer start to avoid the potential syscall unless we
+        // will actually use the result.
+        if ( m_sectionIncluded ) {
+            m_info.name = static_cast<std::string>( _name );
+            m_info.lineInfo = _lineInfo;
+            m_timer.start();
+        }
+    }
+
+    Section::~Section() {
+        if( m_sectionIncluded ) {
+            SectionEndInfo endInfo{ CATCH_MOVE(m_info), m_assertions, m_timer.getElapsedSeconds() };
+            if ( uncaught_exceptions() ) {
+                getResultCapture().sectionEndedEarly( CATCH_MOVE(endInfo) );
+            } else {
+                getResultCapture().sectionEnded( CATCH_MOVE( endInfo ) );
+            }
+        }
+    }
+
+    // This indicates whether the section should be executed or not
+    Section::operator bool() const {
+        return m_sectionIncluded;
+    }
+
+
+} // end namespace Catch
+
+
+
+#include <vector>
+
+namespace Catch {
+
+    namespace {
+        static auto getSingletons() -> std::vector<ISingleton*>*& {
+            static std::vector<ISingleton*>* g_singletons = nullptr;
+            if( !g_singletons )
+                g_singletons = new std::vector<ISingleton*>();
+            return g_singletons;
+        }
+    }
+
+    ISingleton::~ISingleton() = default;
+
+    void addSingleton(ISingleton* singleton ) {
+        getSingletons()->push_back( singleton );
+    }
+    void cleanupSingletons() {
+        auto& singletons = getSingletons();
+        for( auto singleton : *singletons )
+            delete singleton;
+        delete singletons;
+        singletons = nullptr;
+    }
+
+} // namespace Catch
+
+
+
+#include <cstring>
+#include <ostream>
+
+namespace Catch {
+
+    bool SourceLineInfo::operator == ( SourceLineInfo const& other ) const noexcept {
+        return line == other.line && (file == other.file || std::strcmp(file, other.file) == 0);
+    }
+    bool SourceLineInfo::operator < ( SourceLineInfo const& other ) const noexcept {
+        // We can assume that the same file will usually have the same pointer.
+        // Thus, if the pointers are the same, there is no point in calling the strcmp
+        return line < other.line || ( line == other.line && file != other.file && (std::strcmp(file, other.file) < 0));
+    }
+
+    std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ) {
+#ifndef __GNUG__
+        os << info.file << '(' << info.line << ')';
+#else
+        os << info.file << ':' << info.line;
+#endif
+        return os;
+    }
+
+} // end namespace Catch
+
+
+
+
+namespace Catch {
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+    void StartupExceptionRegistry::add( std::exception_ptr const& exception ) noexcept {
+        CATCH_TRY {
+            m_exceptions.push_back(exception);
+        } CATCH_CATCH_ALL {
+            // If we run out of memory during start-up there's really not a lot more we can do about it
+            std::terminate();
+        }
+    }
+
+    std::vector<std::exception_ptr> const& StartupExceptionRegistry::getExceptions() const noexcept {
+        return m_exceptions;
+    }
+#endif
+
+} // end namespace Catch
+
+
+
+
+
+#include <iostream>
+
+namespace Catch {
+
+// If you #define this you must implement these functions
+#if !defined( CATCH_CONFIG_NOSTDOUT )
+    std::ostream& cout() { return std::cout; }
+    std::ostream& cerr() { return std::cerr; }
+    std::ostream& clog() { return std::clog; }
+#endif
+
+} // namespace Catch
+
+
+
+#include <ostream>
+#include <cstring>
+#include <cctype>
+#include <vector>
+
+namespace Catch {
+
+    bool startsWith( std::string const& s, std::string const& prefix ) {
+        return s.size() >= prefix.size() && std::equal(prefix.begin(), prefix.end(), s.begin());
+    }
+    bool startsWith( StringRef s, char prefix ) {
+        return !s.empty() && s[0] == prefix;
+    }
+    bool endsWith( std::string const& s, std::string const& suffix ) {
+        return s.size() >= suffix.size() && std::equal(suffix.rbegin(), suffix.rend(), s.rbegin());
+    }
+    bool endsWith( std::string const& s, char suffix ) {
+        return !s.empty() && s[s.size()-1] == suffix;
+    }
+    bool contains( std::string const& s, std::string const& infix ) {
+        return s.find( infix ) != std::string::npos;
+    }
+    void toLowerInPlace( std::string& s ) {
+        for ( char& c : s ) {
+            c = toLower( c );
+        }
+    }
+    std::string toLower( std::string const& s ) {
+        std::string lc = s;
+        toLowerInPlace( lc );
+        return lc;
+    }
+    char toLower(char c) {
+        return static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
+    }
+
+    std::string trim( std::string const& str ) {
+        static char const* whitespaceChars = "\n\r\t ";
+        std::string::size_type start = str.find_first_not_of( whitespaceChars );
+        std::string::size_type end = str.find_last_not_of( whitespaceChars );
+
+        return start != std::string::npos ? str.substr( start, 1+end-start ) : std::string();
+    }
+
+    StringRef trim(StringRef ref) {
+        const auto is_ws = [](char c) {
+            return c == ' ' || c == '\t' || c == '\n' || c == '\r';
+        };
+        size_t real_begin = 0;
+        while (real_begin < ref.size() && is_ws(ref[real_begin])) { ++real_begin; }
+        size_t real_end = ref.size();
+        while (real_end > real_begin && is_ws(ref[real_end - 1])) { --real_end; }
+
+        return ref.substr(real_begin, real_end - real_begin);
+    }
+
+    bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis ) {
+        std::size_t i = str.find( replaceThis );
+        if (i == std::string::npos) {
+            return false;
+        }
+        std::size_t copyBegin = 0;
+        std::string origStr = CATCH_MOVE(str);
+        str.clear();
+        // There is at least one replacement, so reserve with the best guess
+        // we can make without actually counting the number of occurrences.
+        str.reserve(origStr.size() - replaceThis.size() + withThis.size());
+        do {
+            str.append(origStr, copyBegin, i-copyBegin );
+            str += withThis;
+            copyBegin = i + replaceThis.size();
+            if( copyBegin < origStr.size() )
+                i = origStr.find( replaceThis, copyBegin );
+            else
+                i = std::string::npos;
+        } while( i != std::string::npos );
+        if ( copyBegin < origStr.size() ) {
+            str.append(origStr, copyBegin, origStr.size() );
+        }
+        return true;
+    }
+
+    std::vector<StringRef> splitStringRef( StringRef str, char delimiter ) {
+        std::vector<StringRef> subStrings;
+        std::size_t start = 0;
+        for(std::size_t pos = 0; pos < str.size(); ++pos ) {
+            if( str[pos] == delimiter ) {
+                if( pos - start > 1 )
+                    subStrings.push_back( str.substr( start, pos-start ) );
+                start = pos+1;
+            }
+        }
+        if( start < str.size() )
+            subStrings.push_back( str.substr( start, str.size()-start ) );
+        return subStrings;
+    }
+
+    std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser ) {
+        os << pluraliser.m_count << ' ' << pluraliser.m_label;
+        if( pluraliser.m_count != 1 )
+            os << 's';
+        return os;
+    }
+
+}
+
+
+
+#include <algorithm>
+#include <ostream>
+#include <cstring>
+#include <cstdint>
+
+namespace Catch {
+    StringRef::StringRef( char const* rawChars ) noexcept
+    : StringRef( rawChars, std::strlen(rawChars) )
+    {}
+
+
+    bool StringRef::operator<(StringRef rhs) const noexcept {
+        if (m_size < rhs.m_size) {
+            return strncmp(m_start, rhs.m_start, m_size) <= 0;
+        }
+        return strncmp(m_start, rhs.m_start, rhs.m_size) < 0;
+    }
+
+    int StringRef::compare( StringRef rhs ) const {
+        auto cmpResult =
+            strncmp( m_start, rhs.m_start, std::min( m_size, rhs.m_size ) );
+
+        // This means that strncmp found a difference before the strings
+        // ended, and we can return it directly
+        if ( cmpResult != 0 ) {
+            return cmpResult;
+        }
+
+        // If strings are equal up to length, then their comparison results on
+        // their size
+        if ( m_size < rhs.m_size ) {
+            return -1;
+        } else if ( m_size > rhs.m_size ) {
+            return 1;
+        } else {
+            return 0;
+        }
+    }
+
+    auto operator << ( std::ostream& os, StringRef str ) -> std::ostream& {
+        return os.write(str.data(), static_cast<std::streamsize>(str.size()));
+    }
+
+    std::string operator+(StringRef lhs, StringRef rhs) {
+        std::string ret;
+        ret.reserve(lhs.size() + rhs.size());
+        ret += lhs;
+        ret += rhs;
+        return ret;
+    }
+
+    auto operator+=( std::string& lhs, StringRef rhs ) -> std::string& {
+        lhs.append(rhs.data(), rhs.size());
+        return lhs;
+    }
+
+} // namespace Catch
+
+
+
+namespace Catch {
+
+    TagAliasRegistry::~TagAliasRegistry() = default;
+
+    TagAlias const* TagAliasRegistry::find( std::string const& alias ) const {
+        auto it = m_registry.find( alias );
+        if( it != m_registry.end() )
+            return &(it->second);
+        else
+            return nullptr;
+    }
+
+    std::string TagAliasRegistry::expandAliases( std::string const& unexpandedTestSpec ) const {
+        std::string expandedTestSpec = unexpandedTestSpec;
+        for( auto const& registryKvp : m_registry ) {
+            std::size_t pos = expandedTestSpec.find( registryKvp.first );
+            if( pos != std::string::npos ) {
+                expandedTestSpec =  expandedTestSpec.substr( 0, pos ) +
+                                    registryKvp.second.tag +
+                                    expandedTestSpec.substr( pos + registryKvp.first.size() );
+            }
+        }
+        return expandedTestSpec;
+    }
+
+    void TagAliasRegistry::add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) {
+        CATCH_ENFORCE( startsWith(alias, "[@") && endsWith(alias, ']'),
+                      "error: tag alias, '" << alias << "' is not of the form [@alias name].\n" << lineInfo );
+
+        CATCH_ENFORCE( m_registry.insert(std::make_pair(alias, TagAlias(tag, lineInfo))).second,
+                      "error: tag alias, '" << alias << "' already registered.\n"
+                      << "\tFirst seen at: " << find(alias)->lineInfo << "\n"
+                      << "\tRedefined at: " << lineInfo );
+    }
+
+    ITagAliasRegistry::~ITagAliasRegistry() = default;
+
+    ITagAliasRegistry const& ITagAliasRegistry::get() {
+        return getRegistryHub().getTagAliasRegistry();
+    }
+
+} // end namespace Catch
+
+
+
+
+namespace Catch {
+    TestCaseInfoHasher::TestCaseInfoHasher( hash_t seed ): m_seed( seed ) {}
+
+    uint32_t TestCaseInfoHasher::operator()( TestCaseInfo const& t ) const {
+        // FNV-1a hash algorithm that is designed for uniqueness:
+        const hash_t prime = 1099511628211u;
+        hash_t hash = 14695981039346656037u;
+        for ( const char c : t.name ) {
+            hash ^= c;
+            hash *= prime;
+        }
+        for ( const char c : t.className ) {
+            hash ^= c;
+            hash *= prime;
+        }
+        for ( const Tag& tag : t.tags ) {
+            for ( const char c : tag.original ) {
+                hash ^= c;
+                hash *= prime;
+            }
+        }
+        hash ^= m_seed;
+        hash *= prime;
+        const uint32_t low{ static_cast<uint32_t>( hash ) };
+        const uint32_t high{ static_cast<uint32_t>( hash >> 32 ) };
+        return low * high;
+    }
+} // namespace Catch
+
+
+
+
+#include <algorithm>
+#include <set>
+
+namespace Catch {
+
+    namespace {
+        static void enforceNoDuplicateTestCases(
+            std::vector<TestCaseHandle> const& tests ) {
+            auto testInfoCmp = []( TestCaseInfo const* lhs,
+                                   TestCaseInfo const* rhs ) {
+                return *lhs < *rhs;
+            };
+            std::set<TestCaseInfo const*, decltype( testInfoCmp )&> seenTests(
+                testInfoCmp );
+            for ( auto const& test : tests ) {
+                const auto infoPtr = &test.getTestCaseInfo();
+                const auto prev = seenTests.insert( infoPtr );
+                CATCH_ENFORCE( prev.second,
+                               "error: test case \""
+                                   << infoPtr->name << "\", with tags \""
+                                   << infoPtr->tagsAsString()
+                                   << "\" already defined.\n"
+                                   << "\tFirst seen at "
+                                   << ( *prev.first )->lineInfo << "\n"
+                                   << "\tRedefined at " << infoPtr->lineInfo );
+            }
+        }
+
+        static bool matchTest( TestCaseHandle const& testCase,
+                               TestSpec const& testSpec,
+                               IConfig const& config ) {
+            return testSpec.matches( testCase.getTestCaseInfo() ) &&
+                   isThrowSafe( testCase, config );
+        }
+
+    } // end unnamed namespace
+
+    std::vector<TestCaseHandle> sortTests( IConfig const& config, std::vector<TestCaseHandle> const& unsortedTestCases ) {
+        switch (config.runOrder()) {
+        case TestRunOrder::Declared:
+            return unsortedTestCases;
+
+        case TestRunOrder::LexicographicallySorted: {
+            std::vector<TestCaseHandle> sorted = unsortedTestCases;
+            std::sort(
+                sorted.begin(),
+                sorted.end(),
+                []( TestCaseHandle const& lhs, TestCaseHandle const& rhs ) {
+                    return lhs.getTestCaseInfo() < rhs.getTestCaseInfo();
+                }
+            );
+            return sorted;
+        }
+        case TestRunOrder::Randomized: {
+            using TestWithHash = std::pair<TestCaseInfoHasher::hash_t, TestCaseHandle>;
+
+            TestCaseInfoHasher h{ config.rngSeed() };
+            std::vector<TestWithHash> indexed_tests;
+            indexed_tests.reserve(unsortedTestCases.size());
+
+            for (auto const& handle : unsortedTestCases) {
+                indexed_tests.emplace_back(h(handle.getTestCaseInfo()), handle);
+            }
+
+            std::sort( indexed_tests.begin(),
+                       indexed_tests.end(),
+                       []( TestWithHash const& lhs, TestWithHash const& rhs ) {
+                           if ( lhs.first == rhs.first ) {
+                               return lhs.second.getTestCaseInfo() <
+                                      rhs.second.getTestCaseInfo();
+                           }
+                           return lhs.first < rhs.first;
+                       } );
+
+            std::vector<TestCaseHandle> randomized;
+            randomized.reserve(indexed_tests.size());
+
+            for (auto const& indexed : indexed_tests) {
+                randomized.push_back(indexed.second);
+            }
+
+            return randomized;
+        }
+        }
+
+        CATCH_INTERNAL_ERROR("Unknown test order value!");
+    }
+
+    bool isThrowSafe( TestCaseHandle const& testCase, IConfig const& config ) {
+        return !testCase.getTestCaseInfo().throws() || config.allowThrows();
+    }
+
+    std::vector<TestCaseHandle> filterTests( std::vector<TestCaseHandle> const& testCases, TestSpec const& testSpec, IConfig const& config ) {
+        std::vector<TestCaseHandle> filtered;
+        filtered.reserve( testCases.size() );
+        for (auto const& testCase : testCases) {
+            if ((!testSpec.hasFilters() && !testCase.getTestCaseInfo().isHidden()) ||
+                (testSpec.hasFilters() && matchTest(testCase, testSpec, config))) {
+                filtered.push_back(testCase);
+            }
+        }
+        return createShard(filtered, config.shardCount(), config.shardIndex());
+    }
+    std::vector<TestCaseHandle> const& getAllTestCasesSorted( IConfig const& config ) {
+        return getRegistryHub().getTestCaseRegistry().getAllTestsSorted( config );
+    }
+
+    TestRegistry::~TestRegistry() = default;
+
+    void TestRegistry::registerTest(Detail::unique_ptr<TestCaseInfo> testInfo, Detail::unique_ptr<ITestInvoker> testInvoker) {
+        m_handles.emplace_back(testInfo.get(), testInvoker.get());
+        m_viewed_test_infos.push_back(testInfo.get());
+        m_owned_test_infos.push_back(CATCH_MOVE(testInfo));
+        m_invokers.push_back(CATCH_MOVE(testInvoker));
+    }
+
+    std::vector<TestCaseInfo*> const& TestRegistry::getAllInfos() const {
+        return m_viewed_test_infos;
+    }
+
+    std::vector<TestCaseHandle> const& TestRegistry::getAllTests() const {
+        return m_handles;
+    }
+    std::vector<TestCaseHandle> const& TestRegistry::getAllTestsSorted( IConfig const& config ) const {
+        if( m_sortedFunctions.empty() )
+            enforceNoDuplicateTestCases( m_handles );
+
+        if(  m_currentSortOrder != config.runOrder() || m_sortedFunctions.empty() ) {
+            m_sortedFunctions = sortTests( config, m_handles );
+            m_currentSortOrder = config.runOrder();
+        }
+        return m_sortedFunctions;
+    }
+
+} // end namespace Catch
+
+
+
+
+#include <algorithm>
+#include <cassert>
+
+#if defined(__clang__)
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wexit-time-destructors"
+#endif
+
+namespace Catch {
+namespace TestCaseTracking {
+
+    NameAndLocation::NameAndLocation( std::string&& _name, SourceLineInfo const& _location )
+    :   name( CATCH_MOVE(_name) ),
+        location( _location )
+    {}
+
+
+    ITracker::~ITracker() = default;
+
+    void ITracker::markAsNeedingAnotherRun() {
+        m_runState = NeedsAnotherRun;
+    }
+
+    void ITracker::addChild( ITrackerPtr&& child ) {
+        m_children.push_back( CATCH_MOVE(child) );
+    }
+
+    ITracker* ITracker::findChild( NameAndLocationRef const& nameAndLocation ) {
+        auto it = std::find_if(
+            m_children.begin(),
+            m_children.end(),
+            [&nameAndLocation]( ITrackerPtr const& tracker ) {
+                auto const& tnameAndLoc = tracker->nameAndLocation();
+                if ( tnameAndLoc.location.line !=
+                     nameAndLocation.location.line ) {
+                    return false;
+                }
+                return tnameAndLoc == nameAndLocation;
+            } );
+        return ( it != m_children.end() ) ? it->get() : nullptr;
+    }
+
+    bool ITracker::isSectionTracker() const { return false; }
+    bool ITracker::isGeneratorTracker() const { return false; }
+
+    bool ITracker::isOpen() const {
+        return m_runState != NotStarted && !isComplete();
+    }
+
+    bool ITracker::hasStarted() const { return m_runState != NotStarted; }
+
+    void ITracker::openChild() {
+        if (m_runState != ExecutingChildren) {
+            m_runState = ExecutingChildren;
+            if (m_parent) {
+                m_parent->openChild();
+            }
+        }
+    }
+
+    ITracker& TrackerContext::startRun() {
+        using namespace std::string_literals;
+        m_rootTracker = Catch::Detail::make_unique<SectionTracker>(
+            NameAndLocation( "{root}"s, CATCH_INTERNAL_LINEINFO ),
+            *this,
+            nullptr );
+        m_currentTracker = nullptr;
+        m_runState = Executing;
+        return *m_rootTracker;
+    }
+
+    void TrackerContext::completeCycle() {
+        m_runState = CompletedCycle;
+    }
+
+    bool TrackerContext::completedCycle() const {
+        return m_runState == CompletedCycle;
+    }
+    void TrackerContext::setCurrentTracker( ITracker* tracker ) {
+        m_currentTracker = tracker;
+    }
+
+
+    TrackerBase::TrackerBase( NameAndLocation&& nameAndLocation, TrackerContext& ctx, ITracker* parent ):
+        ITracker(CATCH_MOVE(nameAndLocation), parent),
+        m_ctx( ctx )
+    {}
+
+    bool TrackerBase::isComplete() const {
+        return m_runState == CompletedSuccessfully || m_runState == Failed;
+    }
+
+    void TrackerBase::open() {
+        m_runState = Executing;
+        moveToThis();
+        if( m_parent )
+            m_parent->openChild();
+    }
+
+    void TrackerBase::close() {
+
+        // Close any still open children (e.g. generators)
+        while( &m_ctx.currentTracker() != this )
+            m_ctx.currentTracker().close();
+
+        switch( m_runState ) {
+            case NeedsAnotherRun:
+                break;
+
+            case Executing:
+                m_runState = CompletedSuccessfully;
+                break;
+            case ExecutingChildren:
+                if( std::all_of(m_children.begin(), m_children.end(), [](ITrackerPtr const& t){ return t->isComplete(); }) )
+                    m_runState = CompletedSuccessfully;
+                break;
+
+            case NotStarted:
+            case CompletedSuccessfully:
+            case Failed:
+                CATCH_INTERNAL_ERROR( "Illogical state: " << m_runState );
+
+            default:
+                CATCH_INTERNAL_ERROR( "Unknown state: " << m_runState );
+        }
+        moveToParent();
+        m_ctx.completeCycle();
+    }
+    void TrackerBase::fail() {
+        m_runState = Failed;
+        if( m_parent )
+            m_parent->markAsNeedingAnotherRun();
+        moveToParent();
+        m_ctx.completeCycle();
+    }
+
+    void TrackerBase::moveToParent() {
+        assert( m_parent );
+        m_ctx.setCurrentTracker( m_parent );
+    }
+    void TrackerBase::moveToThis() {
+        m_ctx.setCurrentTracker( this );
+    }
+
+    SectionTracker::SectionTracker( NameAndLocation&& nameAndLocation, TrackerContext& ctx, ITracker* parent )
+    :   TrackerBase( CATCH_MOVE(nameAndLocation), ctx, parent ),
+        m_trimmed_name(trim(StringRef(ITracker::nameAndLocation().name)))
+    {
+        if( parent ) {
+            while ( !parent->isSectionTracker() ) {
+                parent = parent->parent();
+            }
+
+            SectionTracker& parentSection = static_cast<SectionTracker&>( *parent );
+            addNextFilters( parentSection.m_filters );
+        }
+    }
+
+    bool SectionTracker::isComplete() const {
+        bool complete = true;
+
+        if (m_filters.empty()
+            || m_filters[0].empty()
+            || std::find(m_filters.begin(), m_filters.end(), m_trimmed_name) != m_filters.end()) {
+            complete = TrackerBase::isComplete();
+        }
+        return complete;
+    }
+
+    bool SectionTracker::isSectionTracker() const { return true; }
+
+    SectionTracker& SectionTracker::acquire( TrackerContext& ctx, NameAndLocationRef const& nameAndLocation ) {
+        SectionTracker* tracker;
+
+        ITracker& currentTracker = ctx.currentTracker();
+        if ( ITracker* childTracker =
+                 currentTracker.findChild( nameAndLocation ) ) {
+            assert( childTracker );
+            assert( childTracker->isSectionTracker() );
+            tracker = static_cast<SectionTracker*>( childTracker );
+        } else {
+            auto newTracker = Catch::Detail::make_unique<SectionTracker>(
+                NameAndLocation{ static_cast<std::string>(nameAndLocation.name),
+                                 nameAndLocation.location },
+                ctx,
+                &currentTracker );
+            tracker = newTracker.get();
+            currentTracker.addChild( CATCH_MOVE( newTracker ) );
+        }
+
+        if ( !ctx.completedCycle() ) {
+            tracker->tryOpen();
+        }
+
+        return *tracker;
+    }
+
+    void SectionTracker::tryOpen() {
+        if( !isComplete() )
+            open();
+    }
+
+    void SectionTracker::addInitialFilters( std::vector<std::string> const& filters ) {
+        if( !filters.empty() ) {
+            m_filters.reserve( m_filters.size() + filters.size() + 2 );
+            m_filters.emplace_back(StringRef{}); // Root - should never be consulted
+            m_filters.emplace_back(StringRef{}); // Test Case - not a section filter
+            m_filters.insert( m_filters.end(), filters.begin(), filters.end() );
+        }
+    }
+    void SectionTracker::addNextFilters( std::vector<StringRef> const& filters ) {
+        if( filters.size() > 1 )
+            m_filters.insert( m_filters.end(), filters.begin()+1, filters.end() );
+    }
+
+    StringRef SectionTracker::trimmedName() const {
+        return m_trimmed_name;
+    }
+
+} // namespace TestCaseTracking
+
+} // namespace Catch
+
+#if defined(__clang__)
+#    pragma clang diagnostic pop
+#endif
+
+
+
+
+namespace Catch {
+
+    void throw_test_failure_exception() {
+#if !defined( CATCH_CONFIG_DISABLE_EXCEPTIONS )
+        throw TestFailureException{};
+#else
+        CATCH_ERROR( "Test failure requires aborting test!" );
+#endif
+    }
+
+    void throw_test_skip_exception() {
+#if !defined( CATCH_CONFIG_DISABLE_EXCEPTIONS )
+        throw Catch::TestSkipException();
+#else
+        CATCH_ERROR( "Explicitly skipping tests during runtime requires exceptions" );
+#endif
+    }
+
+} // namespace Catch
+
+
+
+#include <algorithm>
+#include <iterator>
+
+namespace Catch {
+    void ITestInvoker::prepareTestCase() {}
+    void ITestInvoker::tearDownTestCase() {}
+    ITestInvoker::~ITestInvoker() = default;
+
+    namespace {
+        static StringRef extractClassName( StringRef classOrMethodName ) {
+            if ( !startsWith( classOrMethodName, '&' ) ) {
+                return classOrMethodName;
+            }
+
+            // Remove the leading '&' to avoid having to special case it later
+            const auto methodName =
+                classOrMethodName.substr( 1, classOrMethodName.size() );
+
+            auto reverseStart = std::make_reverse_iterator( methodName.end() );
+            auto reverseEnd = std::make_reverse_iterator( methodName.begin() );
+
+            // We make a simplifying assumption that ":" is only present
+            // in the input as part of "::" from C++ typenames (this is
+            // relatively safe assumption because the input is generated
+            // as stringification of type through preprocessor).
+            auto lastColons = std::find( reverseStart, reverseEnd, ':' ) + 1;
+            auto secondLastColons =
+                std::find( lastColons + 1, reverseEnd, ':' );
+
+            auto const startIdx = reverseEnd - secondLastColons;
+            auto const classNameSize = secondLastColons - lastColons - 1;
+
+            return methodName.substr(
+                static_cast<std::size_t>( startIdx ),
+                static_cast<std::size_t>( classNameSize ) );
+        }
+
+        class TestInvokerAsFunction final : public ITestInvoker {
+            using TestType = void ( * )();
+            TestType m_testAsFunction;
+
+        public:
+            constexpr TestInvokerAsFunction( TestType testAsFunction ) noexcept:
+                m_testAsFunction( testAsFunction ) {}
+
+            void invoke() const override { m_testAsFunction(); }
+        };
+
+    } // namespace
+
+    Detail::unique_ptr<ITestInvoker> makeTestInvoker( void(*testAsFunction)() ) {
+        return Detail::make_unique<TestInvokerAsFunction>( testAsFunction );
+    }
+
+    AutoReg::AutoReg( Detail::unique_ptr<ITestInvoker> invoker, SourceLineInfo const& lineInfo, StringRef classOrMethod, NameAndTags const& nameAndTags ) noexcept {
+        CATCH_TRY {
+            getMutableRegistryHub()
+                    .registerTest(
+                        makeTestCaseInfo(
+                            extractClassName( classOrMethod ),
+                            nameAndTags,
+                            lineInfo),
+                        CATCH_MOVE(invoker)
+                    );
+        } CATCH_CATCH_ALL {
+            // Do not throw when constructing global objects, instead register the exception to be processed later
+            getMutableRegistryHub().registerStartupException();
+        }
+    }
+}
+
+
+
+
+
+namespace Catch {
+
+    TestSpecParser::TestSpecParser( ITagAliasRegistry const& tagAliases ) : m_tagAliases( &tagAliases ) {}
+
+    TestSpecParser& TestSpecParser::parse( std::string const& arg ) {
+        m_mode = None;
+        m_exclusion = false;
+        m_arg = m_tagAliases->expandAliases( arg );
+        m_escapeChars.clear();
+        m_substring.reserve(m_arg.size());
+        m_patternName.reserve(m_arg.size());
+        m_realPatternPos = 0;
+
+        for( m_pos = 0; m_pos < m_arg.size(); ++m_pos )
+          //if visitChar fails
+           if( !visitChar( m_arg[m_pos] ) ){
+               m_testSpec.m_invalidSpecs.push_back(arg);
+               break;
+           }
+        endMode();
+        return *this;
+    }
+    TestSpec TestSpecParser::testSpec() {
+        addFilter();
+        return CATCH_MOVE(m_testSpec);
+    }
+    bool TestSpecParser::visitChar( char c ) {
+        if( (m_mode != EscapedName) && (c == '\\') ) {
+            escape();
+            addCharToPattern(c);
+            return true;
+        }else if((m_mode != EscapedName) && (c == ',') )  {
+            return separate();
+        }
+
+        switch( m_mode ) {
+        case None:
+            if( processNoneChar( c ) )
+                return true;
+            break;
+        case Name:
+            processNameChar( c );
+            break;
+        case EscapedName:
+            endMode();
+            addCharToPattern(c);
+            return true;
+        default:
+        case Tag:
+        case QuotedName:
+            if( processOtherChar( c ) )
+                return true;
+            break;
+        }
+
+        m_substring += c;
+        if( !isControlChar( c ) ) {
+            m_patternName += c;
+            m_realPatternPos++;
+        }
+        return true;
+    }
+    // Two of the processing methods return true to signal the caller to return
+    // without adding the given character to the current pattern strings
+    bool TestSpecParser::processNoneChar( char c ) {
+        switch( c ) {
+        case ' ':
+            return true;
+        case '~':
+            m_exclusion = true;
+            return false;
+        case '[':
+            startNewMode( Tag );
+            return false;
+        case '"':
+            startNewMode( QuotedName );
+            return false;
+        default:
+            startNewMode( Name );
+            return false;
+        }
+    }
+    void TestSpecParser::processNameChar( char c ) {
+        if( c == '[' ) {
+            if( m_substring == "exclude:" )
+                m_exclusion = true;
+            else
+                endMode();
+            startNewMode( Tag );
+        }
+    }
+    bool TestSpecParser::processOtherChar( char c ) {
+        if( !isControlChar( c ) )
+            return false;
+        m_substring += c;
+        endMode();
+        return true;
+    }
+    void TestSpecParser::startNewMode( Mode mode ) {
+        m_mode = mode;
+    }
+    void TestSpecParser::endMode() {
+        switch( m_mode ) {
+        case Name:
+        case QuotedName:
+            return addNamePattern();
+        case Tag:
+            return addTagPattern();
+        case EscapedName:
+            revertBackToLastMode();
+            return;
+        case None:
+        default:
+            return startNewMode( None );
+        }
+    }
+    void TestSpecParser::escape() {
+        saveLastMode();
+        m_mode = EscapedName;
+        m_escapeChars.push_back(m_realPatternPos);
+    }
+    bool TestSpecParser::isControlChar( char c ) const {
+        switch( m_mode ) {
+            default:
+                return false;
+            case None:
+                return c == '~';
+            case Name:
+                return c == '[';
+            case EscapedName:
+                return true;
+            case QuotedName:
+                return c == '"';
+            case Tag:
+                return c == '[' || c == ']';
+        }
+    }
+
+    void TestSpecParser::addFilter() {
+        if( !m_currentFilter.m_required.empty() || !m_currentFilter.m_forbidden.empty() ) {
+            m_testSpec.m_filters.push_back( CATCH_MOVE(m_currentFilter) );
+            m_currentFilter = TestSpec::Filter();
+        }
+    }
+
+    void TestSpecParser::saveLastMode() {
+      lastMode = m_mode;
+    }
+
+    void TestSpecParser::revertBackToLastMode() {
+      m_mode = lastMode;
+    }
+
+    bool TestSpecParser::separate() {
+      if( (m_mode==QuotedName) || (m_mode==Tag) ){
+         //invalid argument, signal failure to previous scope.
+         m_mode = None;
+         m_pos = m_arg.size();
+         m_substring.clear();
+         m_patternName.clear();
+         m_realPatternPos = 0;
+         return false;
+      }
+      endMode();
+      addFilter();
+      return true; //success
+    }
+
+    std::string TestSpecParser::preprocessPattern() {
+        std::string token = m_patternName;
+        for (std::size_t i = 0; i < m_escapeChars.size(); ++i)
+            token = token.substr(0, m_escapeChars[i] - i) + token.substr(m_escapeChars[i] - i + 1);
+        m_escapeChars.clear();
+        if (startsWith(token, "exclude:")) {
+            m_exclusion = true;
+            token = token.substr(8);
+        }
+
+        m_patternName.clear();
+        m_realPatternPos = 0;
+
+        return token;
+    }
+
+    void TestSpecParser::addNamePattern() {
+        auto token = preprocessPattern();
+
+        if (!token.empty()) {
+            if (m_exclusion) {
+                m_currentFilter.m_forbidden.emplace_back(Detail::make_unique<TestSpec::NamePattern>(token, m_substring));
+            } else {
+                m_currentFilter.m_required.emplace_back(Detail::make_unique<TestSpec::NamePattern>(token, m_substring));
+            }
+        }
+        m_substring.clear();
+        m_exclusion = false;
+        m_mode = None;
+    }
+
+    void TestSpecParser::addTagPattern() {
+        auto token = preprocessPattern();
+
+        if (!token.empty()) {
+            // If the tag pattern is the "hide and tag" shorthand (e.g. [.foo])
+            // we have to create a separate hide tag and shorten the real one
+            if (token.size() > 1 && token[0] == '.') {
+                token.erase(token.begin());
+                if (m_exclusion) {
+                    m_currentFilter.m_forbidden.emplace_back(Detail::make_unique<TestSpec::TagPattern>(".", m_substring));
+                } else {
+                    m_currentFilter.m_required.emplace_back(Detail::make_unique<TestSpec::TagPattern>(".", m_substring));
+                }
+            }
+            if (m_exclusion) {
+                m_currentFilter.m_forbidden.emplace_back(Detail::make_unique<TestSpec::TagPattern>(token, m_substring));
+            } else {
+                m_currentFilter.m_required.emplace_back(Detail::make_unique<TestSpec::TagPattern>(token, m_substring));
+            }
+        }
+        m_substring.clear();
+        m_exclusion = false;
+        m_mode = None;
+    }
+
+} // namespace Catch
+
+
+
+#include <algorithm>
+#include <cstring>
+#include <ostream>
+
+namespace {
+    bool isWhitespace( char c ) {
+        return c == ' ' || c == '\t' || c == '\n' || c == '\r';
+    }
+
+    bool isBreakableBefore( char c ) {
+        static const char chars[] = "[({<|";
+        return std::memchr( chars, c, sizeof( chars ) - 1 ) != nullptr;
+    }
+
+    bool isBreakableAfter( char c ) {
+        static const char chars[] = "])}>.,:;*+-=&/\\";
+        return std::memchr( chars, c, sizeof( chars ) - 1 ) != nullptr;
+    }
+
+} // namespace
+
+namespace Catch {
+    namespace TextFlow {
+        void AnsiSkippingString::preprocessString() {
+            for ( auto it = m_string.begin(); it != m_string.end(); ) {
+                // try to read through an ansi sequence
+                while ( it != m_string.end() && *it == '\033' &&
+                        it + 1 != m_string.end() && *( it + 1 ) == '[' ) {
+                    auto cursor = it + 2;
+                    while ( cursor != m_string.end() &&
+                            ( isdigit( *cursor ) || *cursor == ';' ) ) {
+                        ++cursor;
+                    }
+                    if ( cursor == m_string.end() || *cursor != 'm' ) {
+                        break;
+                    }
+                    // 'm' -> 0xff
+                    *cursor = AnsiSkippingString::sentinel;
+                    // if we've read an ansi sequence, set the iterator and
+                    // return to the top of the loop
+                    it = cursor + 1;
+                }
+                if ( it != m_string.end() ) {
+                    ++m_size;
+                    ++it;
+                }
+            }
+        }
+
+        AnsiSkippingString::AnsiSkippingString( std::string const& text ):
+            m_string( text ) {
+            preprocessString();
+        }
+
+        AnsiSkippingString::AnsiSkippingString( std::string&& text ):
+            m_string( CATCH_MOVE( text ) ) {
+            preprocessString();
+        }
+
+        AnsiSkippingString::const_iterator AnsiSkippingString::begin() const {
+            return const_iterator( m_string );
+        }
+
+        AnsiSkippingString::const_iterator AnsiSkippingString::end() const {
+            return const_iterator( m_string, const_iterator::EndTag{} );
+        }
+
+        std::string AnsiSkippingString::substring( const_iterator begin,
+                                                   const_iterator end ) const {
+            // There's one caveat here to an otherwise simple substring: when
+            // making a begin iterator we might have skipped ansi sequences at
+            // the start. If `begin` here is a begin iterator, skipped over
+            // initial ansi sequences, we'll use the true beginning of the
+            // string. Lastly: We need to transform any chars we replaced with
+            // 0xff back to 'm'
+            auto str = std::string( begin == this->begin() ? m_string.begin()
+                                                           : begin.m_it,
+                                    end.m_it );
+            std::transform( str.begin(), str.end(), str.begin(), []( char c ) {
+                return c == AnsiSkippingString::sentinel ? 'm' : c;
+            } );
+            return str;
+        }
+
+        void AnsiSkippingString::const_iterator::tryParseAnsiEscapes() {
+            // check if we've landed on an ansi sequence, and if so read through
+            // it
+            while ( m_it != m_string->end() && *m_it == '\033' &&
+                    m_it + 1 != m_string->end() &&  *( m_it + 1 ) == '[' ) {
+                auto cursor = m_it + 2;
+                while ( cursor != m_string->end() &&
+                        ( isdigit( *cursor ) || *cursor == ';' ) ) {
+                    ++cursor;
+                }
+                if ( cursor == m_string->end() ||
+                     *cursor != AnsiSkippingString::sentinel ) {
+                    break;
+                }
+                // if we've read an ansi sequence, set the iterator and
+                // return to the top of the loop
+                m_it = cursor + 1;
+            }
+        }
+
+        void AnsiSkippingString::const_iterator::advance() {
+            assert( m_it != m_string->end() );
+            m_it++;
+            tryParseAnsiEscapes();
+        }
+
+        void AnsiSkippingString::const_iterator::unadvance() {
+            assert( m_it != m_string->begin() );
+            m_it--;
+            // if *m_it is 0xff, scan back to the \033 and then m_it-- once more
+            // (and repeat check)
+            while ( *m_it == AnsiSkippingString::sentinel ) {
+                while ( *m_it != '\033' ) {
+                    assert( m_it != m_string->begin() );
+                    m_it--;
+                }
+                // if this happens, we must have been a begin iterator that had
+                // skipped over ansi sequences at the start of a string
+                assert( m_it != m_string->begin() );
+                assert( *m_it == '\033' );
+                m_it--;
+            }
+        }
+
+        static bool isBoundary( AnsiSkippingString const& line,
+                                AnsiSkippingString::const_iterator it ) {
+            return it == line.end() ||
+                   ( isWhitespace( *it ) &&
+                     !isWhitespace( *it.oneBefore() ) ) ||
+                   isBreakableBefore( *it ) ||
+                   isBreakableAfter( *it.oneBefore() );
+        }
+
+        void Column::const_iterator::calcLength() {
+            m_addHyphen = false;
+            m_parsedTo = m_lineStart;
+            AnsiSkippingString const& current_line = m_column.m_string;
+
+            if ( m_parsedTo == current_line.end() ) {
+                m_lineEnd = m_parsedTo;
+                return;
+            }
+
+            assert( m_lineStart != current_line.end() );
+            if ( *m_lineStart == '\n' ) { ++m_parsedTo; }
+
+            const auto maxLineLength = m_column.m_width - indentSize();
+            std::size_t lineLength = 0;
+            while ( m_parsedTo != current_line.end() &&
+                    lineLength < maxLineLength && *m_parsedTo != '\n' ) {
+                ++m_parsedTo;
+                ++lineLength;
+            }
+
+            // If we encountered a newline before the column is filled,
+            // then we linebreak at the newline and consider this line
+            // finished.
+            if ( lineLength < maxLineLength ) {
+                m_lineEnd = m_parsedTo;
+            } else {
+                // Look for a natural linebreak boundary in the column
+                // (We look from the end, so that the first found boundary is
+                // the right one)
+                m_lineEnd = m_parsedTo;
+                while ( lineLength > 0 &&
+                        !isBoundary( current_line, m_lineEnd ) ) {
+                    --lineLength;
+                    --m_lineEnd;
+                }
+                while ( lineLength > 0 &&
+                        isWhitespace( *m_lineEnd.oneBefore() ) ) {
+                    --lineLength;
+                    --m_lineEnd;
+                }
+
+                // If we found one, then that is where we linebreak, otherwise
+                // we have to split text with a hyphen
+                if ( lineLength == 0 ) {
+                    m_addHyphen = true;
+                    m_lineEnd = m_parsedTo.oneBefore();
+                }
+            }
+        }
+
+        size_t Column::const_iterator::indentSize() const {
+            auto initial = m_lineStart == m_column.m_string.begin()
+                               ? m_column.m_initialIndent
+                               : std::string::npos;
+            return initial == std::string::npos ? m_column.m_indent : initial;
+        }
+
+        std::string Column::const_iterator::addIndentAndSuffix(
+            AnsiSkippingString::const_iterator start,
+            AnsiSkippingString::const_iterator end ) const {
+            std::string ret;
+            const auto desired_indent = indentSize();
+            // ret.reserve( desired_indent + (end - start) + m_addHyphen );
+            ret.append( desired_indent, ' ' );
+            // ret.append( start, end );
+            ret += m_column.m_string.substring( start, end );
+            if ( m_addHyphen ) { ret.push_back( '-' ); }
+
+            return ret;
+        }
+
+        Column::const_iterator::const_iterator( Column const& column ):
+            m_column( column ),
+            m_lineStart( column.m_string.begin() ),
+            m_lineEnd( column.m_string.begin() ),
+            m_parsedTo( column.m_string.begin() ) {
+            assert( m_column.m_width > m_column.m_indent );
+            assert( m_column.m_initialIndent == std::string::npos ||
+                    m_column.m_width > m_column.m_initialIndent );
+            calcLength();
+            if ( m_lineStart == m_lineEnd ) {
+                m_lineStart = m_column.m_string.end();
+            }
+        }
+
+        std::string Column::const_iterator::operator*() const {
+            assert( m_lineStart <= m_parsedTo );
+            return addIndentAndSuffix( m_lineStart, m_lineEnd );
+        }
+
+        Column::const_iterator& Column::const_iterator::operator++() {
+            m_lineStart = m_lineEnd;
+            AnsiSkippingString const& current_line = m_column.m_string;
+            if ( m_lineStart != current_line.end() && *m_lineStart == '\n' ) {
+                m_lineStart++;
+            } else {
+                while ( m_lineStart != current_line.end() &&
+                        isWhitespace( *m_lineStart ) ) {
+                    ++m_lineStart;
+                }
+            }
+
+            if ( m_lineStart != current_line.end() ) { calcLength(); }
+            return *this;
+        }
+
+        Column::const_iterator Column::const_iterator::operator++( int ) {
+            const_iterator prev( *this );
+            operator++();
+            return prev;
+        }
+
+        std::ostream& operator<<( std::ostream& os, Column const& col ) {
+            bool first = true;
+            for ( auto line : col ) {
+                if ( first ) {
+                    first = false;
+                } else {
+                    os << '\n';
+                }
+                os << line;
+            }
+            return os;
+        }
+
+        Column Spacer( size_t spaceWidth ) {
+            Column ret{ "" };
+            ret.width( spaceWidth );
+            return ret;
+        }
+
+        Columns::iterator::iterator( Columns const& columns, EndTag ):
+            m_columns( columns.m_columns ), m_activeIterators( 0 ) {
+
+            m_iterators.reserve( m_columns.size() );
+            for ( auto const& col : m_columns ) {
+                m_iterators.push_back( col.end() );
+            }
+        }
+
+        Columns::iterator::iterator( Columns const& columns ):
+            m_columns( columns.m_columns ),
+            m_activeIterators( m_columns.size() ) {
+
+            m_iterators.reserve( m_columns.size() );
+            for ( auto const& col : m_columns ) {
+                m_iterators.push_back( col.begin() );
+            }
+        }
+
+        std::string Columns::iterator::operator*() const {
+            std::string row, padding;
+
+            for ( size_t i = 0; i < m_columns.size(); ++i ) {
+                const auto width = m_columns[i].width();
+                if ( m_iterators[i] != m_columns[i].end() ) {
+                    std::string col = *m_iterators[i];
+                    row += padding;
+                    row += col;
+
+                    padding.clear();
+                    if ( col.size() < width ) {
+                        padding.append( width - col.size(), ' ' );
+                    }
+                } else {
+                    padding.append( width, ' ' );
+                }
+            }
+            return row;
+        }
+
+        Columns::iterator& Columns::iterator::operator++() {
+            for ( size_t i = 0; i < m_columns.size(); ++i ) {
+                if ( m_iterators[i] != m_columns[i].end() ) {
+                    ++m_iterators[i];
+                }
+            }
+            return *this;
+        }
+
+        Columns::iterator Columns::iterator::operator++( int ) {
+            iterator prev( *this );
+            operator++();
+            return prev;
+        }
+
+        std::ostream& operator<<( std::ostream& os, Columns const& cols ) {
+            bool first = true;
+            for ( auto line : cols ) {
+                if ( first ) {
+                    first = false;
+                } else {
+                    os << '\n';
+                }
+                os << line;
+            }
+            return os;
+        }
+
+        Columns operator+( Column const& lhs, Column const& rhs ) {
+            Columns cols;
+            cols += lhs;
+            cols += rhs;
+            return cols;
+        }
+        Columns operator+( Column&& lhs, Column&& rhs ) {
+            Columns cols;
+            cols += CATCH_MOVE( lhs );
+            cols += CATCH_MOVE( rhs );
+            return cols;
+        }
+
+        Columns& operator+=( Columns& lhs, Column const& rhs ) {
+            lhs.m_columns.push_back( rhs );
+            return lhs;
+        }
+        Columns& operator+=( Columns& lhs, Column&& rhs ) {
+            lhs.m_columns.push_back( CATCH_MOVE( rhs ) );
+            return lhs;
+        }
+        Columns operator+( Columns const& lhs, Column const& rhs ) {
+            auto combined( lhs );
+            combined += rhs;
+            return combined;
+        }
+        Columns operator+( Columns&& lhs, Column&& rhs ) {
+            lhs += CATCH_MOVE( rhs );
+            return CATCH_MOVE( lhs );
+        }
+
+    } // namespace TextFlow
+} // namespace Catch
+
+
+
+
+#include <exception>
+
+namespace Catch {
+    bool uncaught_exceptions() {
+#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+        return false;
+#elif defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
+        return std::uncaught_exceptions() > 0;
+#else
+        return std::uncaught_exception();
+#endif
+  }
+} // end namespace Catch
+
+
+
+namespace Catch {
+
+    WildcardPattern::WildcardPattern( std::string const& pattern,
+                                      CaseSensitive caseSensitivity )
+    :   m_caseSensitivity( caseSensitivity ),
+        m_pattern( normaliseString( pattern ) )
+    {
+        if( startsWith( m_pattern, '*' ) ) {
+            m_pattern = m_pattern.substr( 1 );
+            m_wildcard = WildcardAtStart;
+        }
+        if( endsWith( m_pattern, '*' ) ) {
+            m_pattern = m_pattern.substr( 0, m_pattern.size()-1 );
+            m_wildcard = static_cast<WildcardPosition>( m_wildcard | WildcardAtEnd );
+        }
+    }
+
+    bool WildcardPattern::matches( std::string const& str ) const {
+        switch( m_wildcard ) {
+            case NoWildcard:
+                return m_pattern == normaliseString( str );
+            case WildcardAtStart:
+                return endsWith( normaliseString( str ), m_pattern );
+            case WildcardAtEnd:
+                return startsWith( normaliseString( str ), m_pattern );
+            case WildcardAtBothEnds:
+                return contains( normaliseString( str ), m_pattern );
+            default:
+                CATCH_INTERNAL_ERROR( "Unknown enum" );
+        }
+    }
+
+    std::string WildcardPattern::normaliseString( std::string const& str ) const {
+        return trim( m_caseSensitivity == CaseSensitive::No ? toLower( str ) : str );
+    }
+}
+
+
+// Note: swapping these two includes around causes MSVC to error out
+//       while in /permissive- mode. No, I don't know why.
+//       Tested on VS 2019, 18.{3, 4}.x
+
+#include <cstdint>
+#include <iomanip>
+#include <type_traits>
+
+namespace Catch {
+
+namespace {
+
+    size_t trailingBytes(unsigned char c) {
+        if ((c & 0xE0) == 0xC0) {
+            return 2;
+        }
+        if ((c & 0xF0) == 0xE0) {
+            return 3;
+        }
+        if ((c & 0xF8) == 0xF0) {
+            return 4;
+        }
+        CATCH_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
+    }
+
+    uint32_t headerValue(unsigned char c) {
+        if ((c & 0xE0) == 0xC0) {
+            return c & 0x1F;
+        }
+        if ((c & 0xF0) == 0xE0) {
+            return c & 0x0F;
+        }
+        if ((c & 0xF8) == 0xF0) {
+            return c & 0x07;
+        }
+        CATCH_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
+    }
+
+    void hexEscapeChar(std::ostream& os, unsigned char c) {
+        std::ios_base::fmtflags f(os.flags());
+        os << "\\x"
+            << std::uppercase << std::hex << std::setfill('0') << std::setw(2)
+            << static_cast<int>(c);
+        os.flags(f);
+    }
+
+    constexpr bool shouldNewline(XmlFormatting fmt) {
+        return !!(static_cast<std::underlying_type_t<XmlFormatting>>(fmt & XmlFormatting::Newline));
+    }
+
+    constexpr bool shouldIndent(XmlFormatting fmt) {
+        return !!(static_cast<std::underlying_type_t<XmlFormatting>>(fmt & XmlFormatting::Indent));
+    }
+
+} // anonymous namespace
+
+    void XmlEncode::encodeTo( std::ostream& os ) const {
+        // Apostrophe escaping not necessary if we always use " to write attributes
+        // (see: http://www.w3.org/TR/xml/#syntax)
+
+        for( std::size_t idx = 0; idx < m_str.size(); ++ idx ) {
+            unsigned char c = static_cast<unsigned char>(m_str[idx]);
+            switch (c) {
+            case '<':   os << "&lt;"; break;
+            case '&':   os << "&amp;"; break;
+
+            case '>':
+                // See: http://www.w3.org/TR/xml/#syntax
+                if (idx > 2 && m_str[idx - 1] == ']' && m_str[idx - 2] == ']')
+                    os << "&gt;";
+                else
+                    os << c;
+                break;
+
+            case '\"':
+                if (m_forWhat == ForAttributes)
+                    os << "&quot;";
+                else
+                    os << c;
+                break;
+
+            default:
+                // Check for control characters and invalid utf-8
+
+                // Escape control characters in standard ascii
+                // see http://stackoverflow.com/questions/404107/why-are-control-characters-illegal-in-xml-1-0
+                if (c < 0x09 || (c > 0x0D && c < 0x20) || c == 0x7F) {
+                    hexEscapeChar(os, c);
+                    break;
+                }
+
+                // Plain ASCII: Write it to stream
+                if (c < 0x7F) {
+                    os << c;
+                    break;
+                }
+
+                // UTF-8 territory
+                // Check if the encoding is valid and if it is not, hex escape bytes.
+                // Important: We do not check the exact decoded values for validity, only the encoding format
+                // First check that this bytes is a valid lead byte:
+                // This means that it is not encoded as 1111 1XXX
+                // Or as 10XX XXXX
+                if (c <  0xC0 ||
+                    c >= 0xF8) {
+                    hexEscapeChar(os, c);
+                    break;
+                }
+
+                auto encBytes = trailingBytes(c);
+                // Are there enough bytes left to avoid accessing out-of-bounds memory?
+                if (idx + encBytes - 1 >= m_str.size()) {
+                    hexEscapeChar(os, c);
+                    break;
+                }
+                // The header is valid, check data
+                // The next encBytes bytes must together be a valid utf-8
+                // This means: bitpattern 10XX XXXX and the extracted value is sane (ish)
+                bool valid = true;
+                uint32_t value = headerValue(c);
+                for (std::size_t n = 1; n < encBytes; ++n) {
+                    unsigned char nc = static_cast<unsigned char>(m_str[idx + n]);
+                    valid &= ((nc & 0xC0) == 0x80);
+                    value = (value << 6) | (nc & 0x3F);
+                }
+
+                if (
+                    // Wrong bit pattern of following bytes
+                    (!valid) ||
+                    // Overlong encodings
+                    (value < 0x80) ||
+                    (0x80 <= value && value < 0x800   && encBytes > 2) ||
+                    (0x800 < value && value < 0x10000 && encBytes > 3) ||
+                    // Encoded value out of range
+                    (value >= 0x110000)
+                    ) {
+                    hexEscapeChar(os, c);
+                    break;
+                }
+
+                // If we got here, this is in fact a valid(ish) utf-8 sequence
+                for (std::size_t n = 0; n < encBytes; ++n) {
+                    os << m_str[idx + n];
+                }
+                idx += encBytes - 1;
+                break;
+            }
+        }
+    }
+
+    std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode ) {
+        xmlEncode.encodeTo( os );
+        return os;
+    }
+
+    XmlWriter::ScopedElement::ScopedElement( XmlWriter* writer, XmlFormatting fmt )
+    :   m_writer( writer ),
+        m_fmt(fmt)
+    {}
+
+    XmlWriter::ScopedElement::ScopedElement( ScopedElement&& other ) noexcept
+    :   m_writer( other.m_writer ),
+        m_fmt(other.m_fmt)
+    {
+        other.m_writer = nullptr;
+        other.m_fmt = XmlFormatting::None;
+    }
+    XmlWriter::ScopedElement& XmlWriter::ScopedElement::operator=( ScopedElement&& other ) noexcept {
+        if ( m_writer ) {
+            m_writer->endElement();
+        }
+        m_writer = other.m_writer;
+        other.m_writer = nullptr;
+        m_fmt = other.m_fmt;
+        other.m_fmt = XmlFormatting::None;
+        return *this;
+    }
+
+
+    XmlWriter::ScopedElement::~ScopedElement() {
+        if (m_writer) {
+            m_writer->endElement(m_fmt);
+        }
+    }
+
+    XmlWriter::ScopedElement&
+    XmlWriter::ScopedElement::writeText( StringRef text, XmlFormatting fmt ) {
+        m_writer->writeText( text, fmt );
+        return *this;
+    }
+
+    XmlWriter::ScopedElement&
+    XmlWriter::ScopedElement::writeAttribute( StringRef name,
+                                              StringRef attribute ) {
+        m_writer->writeAttribute( name, attribute );
+        return *this;
+    }
+
+
+    XmlWriter::XmlWriter( std::ostream& os ) : m_os( os )
+    {
+        writeDeclaration();
+    }
+
+    XmlWriter::~XmlWriter() {
+        while (!m_tags.empty()) {
+            endElement();
+        }
+        newlineIfNecessary();
+    }
+
+    XmlWriter& XmlWriter::startElement( std::string const& name, XmlFormatting fmt ) {
+        ensureTagClosed();
+        newlineIfNecessary();
+        if (shouldIndent(fmt)) {
+            m_os << m_indent;
+            m_indent += "  ";
+        }
+        m_os << '<' << name;
+        m_tags.push_back( name );
+        m_tagIsOpen = true;
+        applyFormatting(fmt);
+        return *this;
+    }
+
+    XmlWriter::ScopedElement XmlWriter::scopedElement( std::string const& name, XmlFormatting fmt ) {
+        ScopedElement scoped( this, fmt );
+        startElement( name, fmt );
+        return scoped;
+    }
+
+    XmlWriter& XmlWriter::endElement(XmlFormatting fmt) {
+        m_indent = m_indent.substr(0, m_indent.size() - 2);
+
+        if( m_tagIsOpen ) {
+            m_os << "/>";
+            m_tagIsOpen = false;
+        } else {
+            newlineIfNecessary();
+            if (shouldIndent(fmt)) {
+                m_os << m_indent;
+            }
+            m_os << "</" << m_tags.back() << '>';
+        }
+        m_os << std::flush;
+        applyFormatting(fmt);
+        m_tags.pop_back();
+        return *this;
+    }
+
+    XmlWriter& XmlWriter::writeAttribute( StringRef name,
+                                          StringRef attribute ) {
+        if( !name.empty() && !attribute.empty() )
+            m_os << ' ' << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << '"';
+        return *this;
+    }
+
+    XmlWriter& XmlWriter::writeAttribute( StringRef name, bool attribute ) {
+        writeAttribute(name, (attribute ? "true"_sr : "false"_sr));
+        return *this;
+    }
+
+    XmlWriter& XmlWriter::writeAttribute( StringRef name,
+                                          char const* attribute ) {
+        writeAttribute( name, StringRef( attribute ) );
+        return *this;
+    }
+
+    XmlWriter& XmlWriter::writeText( StringRef text, XmlFormatting fmt ) {
+        CATCH_ENFORCE(!m_tags.empty(), "Cannot write text as top level element");
+        if( !text.empty() ){
+            bool tagWasOpen = m_tagIsOpen;
+            ensureTagClosed();
+            if (tagWasOpen && shouldIndent(fmt)) {
+                m_os << m_indent;
+            }
+            m_os << XmlEncode( text, XmlEncode::ForTextNodes );
+            applyFormatting(fmt);
+        }
+        return *this;
+    }
+
+    XmlWriter& XmlWriter::writeComment( StringRef text, XmlFormatting fmt ) {
+        ensureTagClosed();
+        if (shouldIndent(fmt)) {
+            m_os << m_indent;
+        }
+        m_os << "<!-- " << text << " -->";
+        applyFormatting(fmt);
+        return *this;
+    }
+
+    void XmlWriter::writeStylesheetRef( StringRef url ) {
+        m_os << R"(<?xml-stylesheet type="text/xsl" href=")" << url << R"("?>)" << '\n';
+    }
+
+    void XmlWriter::ensureTagClosed() {
+        if( m_tagIsOpen ) {
+            m_os << '>' << std::flush;
+            newlineIfNecessary();
+            m_tagIsOpen = false;
+        }
+    }
+
+    void XmlWriter::applyFormatting(XmlFormatting fmt) {
+        m_needsNewline = shouldNewline(fmt);
+    }
+
+    void XmlWriter::writeDeclaration() {
+        m_os << R"(<?xml version="1.0" encoding="UTF-8"?>)" << '\n';
+    }
+
+    void XmlWriter::newlineIfNecessary() {
+        if( m_needsNewline ) {
+            m_os << '\n' << std::flush;
+            m_needsNewline = false;
+        }
+    }
+}
+
+
+
+
+
+namespace Catch {
+namespace Matchers {
+
+    std::string MatcherUntypedBase::toString() const {
+        if (m_cachedToString.empty()) {
+            m_cachedToString = describe();
+        }
+        return m_cachedToString;
+    }
+
+    MatcherUntypedBase::~MatcherUntypedBase() = default;
+
+} // namespace Matchers
+} // namespace Catch
+
+
+
+
+namespace Catch {
+namespace Matchers {
+
+    std::string IsEmptyMatcher::describe() const {
+        return "is empty";
+    }
+
+    std::string HasSizeMatcher::describe() const {
+        ReusableStringStream sstr;
+        sstr << "has size == " << m_target_size;
+        return sstr.str();
+    }
+
+    IsEmptyMatcher IsEmpty() {
+        return {};
+    }
+
+    HasSizeMatcher SizeIs(std::size_t sz) {
+        return HasSizeMatcher{ sz };
+    }
+
+} // end namespace Matchers
+} // end namespace Catch
+
+
+
+namespace Catch {
+namespace Matchers {
+
+bool ExceptionMessageMatcher::match(std::exception const& ex) const {
+    return ex.what() == m_message;
+}
+
+std::string ExceptionMessageMatcher::describe() const {
+    return "exception message matches \"" + m_message + '"';
+}
+
+ExceptionMessageMatcher Message(std::string const& message) {
+    return ExceptionMessageMatcher(message);
+}
+
+} // namespace Matchers
+} // namespace Catch
+
+
+
+#include <algorithm>
+#include <cmath>
+#include <cstdlib>
+#include <cstdint>
+#include <sstream>
+#include <iomanip>
+#include <limits>
+
+
+namespace Catch {
+namespace {
+
+    template <typename FP>
+    bool almostEqualUlps(FP lhs, FP rhs, uint64_t maxUlpDiff) {
+        // Comparison with NaN should always be false.
+        // This way we can rule it out before getting into the ugly details
+        if (Catch::isnan(lhs) || Catch::isnan(rhs)) {
+            return false;
+        }
+
+        // This should also handle positive and negative zeros, infinities
+        const auto ulpDist = ulpDistance(lhs, rhs);
+
+        return ulpDist <= maxUlpDiff;
+    }
+
+
+template <typename FP>
+FP step(FP start, FP direction, uint64_t steps) {
+    for (uint64_t i = 0; i < steps; ++i) {
+        start = Catch::nextafter(start, direction);
+    }
+    return start;
+}
+
+// Performs equivalent check of std::fabs(lhs - rhs) <= margin
+// But without the subtraction to allow for INFINITY in comparison
+bool marginComparison(double lhs, double rhs, double margin) {
+    return (lhs + margin >= rhs) && (rhs + margin >= lhs);
+}
+
+template <typename FloatingPoint>
+void write(std::ostream& out, FloatingPoint num) {
+    out << std::scientific
+        << std::setprecision(std::numeric_limits<FloatingPoint>::max_digits10 - 1)
+        << num;
+}
+
+} // end anonymous namespace
+
+namespace Matchers {
+namespace Detail {
+
+    enum class FloatingPointKind : uint8_t {
+        Float,
+        Double
+    };
+
+} // end namespace Detail
+
+
+    WithinAbsMatcher::WithinAbsMatcher(double target, double margin)
+        :m_target{ target }, m_margin{ margin } {
+        CATCH_ENFORCE(margin >= 0, "Invalid margin: " << margin << '.'
+            << " Margin has to be non-negative.");
+    }
+
+    // Performs equivalent check of std::fabs(lhs - rhs) <= margin
+    // But without the subtraction to allow for INFINITY in comparison
+    bool WithinAbsMatcher::match(double const& matchee) const {
+        return (matchee + m_margin >= m_target) && (m_target + m_margin >= matchee);
+    }
+
+    std::string WithinAbsMatcher::describe() const {
+        return "is within " + ::Catch::Detail::stringify(m_margin) + " of " + ::Catch::Detail::stringify(m_target);
+    }
+
+
+    WithinUlpsMatcher::WithinUlpsMatcher(double target, uint64_t ulps, Detail::FloatingPointKind baseType)
+        :m_target{ target }, m_ulps{ ulps }, m_type{ baseType } {
+        CATCH_ENFORCE(m_type == Detail::FloatingPointKind::Double
+                   || m_ulps < (std::numeric_limits<uint32_t>::max)(),
+            "Provided ULP is impossibly large for a float comparison.");
+        CATCH_ENFORCE( std::numeric_limits<double>::is_iec559,
+                       "WithinUlp matcher only supports platforms with "
+                       "IEEE-754 compatible floating point representation" );
+    }
+
+#if defined(__clang__)
+#pragma clang diagnostic push
+// Clang <3.5 reports on the default branch in the switch below
+#pragma clang diagnostic ignored "-Wunreachable-code"
+#endif
+
+    bool WithinUlpsMatcher::match(double const& matchee) const {
+        switch (m_type) {
+        case Detail::FloatingPointKind::Float:
+            return almostEqualUlps<float>(static_cast<float>(matchee), static_cast<float>(m_target), m_ulps);
+        case Detail::FloatingPointKind::Double:
+            return almostEqualUlps<double>(matchee, m_target, m_ulps);
+        default:
+            CATCH_INTERNAL_ERROR( "Unknown Detail::FloatingPointKind value" );
+        }
+    }
+
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+
+    std::string WithinUlpsMatcher::describe() const {
+        std::stringstream ret;
+
+        ret << "is within " << m_ulps << " ULPs of ";
+
+        if (m_type == Detail::FloatingPointKind::Float) {
+            write(ret, static_cast<float>(m_target));
+            ret << 'f';
+        } else {
+            write(ret, m_target);
+        }
+
+        ret << " ([";
+        if (m_type == Detail::FloatingPointKind::Double) {
+            write( ret,
+                   step( m_target,
+                         -std::numeric_limits<double>::infinity(),
+                         m_ulps ) );
+            ret << ", ";
+            write( ret,
+                   step( m_target,
+                         std::numeric_limits<double>::infinity(),
+                         m_ulps ) );
+        } else {
+            // We have to cast INFINITY to float because of MinGW, see #1782
+            write( ret,
+                   step( static_cast<float>( m_target ),
+                         -std::numeric_limits<float>::infinity(),
+                         m_ulps ) );
+            ret << ", ";
+            write( ret,
+                   step( static_cast<float>( m_target ),
+                         std::numeric_limits<float>::infinity(),
+                         m_ulps ) );
+        }
+        ret << "])";
+
+        return ret.str();
+    }
+
+    WithinRelMatcher::WithinRelMatcher(double target, double epsilon):
+        m_target(target),
+        m_epsilon(epsilon){
+        CATCH_ENFORCE(m_epsilon >= 0., "Relative comparison with epsilon <  0 does not make sense.");
+        CATCH_ENFORCE(m_epsilon  < 1., "Relative comparison with epsilon >= 1 does not make sense.");
+    }
+
+    bool WithinRelMatcher::match(double const& matchee) const {
+        const auto relMargin = m_epsilon * (std::max)(std::fabs(matchee), std::fabs(m_target));
+        return marginComparison(matchee, m_target,
+                                std::isinf(relMargin)? 0 : relMargin);
+    }
+
+    std::string WithinRelMatcher::describe() const {
+        Catch::ReusableStringStream sstr;
+        sstr << "and " << ::Catch::Detail::stringify(m_target) << " are within " << m_epsilon * 100. << "% of each other";
+        return sstr.str();
+    }
+
+
+WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff) {
+    return WithinUlpsMatcher(target, maxUlpDiff, Detail::FloatingPointKind::Double);
+}
+
+WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff) {
+    return WithinUlpsMatcher(target, maxUlpDiff, Detail::FloatingPointKind::Float);
+}
+
+WithinAbsMatcher WithinAbs(double target, double margin) {
+    return WithinAbsMatcher(target, margin);
+}
+
+WithinRelMatcher WithinRel(double target, double eps) {
+    return WithinRelMatcher(target, eps);
+}
+
+WithinRelMatcher WithinRel(double target) {
+    return WithinRelMatcher(target, std::numeric_limits<double>::epsilon() * 100);
+}
+
+WithinRelMatcher WithinRel(float target, float eps) {
+    return WithinRelMatcher(target, eps);
+}
+
+WithinRelMatcher WithinRel(float target) {
+    return WithinRelMatcher(target, std::numeric_limits<float>::epsilon() * 100);
+}
+
+
+
+bool IsNaNMatcher::match( double const& matchee ) const {
+    return std::isnan( matchee );
+}
+
+std::string IsNaNMatcher::describe() const {
+    using namespace std::string_literals;
+    return "is NaN"s;
+}
+
+IsNaNMatcher IsNaN() { return IsNaNMatcher(); }
+
+    } // namespace Matchers
+} // namespace Catch
+
+
+
+
+std::string Catch::Matchers::Detail::finalizeDescription(const std::string& desc) {
+    if (desc.empty()) {
+        return "matches undescribed predicate";
+    } else {
+        return "matches predicate: \"" + desc + '"';
+    }
+}
+
+
+
+namespace Catch {
+    namespace Matchers {
+        std::string AllTrueMatcher::describe() const { return "contains only true"; }
+
+        AllTrueMatcher AllTrue() { return AllTrueMatcher{}; }
+
+        std::string NoneTrueMatcher::describe() const { return "contains no true"; }
+
+        NoneTrueMatcher NoneTrue() { return NoneTrueMatcher{}; }
+
+        std::string AnyTrueMatcher::describe() const { return "contains at least one true"; }
+
+        AnyTrueMatcher AnyTrue() { return AnyTrueMatcher{}; }
+    } // namespace Matchers
+} // namespace Catch
+
+
+
+#include <regex>
+
+namespace Catch {
+namespace Matchers {
+
+    CasedString::CasedString( std::string const& str, CaseSensitive caseSensitivity )
+    :   m_caseSensitivity( caseSensitivity ),
+        m_str( adjustString( str ) )
+    {}
+    std::string CasedString::adjustString( std::string const& str ) const {
+        return m_caseSensitivity == CaseSensitive::No
+               ? toLower( str )
+               : str;
+    }
+    StringRef CasedString::caseSensitivitySuffix() const {
+        return m_caseSensitivity == CaseSensitive::Yes
+                   ? StringRef()
+                   : " (case insensitive)"_sr;
+    }
+
+
+    StringMatcherBase::StringMatcherBase( StringRef operation, CasedString const& comparator )
+    : m_comparator( comparator ),
+      m_operation( operation ) {
+    }
+
+    std::string StringMatcherBase::describe() const {
+        std::string description;
+        description.reserve(5 + m_operation.size() + m_comparator.m_str.size() +
+                                    m_comparator.caseSensitivitySuffix().size());
+        description += m_operation;
+        description += ": \"";
+        description += m_comparator.m_str;
+        description += '"';
+        description += m_comparator.caseSensitivitySuffix();
+        return description;
+    }
+
+    StringEqualsMatcher::StringEqualsMatcher( CasedString const& comparator ) : StringMatcherBase( "equals"_sr, comparator ) {}
+
+    bool StringEqualsMatcher::match( std::string const& source ) const {
+        return m_comparator.adjustString( source ) == m_comparator.m_str;
+    }
+
+
+    StringContainsMatcher::StringContainsMatcher( CasedString const& comparator ) : StringMatcherBase( "contains"_sr, comparator ) {}
+
+    bool StringContainsMatcher::match( std::string const& source ) const {
+        return contains( m_comparator.adjustString( source ), m_comparator.m_str );
+    }
+
+
+    StartsWithMatcher::StartsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "starts with"_sr, comparator ) {}
+
+    bool StartsWithMatcher::match( std::string const& source ) const {
+        return startsWith( m_comparator.adjustString( source ), m_comparator.m_str );
+    }
+
+
+    EndsWithMatcher::EndsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "ends with"_sr, comparator ) {}
+
+    bool EndsWithMatcher::match( std::string const& source ) const {
+        return endsWith( m_comparator.adjustString( source ), m_comparator.m_str );
+    }
+
+
+
+    RegexMatcher::RegexMatcher(std::string regex, CaseSensitive caseSensitivity): m_regex(CATCH_MOVE(regex)), m_caseSensitivity(caseSensitivity) {}
+
+    bool RegexMatcher::match(std::string const& matchee) const {
+        auto flags = std::regex::ECMAScript; // ECMAScript is the default syntax option anyway
+        if (m_caseSensitivity == CaseSensitive::No) {
+            flags |= std::regex::icase;
+        }
+        auto reg = std::regex(m_regex, flags);
+        return std::regex_match(matchee, reg);
+    }
+
+    std::string RegexMatcher::describe() const {
+        return "matches " + ::Catch::Detail::stringify(m_regex) + ((m_caseSensitivity == CaseSensitive::Yes)? " case sensitively" : " case insensitively");
+    }
+
+
+    StringEqualsMatcher Equals( std::string const& str, CaseSensitive caseSensitivity ) {
+        return StringEqualsMatcher( CasedString( str, caseSensitivity) );
+    }
+    StringContainsMatcher ContainsSubstring( std::string const& str, CaseSensitive caseSensitivity ) {
+        return StringContainsMatcher( CasedString( str, caseSensitivity) );
+    }
+    EndsWithMatcher EndsWith( std::string const& str, CaseSensitive caseSensitivity ) {
+        return EndsWithMatcher( CasedString( str, caseSensitivity) );
+    }
+    StartsWithMatcher StartsWith( std::string const& str, CaseSensitive caseSensitivity ) {
+        return StartsWithMatcher( CasedString( str, caseSensitivity) );
+    }
+
+    RegexMatcher Matches(std::string const& regex, CaseSensitive caseSensitivity) {
+        return RegexMatcher(regex, caseSensitivity);
+    }
+
+} // namespace Matchers
+} // namespace Catch
+
+
+
+namespace Catch {
+namespace Matchers {
+    MatcherGenericBase::~MatcherGenericBase() = default;
+
+    namespace Detail {
+
+        std::string describe_multi_matcher(StringRef combine, std::string const* descriptions_begin, std::string const* descriptions_end) {
+            std::string description;
+            std::size_t combined_size = 4;
+            for ( auto desc = descriptions_begin; desc != descriptions_end; ++desc ) {
+                combined_size += desc->size();
+            }
+            combined_size += static_cast<size_t>(descriptions_end - descriptions_begin - 1) * combine.size();
+
+            description.reserve(combined_size);
+
+            description += "( ";
+            bool first = true;
+            for( auto desc = descriptions_begin; desc != descriptions_end; ++desc ) {
+                if( first )
+                    first = false;
+                else
+                    description += combine;
+                description += *desc;
+            }
+            description += " )";
+            return description;
+        }
+
+    } // namespace Detail
+} // namespace Matchers
+} // namespace Catch
+
+
+
+
+namespace Catch {
+
+    // This is the general overload that takes a any string matcher
+    // There is another overload, in catch_assertionhandler.h/.cpp, that only takes a string and infers
+    // the Equals matcher (so the header does not mention matchers)
+    void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher ) {
+        std::string exceptionMessage = Catch::translateActiveException();
+        MatchExpr<std::string, StringMatcher const&> expr( CATCH_MOVE(exceptionMessage), matcher );
+        handler.handleExpr( expr );
+    }
+
+} // namespace Catch
+
+
+
+#include <ostream>
+
+namespace Catch {
+
+    AutomakeReporter::~AutomakeReporter() = default;
+
+    void AutomakeReporter::testCaseEnded(TestCaseStats const& _testCaseStats) {
+        // Possible values to emit are PASS, XFAIL, SKIP, FAIL, XPASS and ERROR.
+        m_stream << ":test-result: ";
+        if ( _testCaseStats.totals.testCases.skipped > 0 ) {
+            m_stream << "SKIP";
+        } else if (_testCaseStats.totals.assertions.allPassed()) {
+            m_stream << "PASS";
+        } else if (_testCaseStats.totals.assertions.allOk()) {
+            m_stream << "XFAIL";
+        } else {
+            m_stream << "FAIL";
+        }
+        m_stream << ' ' << _testCaseStats.testInfo->name << '\n';
+        StreamingReporterBase::testCaseEnded(_testCaseStats);
+    }
+
+    void AutomakeReporter::skipTest(TestCaseInfo const& testInfo) {
+        m_stream << ":test-result: SKIP " << testInfo.name << '\n';
+    }
+
+} // end namespace Catch
+
+
+
+
+
+
+namespace Catch {
+    ReporterBase::ReporterBase( ReporterConfig&& config ):
+        IEventListener( config.fullConfig() ),
+        m_wrapped_stream( CATCH_MOVE(config).takeStream() ),
+        m_stream( m_wrapped_stream->stream() ),
+        m_colour( makeColourImpl( config.colourMode(), m_wrapped_stream.get() ) ),
+        m_customOptions( config.customOptions() )
+    {}
+
+    ReporterBase::~ReporterBase() = default;
+
+    void ReporterBase::listReporters(
+        std::vector<ReporterDescription> const& descriptions ) {
+        defaultListReporters(m_stream, descriptions, m_config->verbosity());
+    }
+
+    void ReporterBase::listListeners(
+        std::vector<ListenerDescription> const& descriptions ) {
+        defaultListListeners( m_stream, descriptions );
+    }
+
+    void ReporterBase::listTests(std::vector<TestCaseHandle> const& tests) {
+        defaultListTests(m_stream,
+                         m_colour.get(),
+                         tests,
+                         m_config->hasTestFilters(),
+                         m_config->verbosity());
+    }
+
+    void ReporterBase::listTags(std::vector<TagInfo> const& tags) {
+        defaultListTags( m_stream, tags, m_config->hasTestFilters() );
+    }
+
+} // namespace Catch
+
+
+
+
+#include <ostream>
+
+namespace Catch {
+namespace {
+
+    // Colour::LightGrey
+    static constexpr Colour::Code compactDimColour = Colour::FileName;
+
+#ifdef CATCH_PLATFORM_MAC
+    static constexpr Catch::StringRef compactFailedString = "FAILED"_sr;
+    static constexpr Catch::StringRef compactPassedString = "PASSED"_sr;
+#else
+    static constexpr Catch::StringRef compactFailedString = "failed"_sr;
+    static constexpr Catch::StringRef compactPassedString = "passed"_sr;
+#endif
+
+// Implementation of CompactReporter formatting
+class AssertionPrinter {
+public:
+    AssertionPrinter& operator= (AssertionPrinter const&) = delete;
+    AssertionPrinter(AssertionPrinter const&) = delete;
+    AssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages, ColourImpl* colourImpl_)
+        : stream(_stream)
+        , result(_stats.assertionResult)
+        , messages(_stats.infoMessages)
+        , itMessage(_stats.infoMessages.begin())
+        , printInfoMessages(_printInfoMessages)
+        , colourImpl(colourImpl_)
+    {}
+
+    void print() {
+        printSourceInfo();
+
+        itMessage = messages.begin();
+
+        switch (result.getResultType()) {
+        case ResultWas::Ok:
+            printResultType(Colour::ResultSuccess, compactPassedString);
+            printOriginalExpression();
+            printReconstructedExpression();
+            if (!result.hasExpression())
+                printRemainingMessages(Colour::None);
+            else
+                printRemainingMessages();
+            break;
+        case ResultWas::ExpressionFailed:
+            if (result.isOk())
+                printResultType(Colour::ResultSuccess, compactFailedString + " - but was ok"_sr);
+            else
+                printResultType(Colour::Error, compactFailedString);
+            printOriginalExpression();
+            printReconstructedExpression();
+            printRemainingMessages();
+            break;
+        case ResultWas::ThrewException:
+            printResultType(Colour::Error, compactFailedString);
+            printIssue("unexpected exception with message:");
+            printMessage();
+            printExpressionWas();
+            printRemainingMessages();
+            break;
+        case ResultWas::FatalErrorCondition:
+            printResultType(Colour::Error, compactFailedString);
+            printIssue("fatal error condition with message:");
+            printMessage();
+            printExpressionWas();
+            printRemainingMessages();
+            break;
+        case ResultWas::DidntThrowException:
+            printResultType(Colour::Error, compactFailedString);
+            printIssue("expected exception, got none");
+            printExpressionWas();
+            printRemainingMessages();
+            break;
+        case ResultWas::Info:
+            printResultType(Colour::None, "info"_sr);
+            printMessage();
+            printRemainingMessages();
+            break;
+        case ResultWas::Warning:
+            printResultType(Colour::None, "warning"_sr);
+            printMessage();
+            printRemainingMessages();
+            break;
+        case ResultWas::ExplicitFailure:
+            printResultType(Colour::Error, compactFailedString);
+            printIssue("explicitly");
+            printRemainingMessages(Colour::None);
+            break;
+        case ResultWas::ExplicitSkip:
+            printResultType(Colour::Skip, "skipped"_sr);
+            printMessage();
+            printRemainingMessages();
+            break;
+            // These cases are here to prevent compiler warnings
+        case ResultWas::Unknown:
+        case ResultWas::FailureBit:
+        case ResultWas::Exception:
+            printResultType(Colour::Error, "** internal error **");
+            break;
+        }
+    }
+
+private:
+    void printSourceInfo() const {
+        stream << colourImpl->guardColour( Colour::FileName )
+               << result.getSourceInfo() << ':';
+    }
+
+    void printResultType(Colour::Code colour, StringRef passOrFail) const {
+        if (!passOrFail.empty()) {
+            stream << colourImpl->guardColour(colour) << ' ' << passOrFail;
+            stream << ':';
+        }
+    }
+
+    void printIssue(char const* issue) const {
+        stream << ' ' << issue;
+    }
+
+    void printExpressionWas() {
+        if (result.hasExpression()) {
+            stream << ';';
+            {
+                stream << colourImpl->guardColour(compactDimColour) << " expression was:";
+            }
+            printOriginalExpression();
+        }
+    }
+
+    void printOriginalExpression() const {
+        if (result.hasExpression()) {
+            stream << ' ' << result.getExpression();
+        }
+    }
+
+    void printReconstructedExpression() const {
+        if (result.hasExpandedExpression()) {
+            stream << colourImpl->guardColour(compactDimColour) << " for: ";
+            stream << result.getExpandedExpression();
+        }
+    }
+
+    void printMessage() {
+        if (itMessage != messages.end()) {
+            stream << " '" << itMessage->message << '\'';
+            ++itMessage;
+        }
+    }
+
+    void printRemainingMessages(Colour::Code colour = compactDimColour) {
+        if (itMessage == messages.end())
+            return;
+
+        const auto itEnd = messages.cend();
+        const auto N = static_cast<std::size_t>(itEnd - itMessage);
+
+        stream << colourImpl->guardColour( colour ) << " with "
+               << pluralise( N, "message"_sr ) << ':';
+
+        while (itMessage != itEnd) {
+            // If this assertion is a warning ignore any INFO messages
+            if (printInfoMessages || itMessage->type != ResultWas::Info) {
+                printMessage();
+                if (itMessage != itEnd) {
+                    stream << colourImpl->guardColour(compactDimColour) << " and";
+                }
+                continue;
+            }
+            ++itMessage;
+        }
+    }
+
+private:
+    std::ostream& stream;
+    AssertionResult const& result;
+    std::vector<MessageInfo> const& messages;
+    std::vector<MessageInfo>::const_iterator itMessage;
+    bool printInfoMessages;
+    ColourImpl* colourImpl;
+};
+
+} // anon namespace
+
+        std::string CompactReporter::getDescription() {
+            return "Reports test results on a single line, suitable for IDEs";
+        }
+
+        void CompactReporter::noMatchingTestCases( StringRef unmatchedSpec ) {
+            m_stream << "No test cases matched '" << unmatchedSpec << "'\n";
+        }
+
+        void CompactReporter::testRunStarting( TestRunInfo const& ) {
+            if ( m_config->testSpec().hasFilters() ) {
+                m_stream << m_colour->guardColour( Colour::BrightYellow )
+                         << "Filters: "
+                         << m_config->testSpec()
+                         << '\n';
+            }
+            m_stream << "RNG seed: " << getSeed() << '\n';
+        }
+
+        void CompactReporter::assertionEnded( AssertionStats const& _assertionStats ) {
+            AssertionResult const& result = _assertionStats.assertionResult;
+
+            bool printInfoMessages = true;
+
+            // Drop out if result was successful and we're not printing those
+            if( !m_config->includeSuccessfulResults() && result.isOk() ) {
+                if( result.getResultType() != ResultWas::Warning && result.getResultType() != ResultWas::ExplicitSkip )
+                    return;
+                printInfoMessages = false;
+            }
+
+            AssertionPrinter printer( m_stream, _assertionStats, printInfoMessages, m_colour.get() );
+            printer.print();
+
+            m_stream << '\n' << std::flush;
+        }
+
+        void CompactReporter::sectionEnded(SectionStats const& _sectionStats) {
+            double dur = _sectionStats.durationInSeconds;
+            if ( shouldShowDuration( *m_config, dur ) ) {
+                m_stream << getFormattedDuration( dur ) << " s: " << _sectionStats.sectionInfo.name << '\n' << std::flush;
+            }
+        }
+
+        void CompactReporter::testRunEnded( TestRunStats const& _testRunStats ) {
+            printTestRunTotals( m_stream, *m_colour, _testRunStats.totals );
+            m_stream << "\n\n" << std::flush;
+            StreamingReporterBase::testRunEnded( _testRunStats );
+        }
+
+        CompactReporter::~CompactReporter() = default;
+
+} // end namespace Catch
+
+
+
+
+#include <cstdio>
+
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
+ // Note that 4062 (not all labels are handled and default is missing) is enabled
+#endif
+
+#if defined(__clang__)
+#  pragma clang diagnostic push
+// For simplicity, benchmarking-only helpers are always enabled
+#  pragma clang diagnostic ignored "-Wunused-function"
+#endif
+
+
+
+namespace Catch {
+
+namespace {
+
+// Formatter impl for ConsoleReporter
+class ConsoleAssertionPrinter {
+public:
+    ConsoleAssertionPrinter& operator= (ConsoleAssertionPrinter const&) = delete;
+    ConsoleAssertionPrinter(ConsoleAssertionPrinter const&) = delete;
+    ConsoleAssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, ColourImpl* colourImpl_, bool _printInfoMessages)
+        : stream(_stream),
+        stats(_stats),
+        result(_stats.assertionResult),
+        colour(Colour::None),
+        messages(_stats.infoMessages),
+        colourImpl(colourImpl_),
+        printInfoMessages(_printInfoMessages) {
+        switch (result.getResultType()) {
+        case ResultWas::Ok:
+            colour = Colour::Success;
+            passOrFail = "PASSED"_sr;
+            //if( result.hasMessage() )
+            if (messages.size() == 1)
+                messageLabel = "with message"_sr;
+            if (messages.size() > 1)
+                messageLabel = "with messages"_sr;
+            break;
+        case ResultWas::ExpressionFailed:
+            if (result.isOk()) {
+                colour = Colour::Success;
+                passOrFail = "FAILED - but was ok"_sr;
+            } else {
+                colour = Colour::Error;
+                passOrFail = "FAILED"_sr;
+            }
+            if (messages.size() == 1)
+                messageLabel = "with message"_sr;
+            if (messages.size() > 1)
+                messageLabel = "with messages"_sr;
+            break;
+        case ResultWas::ThrewException:
+            colour = Colour::Error;
+            passOrFail = "FAILED"_sr;
+            // todo switch
+            switch (messages.size()) { case 0:
+                messageLabel = "due to unexpected exception with "_sr;
+                break;
+            case 1:
+                messageLabel = "due to unexpected exception with message"_sr;
+                break;
+            default:
+                messageLabel = "due to unexpected exception with messages"_sr;
+                break;
+            }
+            break;
+        case ResultWas::FatalErrorCondition:
+            colour = Colour::Error;
+            passOrFail = "FAILED"_sr;
+            messageLabel = "due to a fatal error condition"_sr;
+            break;
+        case ResultWas::DidntThrowException:
+            colour = Colour::Error;
+            passOrFail = "FAILED"_sr;
+            messageLabel = "because no exception was thrown where one was expected"_sr;
+            break;
+        case ResultWas::Info:
+            messageLabel = "info"_sr;
+            break;
+        case ResultWas::Warning:
+            messageLabel = "warning"_sr;
+            break;
+        case ResultWas::ExplicitFailure:
+            passOrFail = "FAILED"_sr;
+            colour = Colour::Error;
+            if (messages.size() == 1)
+                messageLabel = "explicitly with message"_sr;
+            if (messages.size() > 1)
+                messageLabel = "explicitly with messages"_sr;
+            break;
+        case ResultWas::ExplicitSkip:
+            colour = Colour::Skip;
+            passOrFail = "SKIPPED"_sr;
+            if (messages.size() == 1)
+                messageLabel = "explicitly with message"_sr;
+            if (messages.size() > 1)
+                messageLabel = "explicitly with messages"_sr;
+            break;
+            // These cases are here to prevent compiler warnings
+        case ResultWas::Unknown:
+        case ResultWas::FailureBit:
+        case ResultWas::Exception:
+            passOrFail = "** internal error **"_sr;
+            colour = Colour::Error;
+            break;
+        }
+    }
+
+    void print() const {
+        printSourceInfo();
+        if (stats.totals.assertions.total() > 0) {
+            printResultType();
+            printOriginalExpression();
+            printReconstructedExpression();
+        } else {
+            stream << '\n';
+        }
+        printMessage();
+    }
+
+private:
+    void printResultType() const {
+        if (!passOrFail.empty()) {
+            stream << colourImpl->guardColour(colour) << passOrFail << ":\n";
+        }
+    }
+    void printOriginalExpression() const {
+        if (result.hasExpression()) {
+            stream << colourImpl->guardColour( Colour::OriginalExpression )
+                   << "  " << result.getExpressionInMacro() << '\n';
+        }
+    }
+    void printReconstructedExpression() const {
+        if (result.hasExpandedExpression()) {
+            stream << "with expansion:\n";
+            stream << colourImpl->guardColour( Colour::ReconstructedExpression )
+                   << TextFlow::Column( result.getExpandedExpression() )
+                          .indent( 2 )
+                   << '\n';
+        }
+    }
+    void printMessage() const {
+        if (!messageLabel.empty())
+            stream << messageLabel << ':' << '\n';
+        for (auto const& msg : messages) {
+            // If this assertion is a warning ignore any INFO messages
+            if (printInfoMessages || msg.type != ResultWas::Info)
+                stream << TextFlow::Column(msg.message).indent(2) << '\n';
+        }
+    }
+    void printSourceInfo() const {
+        stream << colourImpl->guardColour( Colour::FileName )
+               << result.getSourceInfo() << ": ";
+    }
+
+    std::ostream& stream;
+    AssertionStats const& stats;
+    AssertionResult const& result;
+    Colour::Code colour;
+    StringRef passOrFail;
+    StringRef messageLabel;
+    std::vector<MessageInfo> const& messages;
+    ColourImpl* colourImpl;
+    bool printInfoMessages;
+};
+
+std::size_t makeRatio( std::uint64_t number, std::uint64_t total ) {
+    const auto ratio = total > 0 ? CATCH_CONFIG_CONSOLE_WIDTH * number / total : 0;
+    return (ratio == 0 && number > 0) ? 1 : static_cast<std::size_t>(ratio);
+}
+
+std::size_t&
+findMax( std::size_t& i, std::size_t& j, std::size_t& k, std::size_t& l ) {
+    if (i > j && i > k && i > l)
+        return i;
+    else if (j > k && j > l)
+        return j;
+    else if (k > l)
+        return k;
+    else
+        return l;
+}
+
+struct ColumnBreak {};
+struct RowBreak {};
+struct OutputFlush {};
+
+class Duration {
+    enum class Unit {
+        Auto,
+        Nanoseconds,
+        Microseconds,
+        Milliseconds,
+        Seconds,
+        Minutes
+    };
+    static const uint64_t s_nanosecondsInAMicrosecond = 1000;
+    static const uint64_t s_nanosecondsInAMillisecond = 1000 * s_nanosecondsInAMicrosecond;
+    static const uint64_t s_nanosecondsInASecond = 1000 * s_nanosecondsInAMillisecond;
+    static const uint64_t s_nanosecondsInAMinute = 60 * s_nanosecondsInASecond;
+
+    double m_inNanoseconds;
+    Unit m_units;
+
+public:
+    explicit Duration(double inNanoseconds, Unit units = Unit::Auto)
+        : m_inNanoseconds(inNanoseconds),
+        m_units(units) {
+        if (m_units == Unit::Auto) {
+            if (m_inNanoseconds < s_nanosecondsInAMicrosecond)
+                m_units = Unit::Nanoseconds;
+            else if (m_inNanoseconds < s_nanosecondsInAMillisecond)
+                m_units = Unit::Microseconds;
+            else if (m_inNanoseconds < s_nanosecondsInASecond)
+                m_units = Unit::Milliseconds;
+            else if (m_inNanoseconds < s_nanosecondsInAMinute)
+                m_units = Unit::Seconds;
+            else
+                m_units = Unit::Minutes;
+        }
+
+    }
+
+    auto value() const -> double {
+        switch (m_units) {
+        case Unit::Microseconds:
+            return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMicrosecond);
+        case Unit::Milliseconds:
+            return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMillisecond);
+        case Unit::Seconds:
+            return m_inNanoseconds / static_cast<double>(s_nanosecondsInASecond);
+        case Unit::Minutes:
+            return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMinute);
+        default:
+            return m_inNanoseconds;
+        }
+    }
+    StringRef unitsAsString() const {
+        switch (m_units) {
+        case Unit::Nanoseconds:
+            return "ns"_sr;
+        case Unit::Microseconds:
+            return "us"_sr;
+        case Unit::Milliseconds:
+            return "ms"_sr;
+        case Unit::Seconds:
+            return "s"_sr;
+        case Unit::Minutes:
+            return "m"_sr;
+        default:
+            return "** internal error **"_sr;
+        }
+
+    }
+    friend auto operator << (std::ostream& os, Duration const& duration) -> std::ostream& {
+        return os << duration.value() << ' ' << duration.unitsAsString();
+    }
+};
+} // end anon namespace
+
+enum class Justification { Left, Right };
+
+struct ColumnInfo {
+    std::string name;
+    std::size_t width;
+    Justification justification;
+};
+
+class TablePrinter {
+    std::ostream& m_os;
+    std::vector<ColumnInfo> m_columnInfos;
+    ReusableStringStream m_oss;
+    int m_currentColumn = -1;
+    bool m_isOpen = false;
+
+public:
+    TablePrinter( std::ostream& os, std::vector<ColumnInfo> columnInfos )
+    :   m_os( os ),
+        m_columnInfos( CATCH_MOVE( columnInfos ) ) {}
+
+    auto columnInfos() const -> std::vector<ColumnInfo> const& {
+        return m_columnInfos;
+    }
+
+    void open() {
+        if (!m_isOpen) {
+            m_isOpen = true;
+            *this << RowBreak();
+
+			TextFlow::Columns headerCols;
+			for (auto const& info : m_columnInfos) {
+                assert(info.width > 2);
+				headerCols += TextFlow::Column(info.name).width(info.width - 2);
+                headerCols += TextFlow::Spacer( 2 );
+			}
+			m_os << headerCols << '\n';
+
+            m_os << lineOfChars('-') << '\n';
+        }
+    }
+    void close() {
+        if (m_isOpen) {
+            *this << RowBreak();
+            m_os << '\n' << std::flush;
+            m_isOpen = false;
+        }
+    }
+
+    template<typename T>
+    friend TablePrinter& operator<< (TablePrinter& tp, T const& value) {
+        tp.m_oss << value;
+        return tp;
+    }
+
+    friend TablePrinter& operator<< (TablePrinter& tp, ColumnBreak) {
+        auto colStr = tp.m_oss.str();
+        const auto strSize = colStr.size();
+        tp.m_oss.str("");
+        tp.open();
+        if (tp.m_currentColumn == static_cast<int>(tp.m_columnInfos.size() - 1)) {
+            tp.m_currentColumn = -1;
+            tp.m_os << '\n';
+        }
+        tp.m_currentColumn++;
+
+        auto colInfo = tp.m_columnInfos[tp.m_currentColumn];
+        auto padding = (strSize + 1 < colInfo.width)
+            ? std::string(colInfo.width - (strSize + 1), ' ')
+            : std::string();
+        if (colInfo.justification == Justification::Left)
+            tp.m_os << colStr << padding << ' ';
+        else
+            tp.m_os << padding << colStr << ' ';
+        return tp;
+    }
+
+    friend TablePrinter& operator<< (TablePrinter& tp, RowBreak) {
+        if (tp.m_currentColumn > 0) {
+            tp.m_os << '\n';
+            tp.m_currentColumn = -1;
+        }
+        return tp;
+    }
+
+    friend TablePrinter& operator<<(TablePrinter& tp, OutputFlush) {
+        tp.m_os << std::flush;
+        return tp;
+    }
+};
+
+ConsoleReporter::ConsoleReporter(ReporterConfig&& config):
+    StreamingReporterBase( CATCH_MOVE( config ) ),
+    m_tablePrinter(Detail::make_unique<TablePrinter>(m_stream,
+        [&config]() -> std::vector<ColumnInfo> {
+        if (config.fullConfig()->benchmarkNoAnalysis())
+        {
+            return{
+                { "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 43, Justification::Left },
+                { "     samples", 14, Justification::Right },
+                { "  iterations", 14, Justification::Right },
+                { "        mean", 14, Justification::Right }
+            };
+        }
+        else
+        {
+            return{
+                { "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 43, Justification::Left },
+                { "samples      mean       std dev", 14, Justification::Right },
+                { "iterations   low mean   low std dev", 14, Justification::Right },
+                { "est run time high mean  high std dev", 14, Justification::Right }
+            };
+        }
+    }())) {}
+ConsoleReporter::~ConsoleReporter() = default;
+
+std::string ConsoleReporter::getDescription() {
+    return "Reports test results as plain lines of text";
+}
+
+void ConsoleReporter::noMatchingTestCases( StringRef unmatchedSpec ) {
+    m_stream << "No test cases matched '" << unmatchedSpec << "'\n";
+}
+
+void ConsoleReporter::reportInvalidTestSpec( StringRef arg ) {
+    m_stream << "Invalid Filter: " << arg << '\n';
+}
+
+void ConsoleReporter::assertionStarting(AssertionInfo const&) {}
+
+void ConsoleReporter::assertionEnded(AssertionStats const& _assertionStats) {
+    AssertionResult const& result = _assertionStats.assertionResult;
+
+    bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
+
+    // Drop out if result was successful but we're not printing them.
+    // TODO: Make configurable whether skips should be printed
+    if (!includeResults && result.getResultType() != ResultWas::Warning && result.getResultType() != ResultWas::ExplicitSkip)
+        return;
+
+    lazyPrint();
+
+    ConsoleAssertionPrinter printer(m_stream, _assertionStats, m_colour.get(), includeResults);
+    printer.print();
+    m_stream << '\n' << std::flush;
+}
+
+void ConsoleReporter::sectionStarting(SectionInfo const& _sectionInfo) {
+    m_tablePrinter->close();
+    m_headerPrinted = false;
+    StreamingReporterBase::sectionStarting(_sectionInfo);
+}
+void ConsoleReporter::sectionEnded(SectionStats const& _sectionStats) {
+    m_tablePrinter->close();
+    if (_sectionStats.missingAssertions) {
+        lazyPrint();
+        auto guard =
+            m_colour->guardColour( Colour::ResultError ).engage( m_stream );
+        if (m_sectionStack.size() > 1)
+            m_stream << "\nNo assertions in section";
+        else
+            m_stream << "\nNo assertions in test case";
+        m_stream << " '" << _sectionStats.sectionInfo.name << "'\n\n" << std::flush;
+    }
+    double dur = _sectionStats.durationInSeconds;
+    if (shouldShowDuration(*m_config, dur)) {
+        m_stream << getFormattedDuration(dur) << " s: " << _sectionStats.sectionInfo.name << '\n' << std::flush;
+    }
+    if (m_headerPrinted) {
+        m_headerPrinted = false;
+    }
+    StreamingReporterBase::sectionEnded(_sectionStats);
+}
+
+void ConsoleReporter::benchmarkPreparing( StringRef name ) {
+	lazyPrintWithoutClosingBenchmarkTable();
+
+	auto nameCol = TextFlow::Column( static_cast<std::string>( name ) )
+                       .width( m_tablePrinter->columnInfos()[0].width - 2 );
+
+	bool firstLine = true;
+	for (auto line : nameCol) {
+		if (!firstLine)
+			(*m_tablePrinter) << ColumnBreak() << ColumnBreak() << ColumnBreak();
+		else
+			firstLine = false;
+
+		(*m_tablePrinter) << line << ColumnBreak();
+	}
+}
+
+void ConsoleReporter::benchmarkStarting(BenchmarkInfo const& info) {
+    (*m_tablePrinter) << info.samples << ColumnBreak()
+        << info.iterations << ColumnBreak();
+    if ( !m_config->benchmarkNoAnalysis() ) {
+        ( *m_tablePrinter )
+            << Duration( info.estimatedDuration ) << ColumnBreak();
+    }
+    ( *m_tablePrinter ) << OutputFlush{};
+}
+void ConsoleReporter::benchmarkEnded(BenchmarkStats<> const& stats) {
+    if (m_config->benchmarkNoAnalysis())
+    {
+        (*m_tablePrinter) << Duration(stats.mean.point.count()) << ColumnBreak();
+    }
+    else
+    {
+        (*m_tablePrinter) << ColumnBreak()
+            << Duration(stats.mean.point.count()) << ColumnBreak()
+            << Duration(stats.mean.lower_bound.count()) << ColumnBreak()
+            << Duration(stats.mean.upper_bound.count()) << ColumnBreak() << ColumnBreak()
+            << Duration(stats.standardDeviation.point.count()) << ColumnBreak()
+            << Duration(stats.standardDeviation.lower_bound.count()) << ColumnBreak()
+            << Duration(stats.standardDeviation.upper_bound.count()) << ColumnBreak() << ColumnBreak() << ColumnBreak() << ColumnBreak() << ColumnBreak();
+    }
+}
+
+void ConsoleReporter::benchmarkFailed( StringRef error ) {
+    auto guard = m_colour->guardColour( Colour::Red ).engage( m_stream );
+    (*m_tablePrinter)
+        << "Benchmark failed (" << error << ')'
+        << ColumnBreak() << RowBreak();
+}
+
+void ConsoleReporter::testCaseEnded(TestCaseStats const& _testCaseStats) {
+    m_tablePrinter->close();
+    StreamingReporterBase::testCaseEnded(_testCaseStats);
+    m_headerPrinted = false;
+}
+void ConsoleReporter::testRunEnded(TestRunStats const& _testRunStats) {
+    printTotalsDivider(_testRunStats.totals);
+    printTestRunTotals( m_stream, *m_colour, _testRunStats.totals );
+    m_stream << '\n' << std::flush;
+    StreamingReporterBase::testRunEnded(_testRunStats);
+}
+void ConsoleReporter::testRunStarting(TestRunInfo const& _testRunInfo) {
+    StreamingReporterBase::testRunStarting(_testRunInfo);
+    if ( m_config->testSpec().hasFilters() ) {
+        m_stream << m_colour->guardColour( Colour::BrightYellow ) << "Filters: "
+                 << m_config->testSpec() << '\n';
+    }
+    m_stream << "Randomness seeded to: " << getSeed() << '\n';
+}
+
+void ConsoleReporter::lazyPrint() {
+
+    m_tablePrinter->close();
+    lazyPrintWithoutClosingBenchmarkTable();
+}
+
+void ConsoleReporter::lazyPrintWithoutClosingBenchmarkTable() {
+
+    if ( !m_testRunInfoPrinted ) {
+        lazyPrintRunInfo();
+    }
+    if (!m_headerPrinted) {
+        printTestCaseAndSectionHeader();
+        m_headerPrinted = true;
+    }
+}
+void ConsoleReporter::lazyPrintRunInfo() {
+    m_stream << '\n'
+             << lineOfChars( '~' ) << '\n'
+             << m_colour->guardColour( Colour::SecondaryText )
+             << currentTestRunInfo.name << " is a Catch2 v" << libraryVersion()
+             << " host application.\n"
+             << "Run with -? for options\n\n";
+
+    m_testRunInfoPrinted = true;
+}
+void ConsoleReporter::printTestCaseAndSectionHeader() {
+    assert(!m_sectionStack.empty());
+    printOpenHeader(currentTestCaseInfo->name);
+
+    if (m_sectionStack.size() > 1) {
+        auto guard = m_colour->guardColour( Colour::Headers ).engage( m_stream );
+
+        auto
+            it = m_sectionStack.begin() + 1, // Skip first section (test case)
+            itEnd = m_sectionStack.end();
+        for (; it != itEnd; ++it)
+            printHeaderString(it->name, 2);
+    }
+
+    SourceLineInfo lineInfo = m_sectionStack.back().lineInfo;
+
+
+    m_stream << lineOfChars( '-' ) << '\n'
+             << m_colour->guardColour( Colour::FileName ) << lineInfo << '\n'
+             << lineOfChars( '.' ) << "\n\n"
+             << std::flush;
+}
+
+void ConsoleReporter::printClosedHeader(std::string const& _name) {
+    printOpenHeader(_name);
+    m_stream << lineOfChars('.') << '\n';
+}
+void ConsoleReporter::printOpenHeader(std::string const& _name) {
+    m_stream << lineOfChars('-') << '\n';
+    {
+        auto guard = m_colour->guardColour( Colour::Headers ).engage( m_stream );
+        printHeaderString(_name);
+    }
+}
+
+void ConsoleReporter::printHeaderString(std::string const& _string, std::size_t indent) {
+    // We want to get a bit fancy with line breaking here, so that subsequent
+    // lines start after ":" if one is present, e.g.
+    // ```
+    // blablabla: Fancy
+    //            linebreaking
+    // ```
+    // but we also want to avoid problems with overly long indentation causing
+    // the text to take up too many lines, e.g.
+    // ```
+    // blablabla: F
+    //            a
+    //            n
+    //            c
+    //            y
+    //            .
+    //            .
+    //            .
+    // ```
+    // So we limit the prefix indentation check to first quarter of the possible
+    // width
+    std::size_t idx = _string.find( ": " );
+    if ( idx != std::string::npos && idx < CATCH_CONFIG_CONSOLE_WIDTH / 4 ) {
+        idx += 2;
+    } else {
+        idx = 0;
+    }
+    m_stream << TextFlow::Column( _string )
+                  .indent( indent + idx )
+                  .initialIndent( indent )
+           << '\n';
+}
+
+void ConsoleReporter::printTotalsDivider(Totals const& totals) {
+    if (totals.testCases.total() > 0) {
+        std::size_t failedRatio = makeRatio(totals.testCases.failed, totals.testCases.total());
+        std::size_t failedButOkRatio = makeRatio(totals.testCases.failedButOk, totals.testCases.total());
+        std::size_t passedRatio = makeRatio(totals.testCases.passed, totals.testCases.total());
+        std::size_t skippedRatio = makeRatio(totals.testCases.skipped, totals.testCases.total());
+        while (failedRatio + failedButOkRatio + passedRatio + skippedRatio < CATCH_CONFIG_CONSOLE_WIDTH - 1)
+            findMax(failedRatio, failedButOkRatio, passedRatio, skippedRatio)++;
+        while (failedRatio + failedButOkRatio + passedRatio > CATCH_CONFIG_CONSOLE_WIDTH - 1)
+            findMax(failedRatio, failedButOkRatio, passedRatio, skippedRatio)--;
+
+        m_stream << m_colour->guardColour( Colour::Error )
+                 << std::string( failedRatio, '=' )
+                 << m_colour->guardColour( Colour::ResultExpectedFailure )
+                 << std::string( failedButOkRatio, '=' );
+        if ( totals.testCases.allPassed() ) {
+            m_stream << m_colour->guardColour( Colour::ResultSuccess )
+                     << std::string( passedRatio, '=' );
+        } else {
+            m_stream << m_colour->guardColour( Colour::Success )
+                     << std::string( passedRatio, '=' );
+        }
+        m_stream << m_colour->guardColour( Colour::Skip )
+                 << std::string( skippedRatio, '=' );
+    } else {
+        m_stream << m_colour->guardColour( Colour::Warning )
+                 << std::string( CATCH_CONFIG_CONSOLE_WIDTH - 1, '=' );
+    }
+    m_stream << '\n';
+}
+
+} // end namespace Catch
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+#if defined(__clang__)
+#  pragma clang diagnostic pop
+#endif
+
+
+
+
+#include <algorithm>
+#include <cassert>
+
+namespace Catch {
+    namespace {
+        struct BySectionInfo {
+            BySectionInfo( SectionInfo const& other ): m_other( other ) {}
+            BySectionInfo( BySectionInfo const& other ) = default;
+            bool operator()(
+                Detail::unique_ptr<CumulativeReporterBase::SectionNode> const&
+                    node ) const {
+                return (
+                    ( node->stats.sectionInfo.name == m_other.name ) &&
+                    ( node->stats.sectionInfo.lineInfo == m_other.lineInfo ) );
+            }
+            void operator=( BySectionInfo const& ) = delete;
+
+        private:
+            SectionInfo const& m_other;
+        };
+
+    } // namespace
+
+    namespace Detail {
+        AssertionOrBenchmarkResult::AssertionOrBenchmarkResult(
+            AssertionStats const& assertion ):
+            m_assertion( assertion ) {}
+
+        AssertionOrBenchmarkResult::AssertionOrBenchmarkResult(
+            BenchmarkStats<> const& benchmark ):
+            m_benchmark( benchmark ) {}
+
+        bool AssertionOrBenchmarkResult::isAssertion() const {
+            return m_assertion.some();
+        }
+        bool AssertionOrBenchmarkResult::isBenchmark() const {
+            return m_benchmark.some();
+        }
+
+        AssertionStats const& AssertionOrBenchmarkResult::asAssertion() const {
+            assert(m_assertion.some());
+
+            return *m_assertion;
+        }
+        BenchmarkStats<> const& AssertionOrBenchmarkResult::asBenchmark() const {
+            assert(m_benchmark.some());
+
+            return *m_benchmark;
+        }
+
+    }
+
+    CumulativeReporterBase::~CumulativeReporterBase() = default;
+
+    void CumulativeReporterBase::benchmarkEnded(BenchmarkStats<> const& benchmarkStats) {
+        m_sectionStack.back()->assertionsAndBenchmarks.emplace_back(benchmarkStats);
+    }
+
+    void
+    CumulativeReporterBase::sectionStarting( SectionInfo const& sectionInfo ) {
+        // We need a copy, because SectionStats expect to take ownership
+        SectionStats incompleteStats( SectionInfo(sectionInfo), Counts(), 0, false );
+        SectionNode* node;
+        if ( m_sectionStack.empty() ) {
+            if ( !m_rootSection ) {
+                m_rootSection =
+                    Detail::make_unique<SectionNode>( incompleteStats );
+            }
+            node = m_rootSection.get();
+        } else {
+            SectionNode& parentNode = *m_sectionStack.back();
+            auto it = std::find_if( parentNode.childSections.begin(),
+                                    parentNode.childSections.end(),
+                                    BySectionInfo( sectionInfo ) );
+            if ( it == parentNode.childSections.end() ) {
+                auto newNode =
+                    Detail::make_unique<SectionNode>( incompleteStats );
+                node = newNode.get();
+                parentNode.childSections.push_back( CATCH_MOVE( newNode ) );
+            } else {
+                node = it->get();
+            }
+        }
+
+        m_deepestSection = node;
+        m_sectionStack.push_back( node );
+    }
+
+    void CumulativeReporterBase::assertionEnded(
+        AssertionStats const& assertionStats ) {
+        assert( !m_sectionStack.empty() );
+        // AssertionResult holds a pointer to a temporary DecomposedExpression,
+        // which getExpandedExpression() calls to build the expression string.
+        // Our section stack copy of the assertionResult will likely outlive the
+        // temporary, so it must be expanded or discarded now to avoid calling
+        // a destroyed object later.
+        if ( m_shouldStoreFailedAssertions &&
+             !assertionStats.assertionResult.isOk() ) {
+            static_cast<void>(
+                assertionStats.assertionResult.getExpandedExpression() );
+        }
+        if ( m_shouldStoreSuccesfulAssertions &&
+             assertionStats.assertionResult.isOk() ) {
+            static_cast<void>(
+                assertionStats.assertionResult.getExpandedExpression() );
+        }
+        SectionNode& sectionNode = *m_sectionStack.back();
+        sectionNode.assertionsAndBenchmarks.emplace_back( assertionStats );
+    }
+
+    void CumulativeReporterBase::sectionEnded( SectionStats const& sectionStats ) {
+        assert( !m_sectionStack.empty() );
+        SectionNode& node = *m_sectionStack.back();
+        node.stats = sectionStats;
+        m_sectionStack.pop_back();
+    }
+
+    void CumulativeReporterBase::testCaseEnded(
+        TestCaseStats const& testCaseStats ) {
+        auto node = Detail::make_unique<TestCaseNode>( testCaseStats );
+        assert( m_sectionStack.size() == 0 );
+        node->children.push_back( CATCH_MOVE(m_rootSection) );
+        m_testCases.push_back( CATCH_MOVE(node) );
+
+        assert( m_deepestSection );
+        m_deepestSection->stdOut = testCaseStats.stdOut;
+        m_deepestSection->stdErr = testCaseStats.stdErr;
+    }
+
+
+    void CumulativeReporterBase::testRunEnded( TestRunStats const& testRunStats ) {
+        assert(!m_testRun && "CumulativeReporterBase assumes there can only be one test run");
+        m_testRun = Detail::make_unique<TestRunNode>( testRunStats );
+        m_testRun->children.swap( m_testCases );
+        testRunEndedCumulative();
+    }
+
+    bool CumulativeReporterBase::SectionNode::hasAnyAssertions() const {
+        return std::any_of(
+            assertionsAndBenchmarks.begin(),
+            assertionsAndBenchmarks.end(),
+            []( Detail::AssertionOrBenchmarkResult const& res ) {
+                return res.isAssertion();
+            } );
+    }
+
+} // end namespace Catch
+
+
+
+
+namespace Catch {
+
+    void EventListenerBase::fatalErrorEncountered( StringRef ) {}
+
+    void EventListenerBase::benchmarkPreparing( StringRef ) {}
+    void EventListenerBase::benchmarkStarting( BenchmarkInfo const& ) {}
+    void EventListenerBase::benchmarkEnded( BenchmarkStats<> const& ) {}
+    void EventListenerBase::benchmarkFailed( StringRef ) {}
+
+    void EventListenerBase::assertionStarting( AssertionInfo const& ) {}
+
+    void EventListenerBase::assertionEnded( AssertionStats const& ) {}
+    void EventListenerBase::listReporters(
+        std::vector<ReporterDescription> const& ) {}
+    void EventListenerBase::listListeners(
+        std::vector<ListenerDescription> const& ) {}
+    void EventListenerBase::listTests( std::vector<TestCaseHandle> const& ) {}
+    void EventListenerBase::listTags( std::vector<TagInfo> const& ) {}
+    void EventListenerBase::noMatchingTestCases( StringRef ) {}
+    void EventListenerBase::reportInvalidTestSpec( StringRef ) {}
+    void EventListenerBase::testRunStarting( TestRunInfo const& ) {}
+    void EventListenerBase::testCaseStarting( TestCaseInfo const& ) {}
+    void EventListenerBase::testCasePartialStarting(TestCaseInfo const&, uint64_t) {}
+    void EventListenerBase::sectionStarting( SectionInfo const& ) {}
+    void EventListenerBase::sectionEnded( SectionStats const& ) {}
+    void EventListenerBase::testCasePartialEnded(TestCaseStats const&, uint64_t) {}
+    void EventListenerBase::testCaseEnded( TestCaseStats const& ) {}
+    void EventListenerBase::testRunEnded( TestRunStats const& ) {}
+    void EventListenerBase::skipTest( TestCaseInfo const& ) {}
+} // namespace Catch
+
+
+
+
+#include <algorithm>
+#include <cfloat>
+#include <cstdio>
+#include <ostream>
+#include <iomanip>
+
+namespace Catch {
+
+    namespace {
+        void listTestNamesOnly(std::ostream& out,
+                               std::vector<TestCaseHandle> const& tests) {
+            for (auto const& test : tests) {
+                auto const& testCaseInfo = test.getTestCaseInfo();
+
+                if (startsWith(testCaseInfo.name, '#')) {
+                    out << '"' << testCaseInfo.name << '"';
+                } else {
+                    out << testCaseInfo.name;
+                }
+
+                out << '\n';
+            }
+            out << std::flush;
+        }
+    } // end unnamed namespace
+
+
+    // Because formatting using c++ streams is stateful, drop down to C is
+    // required Alternatively we could use stringstream, but its performance
+    // is... not good.
+    std::string getFormattedDuration( double duration ) {
+        // Max exponent + 1 is required to represent the whole part
+        // + 1 for decimal point
+        // + 3 for the 3 decimal places
+        // + 1 for null terminator
+        const std::size_t maxDoubleSize = DBL_MAX_10_EXP + 1 + 1 + 3 + 1;
+        char buffer[maxDoubleSize];
+
+        // Save previous errno, to prevent sprintf from overwriting it
+        ErrnoGuard guard;
+#ifdef _MSC_VER
+        size_t printedLength = static_cast<size_t>(
+            sprintf_s( buffer, "%.3f", duration ) );
+#else
+        size_t printedLength = static_cast<size_t>(
+            std::snprintf( buffer, maxDoubleSize, "%.3f", duration ) );
+#endif
+        return std::string( buffer, printedLength );
+    }
+
+    bool shouldShowDuration( IConfig const& config, double duration ) {
+        if ( config.showDurations() == ShowDurations::Always ) {
+            return true;
+        }
+        if ( config.showDurations() == ShowDurations::Never ) {
+            return false;
+        }
+        const double min = config.minDuration();
+        return min >= 0 && duration >= min;
+    }
+
+    std::string serializeFilters( std::vector<std::string> const& filters ) {
+        // We add a ' ' separator between each filter
+        size_t serialized_size = filters.size() - 1;
+        for (auto const& filter : filters) {
+            serialized_size += filter.size();
+        }
+
+        std::string serialized;
+        serialized.reserve(serialized_size);
+        bool first = true;
+
+        for (auto const& filter : filters) {
+            if (!first) {
+                serialized.push_back(' ');
+            }
+            first = false;
+            serialized.append(filter);
+        }
+
+        return serialized;
+    }
+
+    std::ostream& operator<<( std::ostream& out, lineOfChars value ) {
+        for ( size_t idx = 0; idx < CATCH_CONFIG_CONSOLE_WIDTH - 1; ++idx ) {
+            out.put( value.c );
+        }
+        return out;
+    }
+
+    void
+    defaultListReporters( std::ostream& out,
+                          std::vector<ReporterDescription> const& descriptions,
+                          Verbosity verbosity ) {
+        out << "Available reporters:\n";
+        const auto maxNameLen =
+            std::max_element( descriptions.begin(),
+                              descriptions.end(),
+                              []( ReporterDescription const& lhs,
+                                  ReporterDescription const& rhs ) {
+                                  return lhs.name.size() < rhs.name.size();
+                              } )
+                ->name.size();
+
+        for ( auto const& desc : descriptions ) {
+            if ( verbosity == Verbosity::Quiet ) {
+                out << TextFlow::Column( desc.name )
+                           .indent( 2 )
+                           .width( 5 + maxNameLen )
+                    << '\n';
+            } else {
+                out << TextFlow::Column( desc.name + ':' )
+                               .indent( 2 )
+                               .width( 5 + maxNameLen ) +
+                           TextFlow::Column( desc.description )
+                               .initialIndent( 0 )
+                               .indent( 2 )
+                               .width( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen - 8 )
+                    << '\n';
+            }
+        }
+        out << '\n' << std::flush;
+    }
+
+    void defaultListListeners( std::ostream& out,
+                               std::vector<ListenerDescription> const& descriptions ) {
+        out << "Registered listeners:\n";
+
+        if(descriptions.empty()) {
+            return;
+        }
+
+        const auto maxNameLen =
+            std::max_element( descriptions.begin(),
+                              descriptions.end(),
+                              []( ListenerDescription const& lhs,
+                                  ListenerDescription const& rhs ) {
+                                  return lhs.name.size() < rhs.name.size();
+                              } )
+                ->name.size();
+
+        for ( auto const& desc : descriptions ) {
+            out << TextFlow::Column( static_cast<std::string>( desc.name ) +
+                                     ':' )
+                           .indent( 2 )
+                           .width( maxNameLen + 5 ) +
+                       TextFlow::Column( desc.description )
+                           .initialIndent( 0 )
+                           .indent( 2 )
+                           .width( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen - 8 )
+                << '\n';
+        }
+
+        out << '\n' << std::flush;
+    }
+
+    void defaultListTags( std::ostream& out,
+                          std::vector<TagInfo> const& tags,
+                          bool isFiltered ) {
+        if ( isFiltered ) {
+            out << "Tags for matching test cases:\n";
+        } else {
+            out << "All available tags:\n";
+        }
+
+        for ( auto const& tagCount : tags ) {
+            ReusableStringStream rss;
+            rss << "  " << std::setw( 2 ) << tagCount.count << "  ";
+            auto str = rss.str();
+            auto wrapper = TextFlow::Column( tagCount.all() )
+                               .initialIndent( 0 )
+                               .indent( str.size() )
+                               .width( CATCH_CONFIG_CONSOLE_WIDTH - 10 );
+            out << str << wrapper << '\n';
+        }
+        out << pluralise(tags.size(), "tag"_sr) << "\n\n" << std::flush;
+    }
+
+    void defaultListTests(std::ostream& out, ColourImpl* streamColour, std::vector<TestCaseHandle> const& tests, bool isFiltered, Verbosity verbosity) {
+        // We special case this to provide the equivalent of old
+        // `--list-test-names-only`, which could then be used by the
+        // `--input-file` option.
+        if (verbosity == Verbosity::Quiet) {
+            listTestNamesOnly(out, tests);
+            return;
+        }
+
+        if (isFiltered) {
+            out << "Matching test cases:\n";
+        } else {
+            out << "All available test cases:\n";
+        }
+
+        for (auto const& test : tests) {
+            auto const& testCaseInfo = test.getTestCaseInfo();
+            Colour::Code colour = testCaseInfo.isHidden()
+                ? Colour::SecondaryText
+                : Colour::None;
+            auto colourGuard = streamColour->guardColour( colour ).engage( out );
+
+            out << TextFlow::Column(testCaseInfo.name).indent(2) << '\n';
+            if (verbosity >= Verbosity::High) {
+                out << TextFlow::Column(Catch::Detail::stringify(testCaseInfo.lineInfo)).indent(4) << '\n';
+            }
+            if (!testCaseInfo.tags.empty() &&
+                verbosity > Verbosity::Quiet) {
+                out << TextFlow::Column(testCaseInfo.tagsAsString()).indent(6) << '\n';
+            }
+        }
+
+        if (isFiltered) {
+            out << pluralise(tests.size(), "matching test case"_sr);
+        } else {
+            out << pluralise(tests.size(), "test case"_sr);
+        }
+        out << "\n\n" << std::flush;
+    }
+
+    namespace {
+        class SummaryColumn {
+        public:
+            SummaryColumn( std::string suffix, Colour::Code colour ):
+                m_suffix( CATCH_MOVE( suffix ) ), m_colour( colour ) {}
+
+            SummaryColumn&& addRow( std::uint64_t count ) && {
+                std::string row = std::to_string(count);
+                auto const new_width = std::max( m_width, row.size() );
+                if ( new_width > m_width ) {
+                    for ( auto& oldRow : m_rows ) {
+                        oldRow.insert( 0, new_width - m_width, ' ' );
+                    }
+                } else {
+                    row.insert( 0, m_width - row.size(), ' ' );
+                }
+                m_width = new_width;
+                m_rows.push_back( row );
+                return std::move( *this );
+            }
+
+            std::string const& getSuffix() const { return m_suffix; }
+            Colour::Code getColour() const { return m_colour; }
+            std::string const& getRow( std::size_t index ) const {
+                return m_rows[index];
+            }
+
+        private:
+            std::string m_suffix;
+            Colour::Code m_colour;
+            std::size_t m_width = 0;
+            std::vector<std::string> m_rows;
+        };
+
+        void printSummaryRow( std::ostream& stream,
+                              ColourImpl& colour,
+                              StringRef label,
+                              std::vector<SummaryColumn> const& cols,
+                              std::size_t row ) {
+            for ( auto const& col : cols ) {
+                auto const& value = col.getRow( row );
+                auto const& suffix = col.getSuffix();
+                if ( suffix.empty() ) {
+                    stream << label << ": ";
+                    if ( value != "0" ) {
+                        stream << value;
+                    } else {
+                        stream << colour.guardColour( Colour::Warning )
+                               << "- none -";
+                    }
+                } else if ( value != "0" ) {
+                    stream << colour.guardColour( Colour::LightGrey ) << " | "
+                           << colour.guardColour( col.getColour() ) << value
+                           << ' ' << suffix;
+                }
+            }
+            stream << '\n';
+        }
+    } // namespace
+
+    void printTestRunTotals( std::ostream& stream,
+                             ColourImpl& streamColour,
+                             Totals const& totals ) {
+        if ( totals.testCases.total() == 0 ) {
+            stream << streamColour.guardColour( Colour::Warning )
+                   << "No tests ran\n";
+            return;
+        }
+
+        if ( totals.assertions.total() > 0 && totals.testCases.allPassed() ) {
+            stream << streamColour.guardColour( Colour::ResultSuccess )
+                   << "All tests passed";
+            stream << " ("
+                   << pluralise( totals.assertions.passed, "assertion"_sr )
+                   << " in "
+                   << pluralise( totals.testCases.passed, "test case"_sr )
+                   << ')' << '\n';
+            return;
+        }
+
+        std::vector<SummaryColumn> columns;
+        // Don't include "skipped assertions" in total count
+        const auto totalAssertionCount =
+            totals.assertions.total() - totals.assertions.skipped;
+        columns.push_back( SummaryColumn( "", Colour::None )
+                               .addRow( totals.testCases.total() )
+                               .addRow( totalAssertionCount ) );
+        columns.push_back( SummaryColumn( "passed", Colour::Success )
+                               .addRow( totals.testCases.passed )
+                               .addRow( totals.assertions.passed ) );
+        columns.push_back( SummaryColumn( "failed", Colour::ResultError )
+                               .addRow( totals.testCases.failed )
+                               .addRow( totals.assertions.failed ) );
+        columns.push_back( SummaryColumn( "skipped", Colour::Skip )
+                               .addRow( totals.testCases.skipped )
+                               // Don't print "skipped assertions"
+                               .addRow( 0 ) );
+        columns.push_back(
+            SummaryColumn( "failed as expected", Colour::ResultExpectedFailure )
+                .addRow( totals.testCases.failedButOk )
+                .addRow( totals.assertions.failedButOk ) );
+        printSummaryRow( stream, streamColour, "test cases"_sr, columns, 0 );
+        printSummaryRow( stream, streamColour, "assertions"_sr, columns, 1 );
+    }
+
+} // namespace Catch
+
+
+//
+
+namespace Catch {
+    namespace {
+        void writeSourceInfo( JsonObjectWriter& writer,
+                              SourceLineInfo const& sourceInfo ) {
+            auto source_location_writer =
+                writer.write( "source-location"_sr ).writeObject();
+            source_location_writer.write( "filename"_sr )
+                .write( sourceInfo.file );
+            source_location_writer.write( "line"_sr ).write( sourceInfo.line );
+        }
+
+        void writeTags( JsonArrayWriter writer, std::vector<Tag> const& tags ) {
+            for ( auto const& tag : tags ) {
+                writer.write( tag.original );
+            }
+        }
+
+        void writeProperties( JsonArrayWriter writer,
+                              TestCaseInfo const& info ) {
+            if ( info.isHidden() ) { writer.write( "is-hidden"_sr ); }
+            if ( info.okToFail() ) { writer.write( "ok-to-fail"_sr ); }
+            if ( info.expectedToFail() ) {
+                writer.write( "expected-to-fail"_sr );
+            }
+            if ( info.throws() ) { writer.write( "throws"_sr ); }
+        }
+
+    } // namespace
+
+    JsonReporter::JsonReporter( ReporterConfig&& config ):
+        StreamingReporterBase{ CATCH_MOVE( config ) } {
+
+        m_preferences.shouldRedirectStdOut = true;
+        // TBD: Do we want to report all assertions? XML reporter does
+        //      not, but for machine-parseable reporters I think the answer
+        //      should be yes.
+        m_preferences.shouldReportAllAssertions = true;
+
+        m_objectWriters.emplace( m_stream );
+        m_writers.emplace( Writer::Object );
+        auto& writer = m_objectWriters.top();
+
+        writer.write( "version"_sr ).write( 1 );
+
+        {
+            auto metadata_writer = writer.write( "metadata"_sr ).writeObject();
+            metadata_writer.write( "name"_sr ).write( m_config->name() );
+            metadata_writer.write( "rng-seed"_sr ).write( m_config->rngSeed() );
+            metadata_writer.write( "catch2-version"_sr )
+                .write( libraryVersion() );
+            if ( m_config->testSpec().hasFilters() ) {
+                metadata_writer.write( "filters"_sr )
+                    .write( m_config->testSpec() );
+            }
+        }
+    }
+
+    JsonReporter::~JsonReporter() {
+        endListing();
+        // TODO: Ensure this closes the top level object, add asserts
+        assert( m_writers.size() == 1 && "Only the top level object should be open" );
+        assert( m_writers.top() == Writer::Object );
+        endObject();
+        m_stream << '\n' << std::flush;
+        assert( m_writers.empty() );
+    }
+
+    JsonArrayWriter& JsonReporter::startArray() {
+        m_arrayWriters.emplace( m_arrayWriters.top().writeArray() );
+        m_writers.emplace( Writer::Array );
+        return m_arrayWriters.top();
+    }
+    JsonArrayWriter& JsonReporter::startArray( StringRef key ) {
+        m_arrayWriters.emplace(
+            m_objectWriters.top().write( key ).writeArray() );
+        m_writers.emplace( Writer::Array );
+        return m_arrayWriters.top();
+    }
+
+    JsonObjectWriter& JsonReporter::startObject() {
+        m_objectWriters.emplace( m_arrayWriters.top().writeObject() );
+        m_writers.emplace( Writer::Object );
+        return m_objectWriters.top();
+    }
+    JsonObjectWriter& JsonReporter::startObject( StringRef key ) {
+        m_objectWriters.emplace(
+            m_objectWriters.top().write( key ).writeObject() );
+        m_writers.emplace( Writer::Object );
+        return m_objectWriters.top();
+    }
+
+    void JsonReporter::endObject() {
+        assert( isInside( Writer::Object ) );
+        m_objectWriters.pop();
+        m_writers.pop();
+    }
+    void JsonReporter::endArray() {
+        assert( isInside( Writer::Array ) );
+        m_arrayWriters.pop();
+        m_writers.pop();
+    }
+
+    bool JsonReporter::isInside( Writer writer ) {
+        return !m_writers.empty() && m_writers.top() == writer;
+    }
+
+    void JsonReporter::startListing() {
+        if ( !m_startedListing ) { startObject( "listings"_sr ); }
+        m_startedListing = true;
+    }
+    void JsonReporter::endListing() {
+        if ( m_startedListing ) { endObject(); }
+        m_startedListing = false;
+    }
+
+    std::string JsonReporter::getDescription() {
+        return "Outputs listings as JSON. Test listing is Work-in-Progress!";
+    }
+
+    void JsonReporter::testRunStarting( TestRunInfo const& runInfo ) {
+        StreamingReporterBase::testRunStarting( runInfo );
+        endListing();
+
+        assert( isInside( Writer::Object ) );
+        startObject( "test-run"_sr );
+        startArray( "test-cases"_sr );
+    }
+
+     static void writeCounts( JsonObjectWriter&& writer, Counts const& counts ) {
+        writer.write( "passed"_sr ).write( counts.passed );
+        writer.write( "failed"_sr ).write( counts.failed );
+        writer.write( "fail-but-ok"_sr ).write( counts.failedButOk );
+        writer.write( "skipped"_sr ).write( counts.skipped );
+    }
+
+    void JsonReporter::testRunEnded(TestRunStats const& runStats) {
+        assert( isInside( Writer::Array ) );
+        // End "test-cases"
+        endArray();
+
+        {
+            auto totals =
+                m_objectWriters.top().write( "totals"_sr ).writeObject();
+            writeCounts( totals.write( "assertions"_sr ).writeObject(),
+                         runStats.totals.assertions );
+            writeCounts( totals.write( "test-cases"_sr ).writeObject(),
+                         runStats.totals.testCases );
+        }
+
+        // End the "test-run" object
+        endObject();
+    }
+
+    void JsonReporter::testCaseStarting( TestCaseInfo const& tcInfo ) {
+        StreamingReporterBase::testCaseStarting( tcInfo );
+
+        assert( isInside( Writer::Array ) &&
+                "We should be in the 'test-cases' array" );
+        startObject();
+        // "test-info" prelude
+        {
+            auto testInfo =
+                m_objectWriters.top().write( "test-info"_sr ).writeObject();
+            // TODO: handle testName vs className!!
+            testInfo.write( "name"_sr ).write( tcInfo.name );
+            writeSourceInfo(testInfo, tcInfo.lineInfo);
+            writeTags( testInfo.write( "tags"_sr ).writeArray(), tcInfo.tags );
+            writeProperties( testInfo.write( "properties"_sr ).writeArray(),
+                             tcInfo );
+        }
+
+
+        // Start the array for individual test runs (testCasePartial pairs)
+        startArray( "runs"_sr );
+    }
+
+    void JsonReporter::testCaseEnded( TestCaseStats const& tcStats ) {
+        StreamingReporterBase::testCaseEnded( tcStats );
+
+        // We need to close the 'runs' array before finishing the test case
+        assert( isInside( Writer::Array ) );
+        endArray();
+
+        {
+            auto totals =
+                m_objectWriters.top().write( "totals"_sr ).writeObject();
+            writeCounts( totals.write( "assertions"_sr ).writeObject(),
+                         tcStats.totals.assertions );
+            // We do not write the test case totals, because there will always be just one test case here.
+            // TODO: overall "result" -> success, skip, fail here? Or in partial result?
+        }
+        // We do not write out stderr/stdout, because we instead wrote those out in partial runs
+
+        // TODO: aborting?
+
+        // And we also close this test case's object
+        assert( isInside( Writer::Object ) );
+        endObject();
+    }
+
+    void JsonReporter::testCasePartialStarting( TestCaseInfo const& /*tcInfo*/,
+                                                uint64_t index ) {
+        startObject();
+        m_objectWriters.top().write( "run-idx"_sr ).write( index );
+        startArray( "path"_sr );
+        // TODO: we want to delay most of the printing to the 'root' section
+        // TODO: childSection key name?
+    }
+
+    void JsonReporter::testCasePartialEnded( TestCaseStats const& tcStats,
+                                             uint64_t /*index*/ ) {
+        // Fixme: the top level section handles this.
+        //// path object
+        endArray();
+        if ( !tcStats.stdOut.empty() ) {
+            m_objectWriters.top()
+                .write( "captured-stdout"_sr )
+                .write( tcStats.stdOut );
+        }
+        if ( !tcStats.stdErr.empty() ) {
+            m_objectWriters.top()
+                .write( "captured-stderr"_sr )
+                .write( tcStats.stdErr );
+        }
+        {
+            auto totals =
+                m_objectWriters.top().write( "totals"_sr ).writeObject();
+            writeCounts( totals.write( "assertions"_sr ).writeObject(),
+                         tcStats.totals.assertions );
+            // We do not write the test case totals, because there will
+            // always be just one test case here.
+            // TODO: overall "result" -> success, skip, fail here? Or in
+            // partial result?
+        }
+        // TODO: aborting?
+        // run object
+        endObject();
+    }
+
+    void JsonReporter::sectionStarting( SectionInfo const& sectionInfo ) {
+        assert( isInside( Writer::Array ) &&
+                "Section should always start inside an object" );
+        // We want to nest top level sections, even though it shares name
+        // and source loc with the TEST_CASE
+        auto& sectionObject = startObject();
+        sectionObject.write( "kind"_sr ).write( "section"_sr );
+        sectionObject.write( "name"_sr ).write( sectionInfo.name );
+        writeSourceInfo( m_objectWriters.top(), sectionInfo.lineInfo );
+
+
+        // TBD: Do we want to create this event lazily? It would become
+        //      rather complex, but we could do it, and it would look
+        //      better for empty sections. OTOH, empty sections should
+        //      be rare.
+        startArray( "path"_sr );
+    }
+    void JsonReporter::sectionEnded( SectionStats const& /*sectionStats */) {
+        // End the subpath array
+        endArray();
+        // TODO: metadata
+        // TODO: what info do we have here?
+
+        // End the section object
+        endObject();
+    }
+
+    void JsonReporter::assertionStarting( AssertionInfo const& /*assertionInfo*/ ) {}
+    void JsonReporter::assertionEnded( AssertionStats const& assertionStats ) {
+        // TODO: There is lot of different things to handle here, but
+        //       we can fill it in later, after we show that the basic
+        //       outline and streaming reporter impl works well enough.
+        //if ( !m_config->includeSuccessfulResults()
+        //    && assertionStats.assertionResult.isOk() ) {
+        //    return;
+        //}
+        assert( isInside( Writer::Array ) );
+        auto assertionObject = m_arrayWriters.top().writeObject();
+
+        assertionObject.write( "kind"_sr ).write( "assertion"_sr );
+        writeSourceInfo( assertionObject,
+                         assertionStats.assertionResult.getSourceInfo() );
+        assertionObject.write( "status"_sr )
+            .write( assertionStats.assertionResult.isOk() );
+        // TODO: handling of result.
+        // TODO: messages
+        // TODO: totals?
+    }
+
+
+    void JsonReporter::benchmarkPreparing( StringRef name ) { (void)name; }
+    void JsonReporter::benchmarkStarting( BenchmarkInfo const& ) {}
+    void JsonReporter::benchmarkEnded( BenchmarkStats<> const& ) {}
+    void JsonReporter::benchmarkFailed( StringRef error ) { (void)error; }
+
+    void JsonReporter::listReporters(
+        std::vector<ReporterDescription> const& descriptions ) {
+        startListing();
+
+        auto writer =
+            m_objectWriters.top().write( "reporters"_sr ).writeArray();
+        for ( auto const& desc : descriptions ) {
+            auto desc_writer = writer.writeObject();
+            desc_writer.write( "name"_sr ).write( desc.name );
+            desc_writer.write( "description"_sr ).write( desc.description );
+        }
+    }
+    void JsonReporter::listListeners(
+        std::vector<ListenerDescription> const& descriptions ) {
+        startListing();
+
+        auto writer =
+            m_objectWriters.top().write( "listeners"_sr ).writeArray();
+
+        for ( auto const& desc : descriptions ) {
+            auto desc_writer = writer.writeObject();
+            desc_writer.write( "name"_sr ).write( desc.name );
+            desc_writer.write( "description"_sr ).write( desc.description );
+        }
+    }
+    void JsonReporter::listTests( std::vector<TestCaseHandle> const& tests ) {
+        startListing();
+
+        auto writer = m_objectWriters.top().write( "tests"_sr ).writeArray();
+
+        for ( auto const& test : tests ) {
+            auto desc_writer = writer.writeObject();
+            auto const& info = test.getTestCaseInfo();
+
+            desc_writer.write( "name"_sr ).write( info.name );
+            desc_writer.write( "class-name"_sr ).write( info.className );
+            {
+                auto tag_writer = desc_writer.write( "tags"_sr ).writeArray();
+                for ( auto const& tag : info.tags ) {
+                    tag_writer.write( tag.original );
+                }
+            }
+            writeSourceInfo( desc_writer, info.lineInfo );
+        }
+    }
+    void JsonReporter::listTags( std::vector<TagInfo> const& tags ) {
+        startListing();
+
+        auto writer = m_objectWriters.top().write( "tags"_sr ).writeArray();
+        for ( auto const& tag : tags ) {
+            auto tag_writer = writer.writeObject();
+            {
+                auto aliases_writer =
+                    tag_writer.write( "aliases"_sr ).writeArray();
+                for ( auto alias : tag.spellings ) {
+                    aliases_writer.write( alias );
+                }
+            }
+            tag_writer.write( "count"_sr ).write( tag.count );
+        }
+    }
+} // namespace Catch
+
+
+
+
+#include <cassert>
+#include <ctime>
+#include <algorithm>
+#include <iomanip>
+
+namespace Catch {
+
+    namespace {
+        std::string getCurrentTimestamp() {
+            time_t rawtime;
+            std::time(&rawtime);
+
+            std::tm timeInfo = {};
+#if defined (_MSC_VER) || defined (__MINGW32__)
+            gmtime_s(&timeInfo, &rawtime);
+#elif defined (CATCH_PLATFORM_PLAYSTATION)
+            gmtime_s(&rawtime, &timeInfo);
+#elif defined (__IAR_SYSTEMS_ICC__)
+            timeInfo = *std::gmtime(&rawtime);
+#else
+            gmtime_r(&rawtime, &timeInfo);
+#endif
+
+            auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
+            char timeStamp[timeStampSize];
+            const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";
+
+            std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
+
+            return std::string(timeStamp, timeStampSize - 1);
+        }
+
+        std::string fileNameTag(std::vector<Tag> const& tags) {
+            auto it = std::find_if(begin(tags),
+                                   end(tags),
+                                   [] (Tag const& tag) {
+                                       return tag.original.size() > 0
+                                           && tag.original[0] == '#'; });
+            if (it != tags.end()) {
+                return static_cast<std::string>(
+                    it->original.substr(1, it->original.size() - 1)
+                );
+            }
+            return std::string();
+        }
+
+        // Formats the duration in seconds to 3 decimal places.
+        // This is done because some genius defined Maven Surefire schema
+        // in a way that only accepts 3 decimal places, and tools like
+        // Jenkins use that schema for validation JUnit reporter output.
+        std::string formatDuration( double seconds ) {
+            ReusableStringStream rss;
+            rss << std::fixed << std::setprecision( 3 ) << seconds;
+            return rss.str();
+        }
+
+        static void normalizeNamespaceMarkers(std::string& str) {
+            std::size_t pos = str.find( "::" );
+            while ( pos != std::string::npos ) {
+                str.replace( pos, 2, "." );
+                pos += 1;
+                pos = str.find( "::", pos );
+            }
+        }
+
+    } // anonymous namespace
+
+    JunitReporter::JunitReporter( ReporterConfig&& _config )
+        :   CumulativeReporterBase( CATCH_MOVE(_config) ),
+            xml( m_stream )
+        {
+            m_preferences.shouldRedirectStdOut = true;
+            m_preferences.shouldReportAllAssertions = false;
+            m_shouldStoreSuccesfulAssertions = false;
+        }
+
+    std::string JunitReporter::getDescription() {
+        return "Reports test results in an XML format that looks like Ant's junitreport target";
+    }
+
+    void JunitReporter::testRunStarting( TestRunInfo const& runInfo )  {
+        CumulativeReporterBase::testRunStarting( runInfo );
+        xml.startElement( "testsuites" );
+        suiteTimer.start();
+        stdOutForSuite.clear();
+        stdErrForSuite.clear();
+        unexpectedExceptions = 0;
+    }
+
+    void JunitReporter::testCaseStarting( TestCaseInfo const& testCaseInfo ) {
+        m_okToFail = testCaseInfo.okToFail();
+    }
+
+    void JunitReporter::assertionEnded( AssertionStats const& assertionStats ) {
+        if( assertionStats.assertionResult.getResultType() == ResultWas::ThrewException && !m_okToFail )
+            unexpectedExceptions++;
+        CumulativeReporterBase::assertionEnded( assertionStats );
+    }
+
+    void JunitReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
+        stdOutForSuite += testCaseStats.stdOut;
+        stdErrForSuite += testCaseStats.stdErr;
+        CumulativeReporterBase::testCaseEnded( testCaseStats );
+    }
+
+    void JunitReporter::testRunEndedCumulative() {
+        const auto suiteTime = suiteTimer.getElapsedSeconds();
+        writeRun( *m_testRun, suiteTime );
+        xml.endElement();
+    }
+
+    void JunitReporter::writeRun( TestRunNode const& testRunNode, double suiteTime ) {
+        XmlWriter::ScopedElement e = xml.scopedElement( "testsuite" );
+
+        TestRunStats const& stats = testRunNode.value;
+        xml.writeAttribute( "name"_sr, stats.runInfo.name );
+        xml.writeAttribute( "errors"_sr, unexpectedExceptions );
+        xml.writeAttribute( "failures"_sr, stats.totals.assertions.failed-unexpectedExceptions );
+        xml.writeAttribute( "skipped"_sr, stats.totals.assertions.skipped );
+        xml.writeAttribute( "tests"_sr, stats.totals.assertions.total() );
+        xml.writeAttribute( "hostname"_sr, "tbd"_sr ); // !TBD
+        if( m_config->showDurations() == ShowDurations::Never )
+            xml.writeAttribute( "time"_sr, ""_sr );
+        else
+            xml.writeAttribute( "time"_sr, formatDuration( suiteTime ) );
+        xml.writeAttribute( "timestamp"_sr, getCurrentTimestamp() );
+
+        // Write properties
+        {
+            auto properties = xml.scopedElement("properties");
+            xml.scopedElement("property")
+                .writeAttribute("name"_sr, "random-seed"_sr)
+                .writeAttribute("value"_sr, m_config->rngSeed());
+            if (m_config->testSpec().hasFilters()) {
+                xml.scopedElement("property")
+                    .writeAttribute("name"_sr, "filters"_sr)
+                    .writeAttribute("value"_sr, m_config->testSpec());
+            }
+        }
+
+        // Write test cases
+        for( auto const& child : testRunNode.children )
+            writeTestCase( *child );
+
+        xml.scopedElement( "system-out" ).writeText( trim( stdOutForSuite ), XmlFormatting::Newline );
+        xml.scopedElement( "system-err" ).writeText( trim( stdErrForSuite ), XmlFormatting::Newline );
+    }
+
+    void JunitReporter::writeTestCase( TestCaseNode const& testCaseNode ) {
+        TestCaseStats const& stats = testCaseNode.value;
+
+        // All test cases have exactly one section - which represents the
+        // test case itself. That section may have 0-n nested sections
+        assert( testCaseNode.children.size() == 1 );
+        SectionNode const& rootSection = *testCaseNode.children.front();
+
+        std::string className =
+            static_cast<std::string>( stats.testInfo->className );
+
+        if( className.empty() ) {
+            className = fileNameTag(stats.testInfo->tags);
+            if ( className.empty() ) {
+                className = "global";
+            }
+        }
+
+        if ( !m_config->name().empty() )
+            className = static_cast<std::string>(m_config->name()) + '.' + className;
+
+        normalizeNamespaceMarkers(className);
+
+        writeSection( className, "", rootSection, stats.testInfo->okToFail() );
+    }
+
+    void JunitReporter::writeSection( std::string const& className,
+                                      std::string const& rootName,
+                                      SectionNode const& sectionNode,
+                                      bool testOkToFail) {
+        std::string name = trim( sectionNode.stats.sectionInfo.name );
+        if( !rootName.empty() )
+            name = rootName + '/' + name;
+
+        if ( sectionNode.stats.assertions.total() > 0
+           || !sectionNode.stdOut.empty()
+           || !sectionNode.stdErr.empty() ) {
+            XmlWriter::ScopedElement e = xml.scopedElement( "testcase" );
+            if( className.empty() ) {
+                xml.writeAttribute( "classname"_sr, name );
+                xml.writeAttribute( "name"_sr, "root"_sr );
+            }
+            else {
+                xml.writeAttribute( "classname"_sr, className );
+                xml.writeAttribute( "name"_sr, name );
+            }
+            xml.writeAttribute( "time"_sr, formatDuration( sectionNode.stats.durationInSeconds ) );
+            // This is not ideal, but it should be enough to mimic gtest's
+            // junit output.
+            // Ideally the JUnit reporter would also handle `skipTest`
+            // events and write those out appropriately.
+            xml.writeAttribute( "status"_sr, "run"_sr );
+
+            if (sectionNode.stats.assertions.failedButOk) {
+                xml.scopedElement("skipped")
+                    .writeAttribute("message", "TEST_CASE tagged with !mayfail");
+            }
+
+            writeAssertions( sectionNode );
+
+
+            if( !sectionNode.stdOut.empty() )
+                xml.scopedElement( "system-out" ).writeText( trim( sectionNode.stdOut ), XmlFormatting::Newline );
+            if( !sectionNode.stdErr.empty() )
+                xml.scopedElement( "system-err" ).writeText( trim( sectionNode.stdErr ), XmlFormatting::Newline );
+        }
+        for( auto const& childNode : sectionNode.childSections )
+            if( className.empty() )
+                writeSection( name, "", *childNode, testOkToFail );
+            else
+                writeSection( className, name, *childNode, testOkToFail );
+    }
+
+    void JunitReporter::writeAssertions( SectionNode const& sectionNode ) {
+        for (auto const& assertionOrBenchmark : sectionNode.assertionsAndBenchmarks) {
+            if (assertionOrBenchmark.isAssertion()) {
+                writeAssertion(assertionOrBenchmark.asAssertion());
+            }
+        }
+    }
+
+    void JunitReporter::writeAssertion( AssertionStats const& stats ) {
+        AssertionResult const& result = stats.assertionResult;
+        if ( !result.isOk() ||
+             result.getResultType() == ResultWas::ExplicitSkip ) {
+            std::string elementName;
+            switch( result.getResultType() ) {
+                case ResultWas::ThrewException:
+                case ResultWas::FatalErrorCondition:
+                    elementName = "error";
+                    break;
+                case ResultWas::ExplicitFailure:
+                case ResultWas::ExpressionFailed:
+                case ResultWas::DidntThrowException:
+                    elementName = "failure";
+                    break;
+                case ResultWas::ExplicitSkip:
+                    elementName = "skipped";
+                    break;
+                // We should never see these here:
+                case ResultWas::Info:
+                case ResultWas::Warning:
+                case ResultWas::Ok:
+                case ResultWas::Unknown:
+                case ResultWas::FailureBit:
+                case ResultWas::Exception:
+                    elementName = "internalError";
+                    break;
+            }
+
+            XmlWriter::ScopedElement e = xml.scopedElement( elementName );
+
+            xml.writeAttribute( "message"_sr, result.getExpression() );
+            xml.writeAttribute( "type"_sr, result.getTestMacroName() );
+
+            ReusableStringStream rss;
+            if ( result.getResultType() == ResultWas::ExplicitSkip ) {
+                rss << "SKIPPED\n";
+            } else {
+                rss << "FAILED" << ":\n";
+                if (result.hasExpression()) {
+                    rss << "  ";
+                    rss << result.getExpressionInMacro();
+                    rss << '\n';
+                }
+                if (result.hasExpandedExpression()) {
+                    rss << "with expansion:\n";
+                    rss << TextFlow::Column(result.getExpandedExpression()).indent(2) << '\n';
+                }
+            }
+
+            if( result.hasMessage() )
+                rss << result.getMessage() << '\n';
+            for( auto const& msg : stats.infoMessages )
+                if( msg.type == ResultWas::Info )
+                    rss << msg.message << '\n';
+
+            rss << "at " << result.getSourceInfo();
+            xml.writeText( rss.str(), XmlFormatting::Newline );
+        }
+    }
+
+} // end namespace Catch
+
+
+
+
+#include <ostream>
+
+namespace Catch {
+    void MultiReporter::updatePreferences(IEventListener const& reporterish) {
+        m_preferences.shouldRedirectStdOut |=
+            reporterish.getPreferences().shouldRedirectStdOut;
+        m_preferences.shouldReportAllAssertions |=
+            reporterish.getPreferences().shouldReportAllAssertions;
+    }
+
+    void MultiReporter::addListener( IEventListenerPtr&& listener ) {
+        updatePreferences(*listener);
+        m_reporterLikes.insert(m_reporterLikes.begin() + m_insertedListeners, CATCH_MOVE(listener) );
+        ++m_insertedListeners;
+    }
+
+    void MultiReporter::addReporter( IEventListenerPtr&& reporter ) {
+        updatePreferences(*reporter);
+
+        // We will need to output the captured stdout if there are reporters
+        // that do not want it captured.
+        // We do not consider listeners, because it is generally assumed that
+        // listeners are output-transparent, even though they can ask for stdout
+        // capture to do something with it.
+        m_haveNoncapturingReporters |= !reporter->getPreferences().shouldRedirectStdOut;
+
+        // Reporters can always be placed to the back without breaking the
+        // reporting order
+        m_reporterLikes.push_back( CATCH_MOVE( reporter ) );
+    }
+
+    void MultiReporter::noMatchingTestCases( StringRef unmatchedSpec ) {
+        for ( auto& reporterish : m_reporterLikes ) {
+            reporterish->noMatchingTestCases( unmatchedSpec );
+        }
+    }
+
+    void MultiReporter::fatalErrorEncountered( StringRef error ) {
+        for ( auto& reporterish : m_reporterLikes ) {
+            reporterish->fatalErrorEncountered( error );
+        }
+    }
+
+    void MultiReporter::reportInvalidTestSpec( StringRef arg ) {
+        for ( auto& reporterish : m_reporterLikes ) {
+            reporterish->reportInvalidTestSpec( arg );
+        }
+    }
+
+    void MultiReporter::benchmarkPreparing( StringRef name ) {
+        for (auto& reporterish : m_reporterLikes) {
+            reporterish->benchmarkPreparing(name);
+        }
+    }
+    void MultiReporter::benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) {
+        for ( auto& reporterish : m_reporterLikes ) {
+            reporterish->benchmarkStarting( benchmarkInfo );
+        }
+    }
+    void MultiReporter::benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) {
+        for ( auto& reporterish : m_reporterLikes ) {
+            reporterish->benchmarkEnded( benchmarkStats );
+        }
+    }
+
+    void MultiReporter::benchmarkFailed( StringRef error ) {
+        for (auto& reporterish : m_reporterLikes) {
+            reporterish->benchmarkFailed(error);
+        }
+    }
+
+    void MultiReporter::testRunStarting( TestRunInfo const& testRunInfo ) {
+        for ( auto& reporterish : m_reporterLikes ) {
+            reporterish->testRunStarting( testRunInfo );
+        }
+    }
+
+    void MultiReporter::testCaseStarting( TestCaseInfo const& testInfo ) {
+        for ( auto& reporterish : m_reporterLikes ) {
+            reporterish->testCaseStarting( testInfo );
+        }
+    }
+
+    void
+    MultiReporter::testCasePartialStarting( TestCaseInfo const& testInfo,
+                                                uint64_t partNumber ) {
+        for ( auto& reporterish : m_reporterLikes ) {
+            reporterish->testCasePartialStarting( testInfo, partNumber );
+        }
+    }
+
+    void MultiReporter::sectionStarting( SectionInfo const& sectionInfo ) {
+        for ( auto& reporterish : m_reporterLikes ) {
+            reporterish->sectionStarting( sectionInfo );
+        }
+    }
+
+    void MultiReporter::assertionStarting( AssertionInfo const& assertionInfo ) {
+        for ( auto& reporterish : m_reporterLikes ) {
+            reporterish->assertionStarting( assertionInfo );
+        }
+    }
+
+    void MultiReporter::assertionEnded( AssertionStats const& assertionStats ) {
+        const bool reportByDefault =
+            assertionStats.assertionResult.getResultType() != ResultWas::Ok ||
+            m_config->includeSuccessfulResults();
+
+        for ( auto & reporterish : m_reporterLikes ) {
+            if ( reportByDefault ||
+                 reporterish->getPreferences().shouldReportAllAssertions ) {
+                    reporterish->assertionEnded( assertionStats );
+            }
+        }
+    }
+
+    void MultiReporter::sectionEnded( SectionStats const& sectionStats ) {
+        for ( auto& reporterish : m_reporterLikes ) {
+            reporterish->sectionEnded( sectionStats );
+        }
+    }
+
+    void MultiReporter::testCasePartialEnded( TestCaseStats const& testStats,
+                                                  uint64_t partNumber ) {
+        if ( m_preferences.shouldRedirectStdOut &&
+             m_haveNoncapturingReporters ) {
+            if ( !testStats.stdOut.empty() ) {
+                Catch::cout() << testStats.stdOut << std::flush;
+            }
+            if ( !testStats.stdErr.empty() ) {
+                Catch::cerr() << testStats.stdErr << std::flush;
+            }
+        }
+
+        for ( auto& reporterish : m_reporterLikes ) {
+            reporterish->testCasePartialEnded( testStats, partNumber );
+        }
+    }
+
+    void MultiReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
+        for ( auto& reporterish : m_reporterLikes ) {
+            reporterish->testCaseEnded( testCaseStats );
+        }
+    }
+
+    void MultiReporter::testRunEnded( TestRunStats const& testRunStats ) {
+        for ( auto& reporterish : m_reporterLikes ) {
+            reporterish->testRunEnded( testRunStats );
+        }
+    }
+
+
+    void MultiReporter::skipTest( TestCaseInfo const& testInfo ) {
+        for ( auto& reporterish : m_reporterLikes ) {
+            reporterish->skipTest( testInfo );
+        }
+    }
+
+    void MultiReporter::listReporters(std::vector<ReporterDescription> const& descriptions) {
+        for (auto& reporterish : m_reporterLikes) {
+            reporterish->listReporters(descriptions);
+        }
+    }
+
+    void MultiReporter::listListeners(
+        std::vector<ListenerDescription> const& descriptions ) {
+        for ( auto& reporterish : m_reporterLikes ) {
+            reporterish->listListeners( descriptions );
+        }
+    }
+
+    void MultiReporter::listTests(std::vector<TestCaseHandle> const& tests) {
+        for (auto& reporterish : m_reporterLikes) {
+            reporterish->listTests(tests);
+        }
+    }
+
+    void MultiReporter::listTags(std::vector<TagInfo> const& tags) {
+        for (auto& reporterish : m_reporterLikes) {
+            reporterish->listTags(tags);
+        }
+    }
+
+} // end namespace Catch
+
+
+
+
+
+namespace Catch {
+    namespace Detail {
+
+        void registerReporterImpl( std::string const& name,
+                                   IReporterFactoryPtr reporterPtr ) {
+            CATCH_TRY {
+                getMutableRegistryHub().registerReporter(
+                    name, CATCH_MOVE( reporterPtr ) );
+            }
+            CATCH_CATCH_ALL {
+                // Do not throw when constructing global objects, instead
+                // register the exception to be processed later
+                getMutableRegistryHub().registerStartupException();
+            }
+        }
+
+        void registerListenerImpl( Detail::unique_ptr<EventListenerFactory> listenerFactory ) {
+            getMutableRegistryHub().registerListener( CATCH_MOVE(listenerFactory) );
+        }
+
+
+    } // namespace Detail
+} // namespace Catch
+
+
+
+
+#include <map>
+
+namespace Catch {
+
+    namespace {
+        std::string createMetadataString(IConfig const& config) {
+            ReusableStringStream sstr;
+            if ( config.testSpec().hasFilters() ) {
+                sstr << "filters='"
+                         << config.testSpec()
+                         << "' ";
+            }
+            sstr << "rng-seed=" << config.rngSeed();
+            return sstr.str();
+        }
+    }
+
+    void SonarQubeReporter::testRunStarting(TestRunInfo const& testRunInfo) {
+        CumulativeReporterBase::testRunStarting(testRunInfo);
+
+        xml.writeComment( createMetadataString( *m_config ) );
+        xml.startElement("testExecutions");
+        xml.writeAttribute("version"_sr, '1');
+    }
+
+    void SonarQubeReporter::writeRun( TestRunNode const& runNode ) {
+        std::map<StringRef, std::vector<TestCaseNode const*>> testsPerFile;
+
+        for ( auto const& child : runNode.children ) {
+            testsPerFile[child->value.testInfo->lineInfo.file].push_back(
+                child.get() );
+        }
+
+        for ( auto const& kv : testsPerFile ) {
+            writeTestFile( kv.first, kv.second );
+        }
+    }
+
+    void SonarQubeReporter::writeTestFile(StringRef filename, std::vector<TestCaseNode const*> const& testCaseNodes) {
+        XmlWriter::ScopedElement e = xml.scopedElement("file");
+        xml.writeAttribute("path"_sr, filename);
+
+        for (auto const& child : testCaseNodes)
+            writeTestCase(*child);
+    }
+
+    void SonarQubeReporter::writeTestCase(TestCaseNode const& testCaseNode) {
+        // All test cases have exactly one section - which represents the
+        // test case itself. That section may have 0-n nested sections
+        assert(testCaseNode.children.size() == 1);
+        SectionNode const& rootSection = *testCaseNode.children.front();
+        writeSection("", rootSection, testCaseNode.value.testInfo->okToFail());
+    }
+
+    void SonarQubeReporter::writeSection(std::string const& rootName, SectionNode const& sectionNode, bool okToFail) {
+        std::string name = trim(sectionNode.stats.sectionInfo.name);
+        if (!rootName.empty())
+            name = rootName + '/' + name;
+
+        if ( sectionNode.stats.assertions.total() > 0
+            || !sectionNode.stdOut.empty()
+            || !sectionNode.stdErr.empty() ) {
+            XmlWriter::ScopedElement e = xml.scopedElement("testCase");
+            xml.writeAttribute("name"_sr, name);
+            xml.writeAttribute("duration"_sr, static_cast<long>(sectionNode.stats.durationInSeconds * 1000));
+
+            writeAssertions(sectionNode, okToFail);
+        }
+
+        for (auto const& childNode : sectionNode.childSections)
+            writeSection(name, *childNode, okToFail);
+    }
+
+    void SonarQubeReporter::writeAssertions(SectionNode const& sectionNode, bool okToFail) {
+        for (auto const& assertionOrBenchmark : sectionNode.assertionsAndBenchmarks) {
+            if (assertionOrBenchmark.isAssertion()) {
+                writeAssertion(assertionOrBenchmark.asAssertion(), okToFail);
+            }
+        }
+    }
+
+    void SonarQubeReporter::writeAssertion(AssertionStats const& stats, bool okToFail) {
+        AssertionResult const& result = stats.assertionResult;
+        if ( !result.isOk() ||
+             result.getResultType() == ResultWas::ExplicitSkip ) {
+            std::string elementName;
+            if (okToFail) {
+                elementName = "skipped";
+            } else {
+                switch (result.getResultType()) {
+                case ResultWas::ThrewException:
+                case ResultWas::FatalErrorCondition:
+                    elementName = "error";
+                    break;
+                case ResultWas::ExplicitFailure:
+                case ResultWas::ExpressionFailed:
+                case ResultWas::DidntThrowException:
+                    elementName = "failure";
+                    break;
+                case ResultWas::ExplicitSkip:
+                    elementName = "skipped";
+                    break;
+                    // We should never see these here:
+                case ResultWas::Info:
+                case ResultWas::Warning:
+                case ResultWas::Ok:
+                case ResultWas::Unknown:
+                case ResultWas::FailureBit:
+                case ResultWas::Exception:
+                    elementName = "internalError";
+                    break;
+                }
+            }
+
+            XmlWriter::ScopedElement e = xml.scopedElement(elementName);
+
+            ReusableStringStream messageRss;
+            messageRss << result.getTestMacroName() << '(' << result.getExpression() << ')';
+            xml.writeAttribute("message"_sr, messageRss.str());
+
+            ReusableStringStream textRss;
+            if ( result.getResultType() == ResultWas::ExplicitSkip ) {
+                textRss << "SKIPPED\n";
+            } else {
+                textRss << "FAILED:\n";
+                if (result.hasExpression()) {
+                    textRss << '\t' << result.getExpressionInMacro() << '\n';
+                }
+                if (result.hasExpandedExpression()) {
+                    textRss << "with expansion:\n\t" << result.getExpandedExpression() << '\n';
+                }
+            }
+
+            if (result.hasMessage())
+                textRss << result.getMessage() << '\n';
+
+            for (auto const& msg : stats.infoMessages)
+                if (msg.type == ResultWas::Info)
+                    textRss << msg.message << '\n';
+
+            textRss << "at " << result.getSourceInfo();
+            xml.writeText(textRss.str(), XmlFormatting::Newline);
+        }
+    }
+
+} // end namespace Catch
+
+
+
+namespace Catch {
+
+    StreamingReporterBase::~StreamingReporterBase() = default;
+
+    void
+    StreamingReporterBase::testRunStarting( TestRunInfo const& _testRunInfo ) {
+        currentTestRunInfo = _testRunInfo;
+    }
+
+    void StreamingReporterBase::testRunEnded( TestRunStats const& ) {
+        currentTestCaseInfo = nullptr;
+    }
+
+} // end namespace Catch
+
+
+
+#include <algorithm>
+#include <ostream>
+
+namespace Catch {
+
+    namespace {
+        // Yes, this has to be outside the class and namespaced by naming.
+        // Making older compiler happy is hard.
+        static constexpr StringRef tapFailedString = "not ok"_sr;
+        static constexpr StringRef tapPassedString = "ok"_sr;
+        static constexpr Colour::Code tapDimColour = Colour::FileName;
+
+        class TapAssertionPrinter {
+        public:
+            TapAssertionPrinter& operator= (TapAssertionPrinter const&) = delete;
+            TapAssertionPrinter(TapAssertionPrinter const&) = delete;
+            TapAssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, std::size_t _counter, ColourImpl* colour_)
+                : stream(_stream)
+                , result(_stats.assertionResult)
+                , messages(_stats.infoMessages)
+                , itMessage(_stats.infoMessages.begin())
+                , printInfoMessages(true)
+                , counter(_counter)
+                , colourImpl( colour_ ) {}
+
+            void print() {
+                itMessage = messages.begin();
+
+                switch (result.getResultType()) {
+                case ResultWas::Ok:
+                    printResultType(tapPassedString);
+                    printOriginalExpression();
+                    printReconstructedExpression();
+                    if (!result.hasExpression())
+                        printRemainingMessages(Colour::None);
+                    else
+                        printRemainingMessages();
+                    break;
+                case ResultWas::ExpressionFailed:
+                    if (result.isOk()) {
+                        printResultType(tapPassedString);
+                    } else {
+                        printResultType(tapFailedString);
+                    }
+                    printOriginalExpression();
+                    printReconstructedExpression();
+                    if (result.isOk()) {
+                        printIssue(" # TODO");
+                    }
+                    printRemainingMessages();
+                    break;
+                case ResultWas::ThrewException:
+                    printResultType(tapFailedString);
+                    printIssue("unexpected exception with message:"_sr);
+                    printMessage();
+                    printExpressionWas();
+                    printRemainingMessages();
+                    break;
+                case ResultWas::FatalErrorCondition:
+                    printResultType(tapFailedString);
+                    printIssue("fatal error condition with message:"_sr);
+                    printMessage();
+                    printExpressionWas();
+                    printRemainingMessages();
+                    break;
+                case ResultWas::DidntThrowException:
+                    printResultType(tapFailedString);
+                    printIssue("expected exception, got none"_sr);
+                    printExpressionWas();
+                    printRemainingMessages();
+                    break;
+                case ResultWas::Info:
+                    printResultType("info"_sr);
+                    printMessage();
+                    printRemainingMessages();
+                    break;
+                case ResultWas::Warning:
+                    printResultType("warning"_sr);
+                    printMessage();
+                    printRemainingMessages();
+                    break;
+                case ResultWas::ExplicitFailure:
+                    printResultType(tapFailedString);
+                    printIssue("explicitly"_sr);
+                    printRemainingMessages(Colour::None);
+                    break;
+                case ResultWas::ExplicitSkip:
+                    printResultType(tapPassedString);
+                    printIssue(" # SKIP"_sr);
+                    printMessage();
+                    printRemainingMessages();
+                    break;
+                    // These cases are here to prevent compiler warnings
+                case ResultWas::Unknown:
+                case ResultWas::FailureBit:
+                case ResultWas::Exception:
+                    printResultType("** internal error **"_sr);
+                    break;
+                }
+            }
+
+        private:
+            void printResultType(StringRef passOrFail) const {
+                if (!passOrFail.empty()) {
+                    stream << passOrFail << ' ' << counter << " -";
+                }
+            }
+
+            void printIssue(StringRef issue) const {
+                stream << ' ' << issue;
+            }
+
+            void printExpressionWas() {
+                if (result.hasExpression()) {
+                    stream << ';';
+                    stream << colourImpl->guardColour( tapDimColour )
+                           << " expression was:";
+                    printOriginalExpression();
+                }
+            }
+
+            void printOriginalExpression() const {
+                if (result.hasExpression()) {
+                    stream << ' ' << result.getExpression();
+                }
+            }
+
+            void printReconstructedExpression() const {
+                if (result.hasExpandedExpression()) {
+                    stream << colourImpl->guardColour( tapDimColour ) << " for: ";
+
+                    std::string expr = result.getExpandedExpression();
+                    std::replace(expr.begin(), expr.end(), '\n', ' ');
+                    stream << expr;
+                }
+            }
+
+            void printMessage() {
+                if (itMessage != messages.end()) {
+                    stream << " '" << itMessage->message << '\'';
+                    ++itMessage;
+                }
+            }
+
+            void printRemainingMessages(Colour::Code colour = tapDimColour) {
+                if (itMessage == messages.end()) {
+                    return;
+                }
+
+                // using messages.end() directly (or auto) yields compilation error:
+                std::vector<MessageInfo>::const_iterator itEnd = messages.end();
+                const std::size_t N = static_cast<std::size_t>(itEnd - itMessage);
+
+                stream << colourImpl->guardColour( colour ) << " with "
+                       << pluralise( N, "message"_sr ) << ':';
+
+                for (; itMessage != itEnd; ) {
+                    // If this assertion is a warning ignore any INFO messages
+                    if (printInfoMessages || itMessage->type != ResultWas::Info) {
+                        stream << " '" << itMessage->message << '\'';
+                        if (++itMessage != itEnd) {
+                            stream << colourImpl->guardColour(tapDimColour) << " and";
+                        }
+                    }
+                }
+            }
+
+        private:
+            std::ostream& stream;
+            AssertionResult const& result;
+            std::vector<MessageInfo> const& messages;
+            std::vector<MessageInfo>::const_iterator itMessage;
+            bool printInfoMessages;
+            std::size_t counter;
+            ColourImpl* colourImpl;
+        };
+
+    } // End anonymous namespace
+
+    void TAPReporter::testRunStarting( TestRunInfo const& ) {
+        if ( m_config->testSpec().hasFilters() ) {
+            m_stream << "# filters: " << m_config->testSpec() << '\n';
+        }
+        m_stream << "# rng-seed: " << m_config->rngSeed() << '\n';
+    }
+
+    void TAPReporter::noMatchingTestCases( StringRef unmatchedSpec ) {
+        m_stream << "# No test cases matched '" << unmatchedSpec << "'\n";
+    }
+
+    void TAPReporter::assertionEnded(AssertionStats const& _assertionStats) {
+        ++counter;
+
+        m_stream << "# " << currentTestCaseInfo->name << '\n';
+        TapAssertionPrinter printer(m_stream, _assertionStats, counter, m_colour.get());
+        printer.print();
+
+        m_stream << '\n' << std::flush;
+    }
+
+    void TAPReporter::testRunEnded(TestRunStats const& _testRunStats) {
+        m_stream << "1.." << _testRunStats.totals.assertions.total();
+        if (_testRunStats.totals.testCases.total() == 0) {
+            m_stream << " # Skipped: No tests ran.";
+        }
+        m_stream << "\n\n" << std::flush;
+        StreamingReporterBase::testRunEnded(_testRunStats);
+    }
+
+
+
+
+} // end namespace Catch
+
+
+
+
+#include <cassert>
+#include <ostream>
+
+namespace Catch {
+
+    namespace {
+        // if string has a : in first line will set indent to follow it on
+        // subsequent lines
+        void printHeaderString(std::ostream& os, std::string const& _string, std::size_t indent = 0) {
+            std::size_t i = _string.find(": ");
+            if (i != std::string::npos)
+                i += 2;
+            else
+                i = 0;
+            os << TextFlow::Column(_string)
+                  .indent(indent + i)
+                  .initialIndent(indent) << '\n';
+        }
+
+        std::string escape(StringRef str) {
+            std::string escaped = static_cast<std::string>(str);
+            replaceInPlace(escaped, "|", "||");
+            replaceInPlace(escaped, "'", "|'");
+            replaceInPlace(escaped, "\n", "|n");
+            replaceInPlace(escaped, "\r", "|r");
+            replaceInPlace(escaped, "[", "|[");
+            replaceInPlace(escaped, "]", "|]");
+            return escaped;
+        }
+    } // end anonymous namespace
+
+
+    TeamCityReporter::~TeamCityReporter() = default;
+
+    void TeamCityReporter::testRunStarting( TestRunInfo const& runInfo ) {
+        m_stream << "##teamcity[testSuiteStarted name='" << escape( runInfo.name )
+               << "']\n";
+    }
+
+    void TeamCityReporter::testRunEnded( TestRunStats const& runStats ) {
+        m_stream << "##teamcity[testSuiteFinished name='"
+               << escape( runStats.runInfo.name ) << "']\n";
+    }
+
+    void TeamCityReporter::assertionEnded(AssertionStats const& assertionStats) {
+        AssertionResult const& result = assertionStats.assertionResult;
+        if ( !result.isOk() ||
+             result.getResultType() == ResultWas::ExplicitSkip ) {
+
+            ReusableStringStream msg;
+            if (!m_headerPrintedForThisSection)
+                printSectionHeader(msg.get());
+            m_headerPrintedForThisSection = true;
+
+            msg << result.getSourceInfo() << '\n';
+
+            switch (result.getResultType()) {
+            case ResultWas::ExpressionFailed:
+                msg << "expression failed";
+                break;
+            case ResultWas::ThrewException:
+                msg << "unexpected exception";
+                break;
+            case ResultWas::FatalErrorCondition:
+                msg << "fatal error condition";
+                break;
+            case ResultWas::DidntThrowException:
+                msg << "no exception was thrown where one was expected";
+                break;
+            case ResultWas::ExplicitFailure:
+                msg << "explicit failure";
+                break;
+            case ResultWas::ExplicitSkip:
+                msg << "explicit skip";
+                break;
+
+                // We shouldn't get here because of the isOk() test
+            case ResultWas::Ok:
+            case ResultWas::Info:
+            case ResultWas::Warning:
+                CATCH_ERROR("Internal error in TeamCity reporter");
+                // These cases are here to prevent compiler warnings
+            case ResultWas::Unknown:
+            case ResultWas::FailureBit:
+            case ResultWas::Exception:
+                CATCH_ERROR("Not implemented");
+            }
+            if (assertionStats.infoMessages.size() == 1)
+                msg << " with message:";
+            if (assertionStats.infoMessages.size() > 1)
+                msg << " with messages:";
+            for (auto const& messageInfo : assertionStats.infoMessages)
+                msg << "\n  \"" << messageInfo.message << '"';
+
+
+            if (result.hasExpression()) {
+                msg <<
+                    "\n  " << result.getExpressionInMacro() << "\n"
+                    "with expansion:\n"
+                    "  " << result.getExpandedExpression() << '\n';
+            }
+
+            if ( result.getResultType() == ResultWas::ExplicitSkip ) {
+                m_stream << "##teamcity[testIgnored";
+            } else if ( currentTestCaseInfo->okToFail() ) {
+                msg << "- failure ignore as test marked as 'ok to fail'\n";
+                m_stream << "##teamcity[testIgnored";
+            } else {
+                m_stream << "##teamcity[testFailed";
+            }
+            m_stream << " name='" << escape( currentTestCaseInfo->name ) << '\''
+                     << " message='" << escape( msg.str() ) << '\'' << "]\n";
+        }
+        m_stream.flush();
+    }
+
+    void TeamCityReporter::testCaseStarting(TestCaseInfo const& testInfo) {
+        m_testTimer.start();
+        StreamingReporterBase::testCaseStarting(testInfo);
+        m_stream << "##teamcity[testStarted name='"
+            << escape(testInfo.name) << "']\n";
+        m_stream.flush();
+    }
+
+    void TeamCityReporter::testCaseEnded(TestCaseStats const& testCaseStats) {
+        StreamingReporterBase::testCaseEnded(testCaseStats);
+        auto const& testCaseInfo = *testCaseStats.testInfo;
+        if (!testCaseStats.stdOut.empty())
+            m_stream << "##teamcity[testStdOut name='"
+            << escape(testCaseInfo.name)
+            << "' out='" << escape(testCaseStats.stdOut) << "']\n";
+        if (!testCaseStats.stdErr.empty())
+            m_stream << "##teamcity[testStdErr name='"
+            << escape(testCaseInfo.name)
+            << "' out='" << escape(testCaseStats.stdErr) << "']\n";
+        m_stream << "##teamcity[testFinished name='"
+            << escape(testCaseInfo.name) << "' duration='"
+            << m_testTimer.getElapsedMilliseconds() << "']\n";
+        m_stream.flush();
+    }
+
+    void TeamCityReporter::printSectionHeader(std::ostream& os) {
+        assert(!m_sectionStack.empty());
+
+        if (m_sectionStack.size() > 1) {
+            os << lineOfChars('-') << '\n';
+
+            std::vector<SectionInfo>::const_iterator
+                it = m_sectionStack.begin() + 1, // Skip first section (test case)
+                itEnd = m_sectionStack.end();
+            for (; it != itEnd; ++it)
+                printHeaderString(os, it->name);
+            os << lineOfChars('-') << '\n';
+        }
+
+        SourceLineInfo lineInfo = m_sectionStack.front().lineInfo;
+
+        os << lineInfo << '\n';
+        os << lineOfChars('.') << "\n\n";
+    }
+
+} // end namespace Catch
+
+
+
+
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
+                              // Note that 4062 (not all labels are handled
+                              // and default is missing) is enabled
+#endif
+
+namespace Catch {
+    XmlReporter::XmlReporter( ReporterConfig&& _config )
+    :   StreamingReporterBase( CATCH_MOVE(_config) ),
+        m_xml(m_stream)
+    {
+        m_preferences.shouldRedirectStdOut = true;
+        m_preferences.shouldReportAllAssertions = true;
+    }
+
+    XmlReporter::~XmlReporter() = default;
+
+    std::string XmlReporter::getDescription() {
+        return "Reports test results as an XML document";
+    }
+
+    std::string XmlReporter::getStylesheetRef() const {
+        return std::string();
+    }
+
+    void XmlReporter::writeSourceInfo( SourceLineInfo const& sourceInfo ) {
+        m_xml
+            .writeAttribute( "filename"_sr, sourceInfo.file )
+            .writeAttribute( "line"_sr, sourceInfo.line );
+    }
+
+    void XmlReporter::testRunStarting( TestRunInfo const& testInfo ) {
+        StreamingReporterBase::testRunStarting( testInfo );
+        std::string stylesheetRef = getStylesheetRef();
+        if( !stylesheetRef.empty() )
+            m_xml.writeStylesheetRef( stylesheetRef );
+        m_xml.startElement("Catch2TestRun")
+             .writeAttribute("name"_sr, m_config->name())
+             .writeAttribute("rng-seed"_sr, m_config->rngSeed())
+             .writeAttribute("xml-format-version"_sr, 3)
+             .writeAttribute("catch2-version"_sr, libraryVersion());
+        if ( m_config->testSpec().hasFilters() ) {
+            m_xml.writeAttribute( "filters"_sr, m_config->testSpec() );
+        }
+    }
+
+    void XmlReporter::testCaseStarting( TestCaseInfo const& testInfo ) {
+        StreamingReporterBase::testCaseStarting(testInfo);
+        m_xml.startElement( "TestCase" )
+            .writeAttribute( "name"_sr, trim( StringRef(testInfo.name) ) )
+            .writeAttribute( "tags"_sr, testInfo.tagsAsString() );
+
+        writeSourceInfo( testInfo.lineInfo );
+
+        if ( m_config->showDurations() == ShowDurations::Always )
+            m_testCaseTimer.start();
+        m_xml.ensureTagClosed();
+    }
+
+    void XmlReporter::sectionStarting( SectionInfo const& sectionInfo ) {
+        StreamingReporterBase::sectionStarting( sectionInfo );
+        if( m_sectionDepth++ > 0 ) {
+            m_xml.startElement( "Section" )
+                .writeAttribute( "name"_sr, trim( StringRef(sectionInfo.name) ) );
+            writeSourceInfo( sectionInfo.lineInfo );
+            m_xml.ensureTagClosed();
+        }
+    }
+
+    void XmlReporter::assertionStarting( AssertionInfo const& ) { }
+
+    void XmlReporter::assertionEnded( AssertionStats const& assertionStats ) {
+
+        AssertionResult const& result = assertionStats.assertionResult;
+
+        bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
+
+        if( includeResults || result.getResultType() == ResultWas::Warning ) {
+            // Print any info messages in <Info> tags.
+            for( auto const& msg : assertionStats.infoMessages ) {
+                if( msg.type == ResultWas::Info && includeResults ) {
+                    auto t = m_xml.scopedElement( "Info" );
+                    writeSourceInfo( msg.lineInfo );
+                    t.writeText( msg.message );
+                } else if ( msg.type == ResultWas::Warning ) {
+                    auto t = m_xml.scopedElement( "Warning" );
+                    writeSourceInfo( msg.lineInfo );
+                    t.writeText( msg.message );
+                }
+            }
+        }
+
+        // Drop out if result was successful but we're not printing them.
+        if ( !includeResults && result.getResultType() != ResultWas::Warning &&
+             result.getResultType() != ResultWas::ExplicitSkip ) {
+            return;
+        }
+
+        // Print the expression if there is one.
+        if( result.hasExpression() ) {
+            m_xml.startElement( "Expression" )
+                .writeAttribute( "success"_sr, result.succeeded() )
+                .writeAttribute( "type"_sr, result.getTestMacroName() );
+
+            writeSourceInfo( result.getSourceInfo() );
+
+            m_xml.scopedElement( "Original" )
+                .writeText( result.getExpression() );
+            m_xml.scopedElement( "Expanded" )
+                .writeText( result.getExpandedExpression() );
+        }
+
+        // And... Print a result applicable to each result type.
+        switch( result.getResultType() ) {
+            case ResultWas::ThrewException:
+                m_xml.startElement( "Exception" );
+                writeSourceInfo( result.getSourceInfo() );
+                m_xml.writeText( result.getMessage() );
+                m_xml.endElement();
+                break;
+            case ResultWas::FatalErrorCondition:
+                m_xml.startElement( "FatalErrorCondition" );
+                writeSourceInfo( result.getSourceInfo() );
+                m_xml.writeText( result.getMessage() );
+                m_xml.endElement();
+                break;
+            case ResultWas::Info:
+                m_xml.scopedElement( "Info" )
+                     .writeText( result.getMessage() );
+                break;
+            case ResultWas::Warning:
+                // Warning will already have been written
+                break;
+            case ResultWas::ExplicitFailure:
+                m_xml.startElement( "Failure" );
+                writeSourceInfo( result.getSourceInfo() );
+                m_xml.writeText( result.getMessage() );
+                m_xml.endElement();
+                break;
+            case ResultWas::ExplicitSkip:
+                m_xml.startElement( "Skip" );
+                writeSourceInfo( result.getSourceInfo() );
+                m_xml.writeText( result.getMessage() );
+                m_xml.endElement();
+                break;
+            default:
+                break;
+        }
+
+        if( result.hasExpression() )
+            m_xml.endElement();
+    }
+
+    void XmlReporter::sectionEnded( SectionStats const& sectionStats ) {
+        StreamingReporterBase::sectionEnded( sectionStats );
+        if ( --m_sectionDepth > 0 ) {
+            {
+                XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" );
+                e.writeAttribute( "successes"_sr, sectionStats.assertions.passed );
+                e.writeAttribute( "failures"_sr, sectionStats.assertions.failed );
+                e.writeAttribute( "expectedFailures"_sr, sectionStats.assertions.failedButOk );
+                e.writeAttribute( "skipped"_sr, sectionStats.assertions.skipped > 0 );
+
+                if ( m_config->showDurations() == ShowDurations::Always )
+                    e.writeAttribute( "durationInSeconds"_sr, sectionStats.durationInSeconds );
+            }
+            // Ends assertion tag
+            m_xml.endElement();
+        }
+    }
+
+    void XmlReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
+        StreamingReporterBase::testCaseEnded( testCaseStats );
+        XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResult" );
+        e.writeAttribute( "success"_sr, testCaseStats.totals.assertions.allOk() );
+        e.writeAttribute( "skips"_sr, testCaseStats.totals.assertions.skipped );
+
+        if ( m_config->showDurations() == ShowDurations::Always )
+            e.writeAttribute( "durationInSeconds"_sr, m_testCaseTimer.getElapsedSeconds() );
+        if( !testCaseStats.stdOut.empty() )
+            m_xml.scopedElement( "StdOut" ).writeText( trim( StringRef(testCaseStats.stdOut) ), XmlFormatting::Newline );
+        if( !testCaseStats.stdErr.empty() )
+            m_xml.scopedElement( "StdErr" ).writeText( trim( StringRef(testCaseStats.stdErr) ), XmlFormatting::Newline );
+
+        m_xml.endElement();
+    }
+
+    void XmlReporter::testRunEnded( TestRunStats const& testRunStats ) {
+        StreamingReporterBase::testRunEnded( testRunStats );
+        m_xml.scopedElement( "OverallResults" )
+            .writeAttribute( "successes"_sr, testRunStats.totals.assertions.passed )
+            .writeAttribute( "failures"_sr, testRunStats.totals.assertions.failed )
+            .writeAttribute( "expectedFailures"_sr, testRunStats.totals.assertions.failedButOk )
+            .writeAttribute( "skips"_sr, testRunStats.totals.assertions.skipped );
+        m_xml.scopedElement( "OverallResultsCases")
+            .writeAttribute( "successes"_sr, testRunStats.totals.testCases.passed )
+            .writeAttribute( "failures"_sr, testRunStats.totals.testCases.failed )
+            .writeAttribute( "expectedFailures"_sr, testRunStats.totals.testCases.failedButOk )
+            .writeAttribute( "skips"_sr, testRunStats.totals.testCases.skipped );
+        m_xml.endElement();
+    }
+
+    void XmlReporter::benchmarkPreparing( StringRef name ) {
+        m_xml.startElement("BenchmarkResults")
+             .writeAttribute("name"_sr, name);
+    }
+
+    void XmlReporter::benchmarkStarting(BenchmarkInfo const &info) {
+        m_xml.writeAttribute("samples"_sr, info.samples)
+            .writeAttribute("resamples"_sr, info.resamples)
+            .writeAttribute("iterations"_sr, info.iterations)
+            .writeAttribute("clockResolution"_sr, info.clockResolution)
+            .writeAttribute("estimatedDuration"_sr, info.estimatedDuration)
+            .writeComment("All values in nano seconds"_sr);
+    }
+
+    void XmlReporter::benchmarkEnded(BenchmarkStats<> const& benchmarkStats) {
+        m_xml.scopedElement("mean")
+            .writeAttribute("value"_sr, benchmarkStats.mean.point.count())
+            .writeAttribute("lowerBound"_sr, benchmarkStats.mean.lower_bound.count())
+            .writeAttribute("upperBound"_sr, benchmarkStats.mean.upper_bound.count())
+            .writeAttribute("ci"_sr, benchmarkStats.mean.confidence_interval);
+        m_xml.scopedElement("standardDeviation")
+            .writeAttribute("value"_sr, benchmarkStats.standardDeviation.point.count())
+            .writeAttribute("lowerBound"_sr, benchmarkStats.standardDeviation.lower_bound.count())
+            .writeAttribute("upperBound"_sr, benchmarkStats.standardDeviation.upper_bound.count())
+            .writeAttribute("ci"_sr, benchmarkStats.standardDeviation.confidence_interval);
+        m_xml.scopedElement("outliers")
+            .writeAttribute("variance"_sr, benchmarkStats.outlierVariance)
+            .writeAttribute("lowMild"_sr, benchmarkStats.outliers.low_mild)
+            .writeAttribute("lowSevere"_sr, benchmarkStats.outliers.low_severe)
+            .writeAttribute("highMild"_sr, benchmarkStats.outliers.high_mild)
+            .writeAttribute("highSevere"_sr, benchmarkStats.outliers.high_severe);
+        m_xml.endElement();
+    }
+
+    void XmlReporter::benchmarkFailed(StringRef error) {
+        m_xml.scopedElement("failed").
+            writeAttribute("message"_sr, error);
+        m_xml.endElement();
+    }
+
+    void XmlReporter::listReporters(std::vector<ReporterDescription> const& descriptions) {
+        auto outerTag = m_xml.scopedElement("AvailableReporters");
+        for (auto const& reporter : descriptions) {
+            auto inner = m_xml.scopedElement("Reporter");
+            m_xml.startElement("Name", XmlFormatting::Indent)
+                 .writeText(reporter.name, XmlFormatting::None)
+                 .endElement(XmlFormatting::Newline);
+            m_xml.startElement("Description", XmlFormatting::Indent)
+                 .writeText(reporter.description, XmlFormatting::None)
+                 .endElement(XmlFormatting::Newline);
+        }
+    }
+
+    void XmlReporter::listListeners(std::vector<ListenerDescription> const& descriptions) {
+        auto outerTag = m_xml.scopedElement( "RegisteredListeners" );
+        for ( auto const& listener : descriptions ) {
+            auto inner = m_xml.scopedElement( "Listener" );
+            m_xml.startElement( "Name", XmlFormatting::Indent )
+                .writeText( listener.name, XmlFormatting::None )
+                .endElement( XmlFormatting::Newline );
+            m_xml.startElement( "Description", XmlFormatting::Indent )
+                .writeText( listener.description, XmlFormatting::None )
+                .endElement( XmlFormatting::Newline );
+        }
+    }
+
+    void XmlReporter::listTests(std::vector<TestCaseHandle> const& tests) {
+        auto outerTag = m_xml.scopedElement("MatchingTests");
+        for (auto const& test : tests) {
+            auto innerTag = m_xml.scopedElement("TestCase");
+            auto const& testInfo = test.getTestCaseInfo();
+            m_xml.startElement("Name", XmlFormatting::Indent)
+                 .writeText(testInfo.name, XmlFormatting::None)
+                 .endElement(XmlFormatting::Newline);
+            m_xml.startElement("ClassName", XmlFormatting::Indent)
+                 .writeText(testInfo.className, XmlFormatting::None)
+                 .endElement(XmlFormatting::Newline);
+            m_xml.startElement("Tags", XmlFormatting::Indent)
+                 .writeText(testInfo.tagsAsString(), XmlFormatting::None)
+                 .endElement(XmlFormatting::Newline);
+
+            auto sourceTag = m_xml.scopedElement("SourceInfo");
+            m_xml.startElement("File", XmlFormatting::Indent)
+                 .writeText(testInfo.lineInfo.file, XmlFormatting::None)
+                 .endElement(XmlFormatting::Newline);
+            m_xml.startElement("Line", XmlFormatting::Indent)
+                 .writeText(std::to_string(testInfo.lineInfo.line), XmlFormatting::None)
+                 .endElement(XmlFormatting::Newline);
+        }
+    }
+
+    void XmlReporter::listTags(std::vector<TagInfo> const& tags) {
+        auto outerTag = m_xml.scopedElement("TagsFromMatchingTests");
+        for (auto const& tag : tags) {
+            auto innerTag = m_xml.scopedElement("Tag");
+            m_xml.startElement("Count", XmlFormatting::Indent)
+                 .writeText(std::to_string(tag.count), XmlFormatting::None)
+                 .endElement(XmlFormatting::Newline);
+            auto aliasTag = m_xml.scopedElement("Aliases");
+            for (auto const& alias : tag.spellings) {
+                m_xml.startElement("Alias", XmlFormatting::Indent)
+                     .writeText(alias, XmlFormatting::None)
+                     .endElement(XmlFormatting::Newline);
+            }
+        }
+    }
+
+} // end namespace Catch
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
diff --git a/tests/catch_amalgamated.hpp b/tests/catch_amalgamated.hpp
new file mode 100644
index 0000000000..815db1df40
--- /dev/null
+++ b/tests/catch_amalgamated.hpp
@@ -0,0 +1,14106 @@
+
+//              Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+//   (See accompanying file LICENSE.txt or copy at
+//        https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+
+//  Catch v3.7.1
+//  Generated: 2024-09-17 10:36:40.974985
+//  ----------------------------------------------------------
+//  This file is an amalgamation of multiple different files.
+//  You probably shouldn't edit it directly.
+//  ----------------------------------------------------------
+#ifndef CATCH_AMALGAMATED_HPP_INCLUDED
+#define CATCH_AMALGAMATED_HPP_INCLUDED
+
+
+/** \file
+ * This is a convenience header for Catch2. It includes **all** of Catch2 headers.
+ *
+ * Generally the Catch2 users should use specific includes they need,
+ * but this header can be used instead for ease-of-experimentation, or
+ * just plain convenience, at the cost of (significantly) increased
+ * compilation times.
+ *
+ * When a new header is added to either the top level folder, or to the
+ * corresponding internal subfolder, it should be added here. Headers
+ * added to the various subparts (e.g. matchers, generators, etc...),
+ * should go their respective catch-all headers.
+ */
+
+#ifndef CATCH_ALL_HPP_INCLUDED
+#define CATCH_ALL_HPP_INCLUDED
+
+
+
+/** \file
+ * This is a convenience header for Catch2's benchmarking. It includes
+ * **all** of Catch2 headers related to benchmarking.
+ *
+ * Generally the Catch2 users should use specific includes they need,
+ * but this header can be used instead for ease-of-experimentation, or
+ * just plain convenience, at the cost of (significantly) increased
+ * compilation times.
+ *
+ * When a new header is added to either the `benchmark` folder, or to
+ * the corresponding internal (detail) subfolder, it should be added here.
+ */
+
+#ifndef CATCH_BENCHMARK_ALL_HPP_INCLUDED
+#define CATCH_BENCHMARK_ALL_HPP_INCLUDED
+
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_BENCHMARK_HPP_INCLUDED
+#define CATCH_BENCHMARK_HPP_INCLUDED
+
+
+
+#ifndef CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED
+#define CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED
+
+// Detect a number of compiler features - by compiler
+// The following features are defined:
+//
+// CATCH_CONFIG_WINDOWS_SEH : is Windows SEH supported?
+// CATCH_CONFIG_POSIX_SIGNALS : are POSIX signals supported?
+// CATCH_CONFIG_DISABLE_EXCEPTIONS : Are exceptions enabled?
+// ****************
+// Note to maintainers: if new toggles are added please document them
+// in configuration.md, too
+// ****************
+
+// In general each macro has a _NO_<feature name> form
+// (e.g. CATCH_CONFIG_NO_POSIX_SIGNALS) which disables the feature.
+// Many features, at point of detection, define an _INTERNAL_ macro, so they
+// can be combined, en-mass, with the _NO_ forms later.
+
+
+
+#ifndef CATCH_PLATFORM_HPP_INCLUDED
+#define CATCH_PLATFORM_HPP_INCLUDED
+
+// See e.g.:
+// https://opensource.apple.com/source/CarbonHeaders/CarbonHeaders-18.1/TargetConditionals.h.auto.html
+#ifdef __APPLE__
+#  ifndef __has_extension
+#    define __has_extension(x) 0
+#  endif
+#  include <TargetConditionals.h>
+#  if (defined(TARGET_OS_OSX) && TARGET_OS_OSX == 1) || \
+      (defined(TARGET_OS_MAC) && TARGET_OS_MAC == 1)
+#    define CATCH_PLATFORM_MAC
+#  elif (defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE == 1)
+#    define CATCH_PLATFORM_IPHONE
+#  endif
+
+#elif defined(linux) || defined(__linux) || defined(__linux__)
+#  define CATCH_PLATFORM_LINUX
+
+#elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) || defined(__MINGW32__)
+#  define CATCH_PLATFORM_WINDOWS
+
+#  if defined( WINAPI_FAMILY ) && ( WINAPI_FAMILY == WINAPI_FAMILY_APP )
+#      define CATCH_PLATFORM_WINDOWS_UWP
+#  endif
+
+#elif defined(__ORBIS__) || defined(__PROSPERO__)
+#  define CATCH_PLATFORM_PLAYSTATION
+
+#endif
+
+#endif // CATCH_PLATFORM_HPP_INCLUDED
+
+#ifdef __cplusplus
+
+#  if (__cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
+#    define CATCH_CPP17_OR_GREATER
+#  endif
+
+#  if (__cplusplus >= 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L)
+#    define CATCH_CPP20_OR_GREATER
+#  endif
+
+#endif
+
+// Only GCC compiler should be used in this block, so other compilers trying to
+// mask themselves as GCC should be ignored.
+#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC) && !defined(__CUDACC__) && !defined(__LCC__) && !defined(__NVCOMPILER)
+#    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "GCC diagnostic push" )
+#    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  _Pragma( "GCC diagnostic pop" )
+
+// This only works on GCC 9+. so we have to also add a global suppression of Wparentheses
+// for older versions of GCC.
+#    define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
+         _Pragma( "GCC diagnostic ignored \"-Wparentheses\"" )
+
+#    define CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT \
+         _Pragma( "GCC diagnostic ignored \"-Wunused-result\"" )
+
+#    define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+         _Pragma( "GCC diagnostic ignored \"-Wunused-variable\"" )
+
+#    define CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
+         _Pragma( "GCC diagnostic ignored \"-Wuseless-cast\"" )
+
+#    define CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS \
+         _Pragma( "GCC diagnostic ignored \"-Wshadow\"" )
+
+#    define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__)
+
+#endif
+
+#if defined(__NVCOMPILER)
+#    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "diag push" )
+#    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  _Pragma( "diag pop" )
+#    define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS _Pragma( "diag_suppress declared_but_not_referenced" )
+#endif
+
+#if defined(__CUDACC__) && !defined(__clang__)
+#  ifdef __NVCC_DIAG_PRAGMA_SUPPORT__
+// New pragmas introduced in CUDA 11.5+
+#    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "nv_diagnostic push" )
+#    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  _Pragma( "nv_diagnostic pop" )
+#    define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS _Pragma( "nv_diag_suppress 177" )
+#  else
+#    define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS _Pragma( "diag_suppress 177" )
+#  endif
+#endif
+
+// clang-cl defines _MSC_VER as well as __clang__, which could cause the
+// start/stop internal suppression macros to be double defined.
+#if defined(__clang__) && !defined(_MSC_VER)
+
+#    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "clang diagnostic push" )
+#    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  _Pragma( "clang diagnostic pop" )
+
+#endif // __clang__ && !_MSC_VER
+
+#if defined(__clang__)
+
+// As of this writing, IBM XL's implementation of __builtin_constant_p has a bug
+// which results in calls to destructors being emitted for each temporary,
+// without a matching initialization. In practice, this can result in something
+// like `std::string::~string` being called on an uninitialized value.
+//
+// For example, this code will likely segfault under IBM XL:
+// ```
+// REQUIRE(std::string("12") + "34" == "1234")
+// ```
+//
+// Similarly, NVHPC's implementation of `__builtin_constant_p` has a bug which
+// results in calls to the immediately evaluated lambda expressions to be
+// reported as unevaluated lambdas.
+// https://developer.nvidia.com/nvidia_bug/3321845.
+//
+// Therefore, `CATCH_INTERNAL_IGNORE_BUT_WARN` is not implemented.
+#  if !defined(__ibmxl__) && !defined(__CUDACC__) && !defined( __NVCOMPILER )
+#    define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__) /* NOLINT(cppcoreguidelines-pro-type-vararg, hicpp-vararg) */
+#  endif
+
+
+#    define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) \
+         _Pragma( "clang diagnostic ignored \"-Wglobal-constructors\"")
+
+#    define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wparentheses\"" )
+
+#    define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wunused-variable\"" )
+
+#    define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wgnu-zero-variadic-macro-arguments\"" )
+
+#    define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wunused-template\"" )
+
+#    define CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
+        _Pragma( "clang diagnostic ignored \"-Wcomma\"" )
+
+#    define CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS \
+        _Pragma( "clang diagnostic ignored \"-Wshadow\"" )
+
+#endif // __clang__
+
+
+////////////////////////////////////////////////////////////////////////////////
+// We know some environments not to support full POSIX signals
+#if defined( CATCH_PLATFORM_WINDOWS ) ||                                       \
+    defined( CATCH_PLATFORM_PLAYSTATION ) ||                                   \
+    defined( __CYGWIN__ ) ||                                                   \
+    defined( __QNX__ ) ||                                                      \
+    defined( __EMSCRIPTEN__ ) ||                                               \
+    defined( __DJGPP__ ) ||                                                    \
+    defined( __OS400__ )
+#    define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
+#else
+#    define CATCH_INTERNAL_CONFIG_POSIX_SIGNALS
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// Assume that some platforms do not support getenv.
+#if defined( CATCH_PLATFORM_WINDOWS_UWP ) ||                                   \
+    defined( CATCH_PLATFORM_PLAYSTATION ) ||                                   \
+    defined( _GAMING_XBOX )
+#    define CATCH_INTERNAL_CONFIG_NO_GETENV
+#else
+#    define CATCH_INTERNAL_CONFIG_GETENV
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// Android somehow still does not support std::to_string
+#if defined(__ANDROID__)
+#    define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// Not all Windows environments support SEH properly
+#if defined(__MINGW32__)
+#    define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// PS4
+#if defined(__ORBIS__)
+#    define CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// Cygwin
+#ifdef __CYGWIN__
+
+// Required for some versions of Cygwin to declare gettimeofday
+// see: http://stackoverflow.com/questions/36901803/gettimeofday-not-declared-in-this-scope-cygwin
+#   define _BSD_SOURCE
+// some versions of cygwin (most) do not support std::to_string. Use the libstd check.
+// https://gcc.gnu.org/onlinedocs/gcc-4.8.2/libstdc++/api/a01053_source.html line 2812-2813
+# if !((__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99) \
+           && !defined(_GLIBCXX_HAVE_BROKEN_VSWPRINTF))
+
+#    define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
+
+# endif
+#endif // __CYGWIN__
+
+////////////////////////////////////////////////////////////////////////////////
+// Visual C++
+#if defined(_MSC_VER)
+
+// We want to defer to nvcc-specific warning suppression if we are compiled
+// with nvcc masquerading for MSVC.
+#    if !defined( __CUDACC__ )
+#        define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+            __pragma( warning( push ) )
+#        define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+            __pragma( warning( pop ) )
+#    endif
+
+// Universal Windows platform does not support SEH
+// Or console colours (or console at all...)
+#  if defined(CATCH_PLATFORM_WINDOWS_UWP)
+#    define CATCH_INTERNAL_CONFIG_NO_COLOUR_WIN32
+#  else
+#    define CATCH_INTERNAL_CONFIG_WINDOWS_SEH
+#  endif
+
+// MSVC traditional preprocessor needs some workaround for __VA_ARGS__
+// _MSVC_TRADITIONAL == 0 means new conformant preprocessor
+// _MSVC_TRADITIONAL == 1 means old traditional non-conformant preprocessor
+#  if !defined(__clang__) // Handle Clang masquerading for msvc
+#    if !defined(_MSVC_TRADITIONAL) || (defined(_MSVC_TRADITIONAL) && _MSVC_TRADITIONAL)
+#      define CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#    endif // MSVC_TRADITIONAL
+#  endif // __clang__
+
+#endif // _MSC_VER
+
+#if defined(_REENTRANT) || defined(_MSC_VER)
+// Enable async processing, as -pthread is specified or no additional linking is required
+# define CATCH_INTERNAL_CONFIG_USE_ASYNC
+#endif // _MSC_VER
+
+////////////////////////////////////////////////////////////////////////////////
+// Check if we are compiled with -fno-exceptions or equivalent
+#if defined(__EXCEPTIONS) || defined(__cpp_exceptions) || defined(_CPPUNWIND)
+#  define CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED
+#endif
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Embarcadero C++Build
+#if defined(__BORLANDC__)
+    #define CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+
+// RTX is a special version of Windows that is real time.
+// This means that it is detected as Windows, but does not provide
+// the same set of capabilities as real Windows does.
+#if defined(UNDER_RTSS) || defined(RTX64_BUILD)
+    #define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH
+    #define CATCH_INTERNAL_CONFIG_NO_ASYNC
+    #define CATCH_INTERNAL_CONFIG_NO_COLOUR_WIN32
+#endif
+
+#if !defined(_GLIBCXX_USE_C99_MATH_TR1)
+#define CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER
+#endif
+
+// Various stdlib support checks that require __has_include
+#if defined(__has_include)
+  // Check if string_view is available and usable
+  #if __has_include(<string_view>) && defined(CATCH_CPP17_OR_GREATER)
+  #    define CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW
+  #endif
+
+  // Check if optional is available and usable
+  #  if __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
+  #    define CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL
+  #  endif // __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
+
+  // Check if byte is available and usable
+  #  if __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
+  #    include <cstddef>
+  #    if defined(__cpp_lib_byte) && (__cpp_lib_byte > 0)
+  #      define CATCH_INTERNAL_CONFIG_CPP17_BYTE
+  #    endif
+  #  endif // __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
+
+  // Check if variant is available and usable
+  #  if __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
+  #    if defined(__clang__) && (__clang_major__ < 8)
+         // work around clang bug with libstdc++ https://bugs.llvm.org/show_bug.cgi?id=31852
+         // fix should be in clang 8, workaround in libstdc++ 8.2
+  #      include <ciso646>
+  #      if defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
+  #        define CATCH_CONFIG_NO_CPP17_VARIANT
+  #      else
+  #        define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
+  #      endif // defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
+  #    else
+  #      define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
+  #    endif // defined(__clang__) && (__clang_major__ < 8)
+  #  endif // __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
+#endif // defined(__has_include)
+
+
+#if defined(CATCH_INTERNAL_CONFIG_WINDOWS_SEH) && !defined(CATCH_CONFIG_NO_WINDOWS_SEH) && !defined(CATCH_CONFIG_WINDOWS_SEH) && !defined(CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH)
+#   define CATCH_CONFIG_WINDOWS_SEH
+#endif
+// This is set by default, because we assume that unix compilers are posix-signal-compatible by default.
+#if defined(CATCH_INTERNAL_CONFIG_POSIX_SIGNALS) && !defined(CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_POSIX_SIGNALS)
+#   define CATCH_CONFIG_POSIX_SIGNALS
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_GETENV) && !defined(CATCH_INTERNAL_CONFIG_NO_GETENV) && !defined(CATCH_CONFIG_NO_GETENV) && !defined(CATCH_CONFIG_GETENV)
+#   define CATCH_CONFIG_GETENV
+#endif
+
+#if !defined(CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_CPP11_TO_STRING)
+#    define CATCH_CONFIG_CPP11_TO_STRING
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_NO_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_CPP17_OPTIONAL)
+#  define CATCH_CONFIG_CPP17_OPTIONAL
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_NO_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_CPP17_STRING_VIEW)
+#  define CATCH_CONFIG_CPP17_STRING_VIEW
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_VARIANT) && !defined(CATCH_CONFIG_NO_CPP17_VARIANT) && !defined(CATCH_CONFIG_CPP17_VARIANT)
+#  define CATCH_CONFIG_CPP17_VARIANT
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_BYTE) && !defined(CATCH_CONFIG_NO_CPP17_BYTE) && !defined(CATCH_CONFIG_CPP17_BYTE)
+#  define CATCH_CONFIG_CPP17_BYTE
+#endif
+
+
+#if defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT)
+#  define CATCH_INTERNAL_CONFIG_NEW_CAPTURE
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_NEW_CAPTURE) && !defined(CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NEW_CAPTURE)
+#  define CATCH_CONFIG_NEW_CAPTURE
+#endif
+
+#if !defined( CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED ) && \
+    !defined( CATCH_CONFIG_DISABLE_EXCEPTIONS ) &&          \
+    !defined( CATCH_CONFIG_NO_DISABLE_EXCEPTIONS )
+#  define CATCH_CONFIG_DISABLE_EXCEPTIONS
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_NO_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_POLYFILL_ISNAN)
+#  define CATCH_CONFIG_POLYFILL_ISNAN
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_USE_ASYNC)  && !defined(CATCH_INTERNAL_CONFIG_NO_ASYNC) && !defined(CATCH_CONFIG_NO_USE_ASYNC) && !defined(CATCH_CONFIG_USE_ASYNC)
+#  define CATCH_CONFIG_USE_ASYNC
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_NO_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
+#  define CATCH_CONFIG_GLOBAL_NEXTAFTER
+#endif
+
+
+// Even if we do not think the compiler has that warning, we still have
+// to provide a macro that can be used by the code.
+#if !defined(CATCH_INTERNAL_START_WARNINGS_SUPPRESSION)
+#   define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
+#endif
+#if !defined(CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION)
+#   define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+#endif
+#if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS
+#endif
+#if !defined(CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
+#endif
+#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT)
+#   define CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT
+#endif
+#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS
+#endif
+#if !defined(CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS
+#endif
+#if !defined(CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS
+#endif
+#if !defined( CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS )
+#    define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
+#endif
+#if !defined( CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS )
+#    define CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS
+#endif
+#if !defined( CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS )
+#    define CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS
+#endif
+
+
+// The goal of this macro is to avoid evaluation of the arguments, but
+// still have the compiler warn on problems inside...
+#if !defined(CATCH_INTERNAL_IGNORE_BUT_WARN)
+#   define CATCH_INTERNAL_IGNORE_BUT_WARN(...)
+#endif
+
+#if defined(__APPLE__) && defined(__apple_build_version__) && (__clang_major__ < 10)
+#   undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
+#elif defined(__clang__) && (__clang_major__ < 5)
+#   undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
+#endif
+
+
+#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+#define CATCH_TRY if ((true))
+#define CATCH_CATCH_ALL if ((false))
+#define CATCH_CATCH_ANON(type) if ((false))
+#else
+#define CATCH_TRY try
+#define CATCH_CATCH_ALL catch (...)
+#define CATCH_CATCH_ANON(type) catch (type)
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_NO_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR)
+#define CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#endif
+
+#if defined( CATCH_PLATFORM_WINDOWS ) &&       \
+    !defined( CATCH_CONFIG_COLOUR_WIN32 ) && \
+    !defined( CATCH_CONFIG_NO_COLOUR_WIN32 ) && \
+    !defined( CATCH_INTERNAL_CONFIG_NO_COLOUR_WIN32 )
+#    define CATCH_CONFIG_COLOUR_WIN32
+#endif
+
+#if defined( CATCH_CONFIG_SHARED_LIBRARY ) && defined( _MSC_VER ) && \
+    !defined( CATCH_CONFIG_STATIC )
+#    ifdef Catch2_EXPORTS
+#        define CATCH_EXPORT //__declspec( dllexport ) // not needed
+#    else
+#        define CATCH_EXPORT __declspec( dllimport )
+#    endif
+#else
+#    define CATCH_EXPORT
+#endif
+
+#endif // CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED
+
+
+#ifndef CATCH_CONTEXT_HPP_INCLUDED
+#define CATCH_CONTEXT_HPP_INCLUDED
+
+
+namespace Catch {
+
+    class IResultCapture;
+    class IConfig;
+
+    class Context {
+        IConfig const* m_config = nullptr;
+        IResultCapture* m_resultCapture = nullptr;
+
+        CATCH_EXPORT static Context* currentContext;
+        friend Context& getCurrentMutableContext();
+        friend Context const& getCurrentContext();
+        static void createContext();
+        friend void cleanUpContext();
+
+    public:
+        constexpr IResultCapture* getResultCapture() const {
+            return m_resultCapture;
+        }
+        constexpr IConfig const* getConfig() const { return m_config; }
+        constexpr void setResultCapture( IResultCapture* resultCapture ) {
+            m_resultCapture = resultCapture;
+        }
+        constexpr void setConfig( IConfig const* config ) { m_config = config; }
+
+    };
+
+    Context& getCurrentMutableContext();
+
+    inline Context const& getCurrentContext() {
+        // We duplicate the logic from `getCurrentMutableContext` here,
+        // to avoid paying the call overhead in debug mode.
+        if ( !Context::currentContext ) { Context::createContext(); }
+        // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
+        return *Context::currentContext;
+    }
+
+    void cleanUpContext();
+
+    class SimplePcg32;
+    SimplePcg32& sharedRng();
+}
+
+#endif // CATCH_CONTEXT_HPP_INCLUDED
+
+
+#ifndef CATCH_MOVE_AND_FORWARD_HPP_INCLUDED
+#define CATCH_MOVE_AND_FORWARD_HPP_INCLUDED
+
+#include <type_traits>
+
+//! Replacement for std::move with better compile time performance
+#define CATCH_MOVE(...) static_cast<std::remove_reference_t<decltype(__VA_ARGS__)>&&>(__VA_ARGS__)
+
+//! Replacement for std::forward with better compile time performance
+#define CATCH_FORWARD(...) static_cast<decltype(__VA_ARGS__)&&>(__VA_ARGS__)
+
+#endif // CATCH_MOVE_AND_FORWARD_HPP_INCLUDED
+
+
+#ifndef CATCH_TEST_FAILURE_EXCEPTION_HPP_INCLUDED
+#define CATCH_TEST_FAILURE_EXCEPTION_HPP_INCLUDED
+
+namespace Catch {
+
+    //! Used to signal that an assertion macro failed
+    struct TestFailureException{};
+    //! Used to signal that the remainder of a test should be skipped
+    struct TestSkipException {};
+
+    /**
+     * Outlines throwing of `TestFailureException` into a single TU
+     *
+     * Also handles `CATCH_CONFIG_DISABLE_EXCEPTIONS` for callers.
+     */
+    [[noreturn]] void throw_test_failure_exception();
+
+    /**
+     * Outlines throwing of `TestSkipException` into a single TU
+     *
+     * Also handles `CATCH_CONFIG_DISABLE_EXCEPTIONS` for callers.
+     */
+    [[noreturn]] void throw_test_skip_exception();
+
+} // namespace Catch
+
+#endif // CATCH_TEST_FAILURE_EXCEPTION_HPP_INCLUDED
+
+
+#ifndef CATCH_UNIQUE_NAME_HPP_INCLUDED
+#define CATCH_UNIQUE_NAME_HPP_INCLUDED
+
+
+
+
+/** \file
+ * Wrapper for the CONFIG configuration option
+ *
+ * When generating internal unique names, there are two options. Either
+ * we mix in the current line number, or mix in an incrementing number.
+ * We prefer the latter, using `__COUNTER__`, but users might want to
+ * use the former.
+ */
+
+#ifndef CATCH_CONFIG_COUNTER_HPP_INCLUDED
+#define CATCH_CONFIG_COUNTER_HPP_INCLUDED
+
+
+#if ( !defined(__JETBRAINS_IDE__) || __JETBRAINS_IDE__ >= 20170300L )
+    #define CATCH_INTERNAL_CONFIG_COUNTER
+#endif
+
+#if defined( CATCH_INTERNAL_CONFIG_COUNTER ) && \
+    !defined( CATCH_CONFIG_NO_COUNTER ) && \
+    !defined( CATCH_CONFIG_COUNTER )
+#    define CATCH_CONFIG_COUNTER
+#endif
+
+
+#endif // CATCH_CONFIG_COUNTER_HPP_INCLUDED
+#define INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) name##line
+#define INTERNAL_CATCH_UNIQUE_NAME_LINE( name, line ) INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line )
+#ifdef CATCH_CONFIG_COUNTER
+#  define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __COUNTER__ )
+#else
+#  define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __LINE__ )
+#endif
+
+#endif // CATCH_UNIQUE_NAME_HPP_INCLUDED
+
+
+#ifndef CATCH_INTERFACES_CAPTURE_HPP_INCLUDED
+#define CATCH_INTERFACES_CAPTURE_HPP_INCLUDED
+
+#include <string>
+
+
+
+#ifndef CATCH_STRINGREF_HPP_INCLUDED
+#define CATCH_STRINGREF_HPP_INCLUDED
+
+#include <cstddef>
+#include <string>
+#include <iosfwd>
+#include <cassert>
+
+#include <cstring>
+
+namespace Catch {
+
+    /// A non-owning string class (similar to the forthcoming std::string_view)
+    /// Note that, because a StringRef may be a substring of another string,
+    /// it may not be null terminated.
+    class StringRef {
+    public:
+        using size_type = std::size_t;
+        using const_iterator = const char*;
+
+        static constexpr size_type npos{ static_cast<size_type>( -1 ) };
+
+    private:
+        static constexpr char const* const s_empty = "";
+
+        char const* m_start = s_empty;
+        size_type m_size = 0;
+
+    public: // construction
+        constexpr StringRef() noexcept = default;
+
+        StringRef( char const* rawChars ) noexcept;
+
+        constexpr StringRef( char const* rawChars, size_type size ) noexcept
+        :   m_start( rawChars ),
+            m_size( size )
+        {}
+
+        StringRef( std::string const& stdString ) noexcept
+        :   m_start( stdString.c_str() ),
+            m_size( stdString.size() )
+        {}
+
+        explicit operator std::string() const {
+            return std::string(m_start, m_size);
+        }
+
+    public: // operators
+        auto operator == ( StringRef other ) const noexcept -> bool {
+            return m_size == other.m_size
+                && (std::memcmp( m_start, other.m_start, m_size ) == 0);
+        }
+        auto operator != (StringRef other) const noexcept -> bool {
+            return !(*this == other);
+        }
+
+        constexpr auto operator[] ( size_type index ) const noexcept -> char {
+            assert(index < m_size);
+            return m_start[index];
+        }
+
+        bool operator<(StringRef rhs) const noexcept;
+
+    public: // named queries
+        constexpr auto empty() const noexcept -> bool {
+            return m_size == 0;
+        }
+        constexpr auto size() const noexcept -> size_type {
+            return m_size;
+        }
+
+        // Returns a substring of [start, start + length).
+        // If start + length > size(), then the substring is [start, size()).
+        // If start > size(), then the substring is empty.
+        constexpr StringRef substr(size_type start, size_type length) const noexcept {
+            if (start < m_size) {
+                const auto shortened_size = m_size - start;
+                return StringRef(m_start + start, (shortened_size < length) ? shortened_size : length);
+            } else {
+                return StringRef();
+            }
+        }
+
+        // Returns the current start pointer. May not be null-terminated.
+        constexpr char const* data() const noexcept {
+            return m_start;
+        }
+
+        constexpr const_iterator begin() const { return m_start; }
+        constexpr const_iterator end() const { return m_start + m_size; }
+
+
+        friend std::string& operator += (std::string& lhs, StringRef rhs);
+        friend std::ostream& operator << (std::ostream& os, StringRef str);
+        friend std::string operator+(StringRef lhs, StringRef rhs);
+
+        /**
+         * Provides a three-way comparison with rhs
+         *
+         * Returns negative number if lhs < rhs, 0 if lhs == rhs, and a positive
+         * number if lhs > rhs
+         */
+        int compare( StringRef rhs ) const;
+    };
+
+
+    constexpr auto operator ""_sr( char const* rawChars, std::size_t size ) noexcept -> StringRef {
+        return StringRef( rawChars, size );
+    }
+} // namespace Catch
+
+constexpr auto operator ""_catch_sr( char const* rawChars, std::size_t size ) noexcept -> Catch::StringRef {
+    return Catch::StringRef( rawChars, size );
+}
+
+#endif // CATCH_STRINGREF_HPP_INCLUDED
+
+
+#ifndef CATCH_RESULT_TYPE_HPP_INCLUDED
+#define CATCH_RESULT_TYPE_HPP_INCLUDED
+
+namespace Catch {
+
+    // ResultWas::OfType enum
+    struct ResultWas { enum OfType {
+        Unknown = -1,
+        Ok = 0,
+        Info = 1,
+        Warning = 2,
+        // TODO: Should explicit skip be considered "not OK" (cf. isOk)? I.e., should it have the failure bit?
+        ExplicitSkip = 4,
+
+        FailureBit = 0x10,
+
+        ExpressionFailed = FailureBit | 1,
+        ExplicitFailure = FailureBit | 2,
+
+        Exception = 0x100 | FailureBit,
+
+        ThrewException = Exception | 1,
+        DidntThrowException = Exception | 2,
+
+        FatalErrorCondition = 0x200 | FailureBit
+
+    }; };
+
+    constexpr bool isOk( ResultWas::OfType resultType ) {
+        return ( resultType & ResultWas::FailureBit ) == 0;
+    }
+    constexpr bool isJustInfo( int flags ) { return flags == ResultWas::Info; }
+
+
+    // ResultDisposition::Flags enum
+    struct ResultDisposition { enum Flags {
+        Normal = 0x01,
+
+        ContinueOnFailure = 0x02,   // Failures fail test, but execution continues
+        FalseTest = 0x04,           // Prefix expression with !
+        SuppressFail = 0x08         // Failures are reported but do not fail the test
+    }; };
+
+    constexpr ResultDisposition::Flags operator|( ResultDisposition::Flags lhs,
+                                        ResultDisposition::Flags rhs ) {
+        return static_cast<ResultDisposition::Flags>( static_cast<int>( lhs ) |
+                                                      static_cast<int>( rhs ) );
+    }
+
+    constexpr bool isFalseTest( int flags ) {
+        return ( flags & ResultDisposition::FalseTest ) != 0;
+    }
+    constexpr bool shouldSuppressFailure( int flags ) {
+        return ( flags & ResultDisposition::SuppressFail ) != 0;
+    }
+
+} // end namespace Catch
+
+#endif // CATCH_RESULT_TYPE_HPP_INCLUDED
+
+
+#ifndef CATCH_UNIQUE_PTR_HPP_INCLUDED
+#define CATCH_UNIQUE_PTR_HPP_INCLUDED
+
+#include <cassert>
+#include <type_traits>
+
+
+namespace Catch {
+namespace Detail {
+    /**
+     * A reimplementation of `std::unique_ptr` for improved compilation performance
+     *
+     * Does not support arrays nor custom deleters.
+     */
+    template <typename T>
+    class unique_ptr {
+        T* m_ptr;
+    public:
+        constexpr unique_ptr(std::nullptr_t = nullptr):
+            m_ptr{}
+        {}
+        explicit constexpr unique_ptr(T* ptr):
+            m_ptr(ptr)
+        {}
+
+        template <typename U, typename = std::enable_if_t<std::is_base_of<T, U>::value>>
+        unique_ptr(unique_ptr<U>&& from):
+            m_ptr(from.release())
+        {}
+
+        template <typename U, typename = std::enable_if_t<std::is_base_of<T, U>::value>>
+        unique_ptr& operator=(unique_ptr<U>&& from) {
+            reset(from.release());
+
+            return *this;
+        }
+
+        unique_ptr(unique_ptr const&) = delete;
+        unique_ptr& operator=(unique_ptr const&) = delete;
+
+        unique_ptr(unique_ptr&& rhs) noexcept:
+            m_ptr(rhs.m_ptr) {
+            rhs.m_ptr = nullptr;
+        }
+        unique_ptr& operator=(unique_ptr&& rhs) noexcept {
+            reset(rhs.release());
+
+            return *this;
+        }
+
+        ~unique_ptr() {
+            delete m_ptr;
+        }
+
+        T& operator*() {
+            assert(m_ptr);
+            return *m_ptr;
+        }
+        T const& operator*() const {
+            assert(m_ptr);
+            return *m_ptr;
+        }
+        T* operator->() noexcept {
+            assert(m_ptr);
+            return m_ptr;
+        }
+        T const* operator->() const noexcept {
+            assert(m_ptr);
+            return m_ptr;
+        }
+
+        T* get() { return m_ptr; }
+        T const* get() const { return m_ptr; }
+
+        void reset(T* ptr = nullptr) {
+            delete m_ptr;
+            m_ptr = ptr;
+        }
+
+        T* release() {
+            auto temp = m_ptr;
+            m_ptr = nullptr;
+            return temp;
+        }
+
+        explicit operator bool() const {
+            return m_ptr;
+        }
+
+        friend void swap(unique_ptr& lhs, unique_ptr& rhs) {
+            auto temp = lhs.m_ptr;
+            lhs.m_ptr = rhs.m_ptr;
+            rhs.m_ptr = temp;
+        }
+    };
+
+    //! Specialization to cause compile-time error for arrays
+    template <typename T>
+    class unique_ptr<T[]>;
+
+    template <typename T, typename... Args>
+    unique_ptr<T> make_unique(Args&&... args) {
+        return unique_ptr<T>(new T(CATCH_FORWARD(args)...));
+    }
+
+
+} // end namespace Detail
+} // end namespace Catch
+
+#endif // CATCH_UNIQUE_PTR_HPP_INCLUDED
+
+
+#ifndef CATCH_BENCHMARK_STATS_FWD_HPP_INCLUDED
+#define CATCH_BENCHMARK_STATS_FWD_HPP_INCLUDED
+
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_CLOCK_HPP_INCLUDED
+#define CATCH_CLOCK_HPP_INCLUDED
+
+#include <chrono>
+
+namespace Catch {
+    namespace Benchmark {
+        using IDuration = std::chrono::nanoseconds;
+        using FDuration = std::chrono::duration<double, std::nano>;
+
+        template <typename Clock>
+        using TimePoint = typename Clock::time_point;
+
+        using default_clock = std::chrono::steady_clock;
+    } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_CLOCK_HPP_INCLUDED
+
+namespace Catch {
+
+    // We cannot forward declare the type with default template argument
+    // multiple times, so it is split out into a separate header so that
+    // we can prevent multiple declarations in dependees
+    template <typename Duration = Benchmark::FDuration>
+    struct BenchmarkStats;
+
+} // end namespace Catch
+
+#endif // CATCH_BENCHMARK_STATS_FWD_HPP_INCLUDED
+
+namespace Catch {
+
+    class AssertionResult;
+    struct AssertionInfo;
+    struct SectionInfo;
+    struct SectionEndInfo;
+    struct MessageInfo;
+    struct MessageBuilder;
+    struct Counts;
+    struct AssertionReaction;
+    struct SourceLineInfo;
+
+    class ITransientExpression;
+    class IGeneratorTracker;
+
+    struct BenchmarkInfo;
+
+    namespace Generators {
+        class GeneratorUntypedBase;
+        using GeneratorBasePtr = Catch::Detail::unique_ptr<GeneratorUntypedBase>;
+    }
+
+
+    class IResultCapture {
+    public:
+        virtual ~IResultCapture();
+
+        virtual void notifyAssertionStarted( AssertionInfo const& info ) = 0;
+        virtual bool sectionStarted( StringRef sectionName,
+                                     SourceLineInfo const& sectionLineInfo,
+                                     Counts& assertions ) = 0;
+        virtual void sectionEnded( SectionEndInfo&& endInfo ) = 0;
+        virtual void sectionEndedEarly( SectionEndInfo&& endInfo ) = 0;
+
+        virtual IGeneratorTracker*
+        acquireGeneratorTracker( StringRef generatorName,
+                                 SourceLineInfo const& lineInfo ) = 0;
+        virtual IGeneratorTracker*
+        createGeneratorTracker( StringRef generatorName,
+                                SourceLineInfo lineInfo,
+                                Generators::GeneratorBasePtr&& generator ) = 0;
+
+        virtual void benchmarkPreparing( StringRef name ) = 0;
+        virtual void benchmarkStarting( BenchmarkInfo const& info ) = 0;
+        virtual void benchmarkEnded( BenchmarkStats<> const& stats ) = 0;
+        virtual void benchmarkFailed( StringRef error ) = 0;
+
+        virtual void pushScopedMessage( MessageInfo const& message ) = 0;
+        virtual void popScopedMessage( MessageInfo const& message ) = 0;
+
+        virtual void emplaceUnscopedMessage( MessageBuilder&& builder ) = 0;
+
+        virtual void handleFatalErrorCondition( StringRef message ) = 0;
+
+        virtual void handleExpr
+                (   AssertionInfo const& info,
+                    ITransientExpression const& expr,
+                    AssertionReaction& reaction ) = 0;
+        virtual void handleMessage
+                (   AssertionInfo const& info,
+                    ResultWas::OfType resultType,
+                    std::string&& message,
+                    AssertionReaction& reaction ) = 0;
+        virtual void handleUnexpectedExceptionNotThrown
+                (   AssertionInfo const& info,
+                    AssertionReaction& reaction ) = 0;
+        virtual void handleUnexpectedInflightException
+                (   AssertionInfo const& info,
+                    std::string&& message,
+                    AssertionReaction& reaction ) = 0;
+        virtual void handleIncomplete
+                (   AssertionInfo const& info ) = 0;
+        virtual void handleNonExpr
+                (   AssertionInfo const &info,
+                    ResultWas::OfType resultType,
+                    AssertionReaction &reaction ) = 0;
+
+
+
+        virtual bool lastAssertionPassed() = 0;
+        virtual void assertionPassed() = 0;
+
+        // Deprecated, do not use:
+        virtual std::string getCurrentTestName() const = 0;
+        virtual const AssertionResult* getLastResult() const = 0;
+        virtual void exceptionEarlyReported() = 0;
+    };
+
+    IResultCapture& getResultCapture();
+}
+
+#endif // CATCH_INTERFACES_CAPTURE_HPP_INCLUDED
+
+
+#ifndef CATCH_INTERFACES_CONFIG_HPP_INCLUDED
+#define CATCH_INTERFACES_CONFIG_HPP_INCLUDED
+
+
+
+#ifndef CATCH_NONCOPYABLE_HPP_INCLUDED
+#define CATCH_NONCOPYABLE_HPP_INCLUDED
+
+namespace Catch {
+    namespace Detail {
+
+        //! Deriving classes become noncopyable and nonmovable
+        class NonCopyable {
+            NonCopyable( NonCopyable const& ) = delete;
+            NonCopyable( NonCopyable&& ) = delete;
+            NonCopyable& operator=( NonCopyable const& ) = delete;
+            NonCopyable& operator=( NonCopyable&& ) = delete;
+
+        protected:
+            NonCopyable() noexcept = default;
+        };
+
+    } // namespace Detail
+} // namespace Catch
+
+#endif // CATCH_NONCOPYABLE_HPP_INCLUDED
+
+#include <chrono>
+#include <iosfwd>
+#include <string>
+#include <vector>
+
+namespace Catch {
+
+    enum class Verbosity {
+        Quiet = 0,
+        Normal,
+        High
+    };
+
+    struct WarnAbout { enum What {
+        Nothing = 0x00,
+        //! A test case or leaf section did not run any assertions
+        NoAssertions = 0x01,
+        //! A command line test spec matched no test cases
+        UnmatchedTestSpec = 0x02,
+    }; };
+
+    enum class ShowDurations {
+        DefaultForReporter,
+        Always,
+        Never
+    };
+    enum class TestRunOrder {
+        Declared,
+        LexicographicallySorted,
+        Randomized
+    };
+    enum class ColourMode : std::uint8_t {
+        //! Let Catch2 pick implementation based on platform detection
+        PlatformDefault,
+        //! Use ANSI colour code escapes
+        ANSI,
+        //! Use Win32 console colour API
+        Win32,
+        //! Don't use any colour
+        None
+    };
+    struct WaitForKeypress { enum When {
+        Never,
+        BeforeStart = 1,
+        BeforeExit = 2,
+        BeforeStartAndExit = BeforeStart | BeforeExit
+    }; };
+
+    class TestSpec;
+    class IStream;
+
+    class IConfig : public Detail::NonCopyable {
+    public:
+        virtual ~IConfig();
+
+        virtual bool allowThrows() const = 0;
+        virtual StringRef name() const = 0;
+        virtual bool includeSuccessfulResults() const = 0;
+        virtual bool shouldDebugBreak() const = 0;
+        virtual bool warnAboutMissingAssertions() const = 0;
+        virtual bool warnAboutUnmatchedTestSpecs() const = 0;
+        virtual bool zeroTestsCountAsSuccess() const = 0;
+        virtual int abortAfter() const = 0;
+        virtual bool showInvisibles() const = 0;
+        virtual ShowDurations showDurations() const = 0;
+        virtual double minDuration() const = 0;
+        virtual TestSpec const& testSpec() const = 0;
+        virtual bool hasTestFilters() const = 0;
+        virtual std::vector<std::string> const& getTestsOrTags() const = 0;
+        virtual TestRunOrder runOrder() const = 0;
+        virtual uint32_t rngSeed() const = 0;
+        virtual unsigned int shardCount() const = 0;
+        virtual unsigned int shardIndex() const = 0;
+        virtual ColourMode defaultColourMode() const = 0;
+        virtual std::vector<std::string> const& getSectionsToRun() const = 0;
+        virtual Verbosity verbosity() const = 0;
+
+        virtual bool skipBenchmarks() const = 0;
+        virtual bool benchmarkNoAnalysis() const = 0;
+        virtual unsigned int benchmarkSamples() const = 0;
+        virtual double benchmarkConfidenceInterval() const = 0;
+        virtual unsigned int benchmarkResamples() const = 0;
+        virtual std::chrono::milliseconds benchmarkWarmupTime() const = 0;
+    };
+}
+
+#endif // CATCH_INTERFACES_CONFIG_HPP_INCLUDED
+
+
+#ifndef CATCH_INTERFACES_REGISTRY_HUB_HPP_INCLUDED
+#define CATCH_INTERFACES_REGISTRY_HUB_HPP_INCLUDED
+
+
+#include <string>
+
+namespace Catch {
+
+    class TestCaseHandle;
+    struct TestCaseInfo;
+    class ITestCaseRegistry;
+    class IExceptionTranslatorRegistry;
+    class IExceptionTranslator;
+    class ReporterRegistry;
+    class IReporterFactory;
+    class ITagAliasRegistry;
+    class ITestInvoker;
+    class IMutableEnumValuesRegistry;
+    struct SourceLineInfo;
+
+    class StartupExceptionRegistry;
+    class EventListenerFactory;
+
+    using IReporterFactoryPtr = Detail::unique_ptr<IReporterFactory>;
+
+    class IRegistryHub {
+    public:
+        virtual ~IRegistryHub(); // = default
+
+        virtual ReporterRegistry const& getReporterRegistry() const = 0;
+        virtual ITestCaseRegistry const& getTestCaseRegistry() const = 0;
+        virtual ITagAliasRegistry const& getTagAliasRegistry() const = 0;
+        virtual IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const = 0;
+
+
+        virtual StartupExceptionRegistry const& getStartupExceptionRegistry() const = 0;
+    };
+
+    class IMutableRegistryHub {
+    public:
+        virtual ~IMutableRegistryHub(); // = default
+        virtual void registerReporter( std::string const& name, IReporterFactoryPtr factory ) = 0;
+        virtual void registerListener( Detail::unique_ptr<EventListenerFactory> factory ) = 0;
+        virtual void registerTest(Detail::unique_ptr<TestCaseInfo>&& testInfo, Detail::unique_ptr<ITestInvoker>&& invoker) = 0;
+        virtual void registerTranslator( Detail::unique_ptr<IExceptionTranslator>&& translator ) = 0;
+        virtual void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) = 0;
+        virtual void registerStartupException() noexcept = 0;
+        virtual IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() = 0;
+    };
+
+    IRegistryHub const& getRegistryHub();
+    IMutableRegistryHub& getMutableRegistryHub();
+    void cleanUp();
+    std::string translateActiveException();
+
+}
+
+#endif // CATCH_INTERFACES_REGISTRY_HUB_HPP_INCLUDED
+
+
+#ifndef CATCH_BENCHMARK_STATS_HPP_INCLUDED
+#define CATCH_BENCHMARK_STATS_HPP_INCLUDED
+
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_ESTIMATE_HPP_INCLUDED
+#define CATCH_ESTIMATE_HPP_INCLUDED
+
+namespace Catch {
+    namespace Benchmark {
+        template <typename Type>
+        struct Estimate {
+            Type point;
+            Type lower_bound;
+            Type upper_bound;
+            double confidence_interval;
+        };
+    } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_ESTIMATE_HPP_INCLUDED
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_OUTLIER_CLASSIFICATION_HPP_INCLUDED
+#define CATCH_OUTLIER_CLASSIFICATION_HPP_INCLUDED
+
+namespace Catch {
+    namespace Benchmark {
+        struct OutlierClassification {
+            int samples_seen = 0;
+            int low_severe = 0;     // more than 3 times IQR below Q1
+            int low_mild = 0;       // 1.5 to 3 times IQR below Q1
+            int high_mild = 0;      // 1.5 to 3 times IQR above Q3
+            int high_severe = 0;    // more than 3 times IQR above Q3
+
+            constexpr int total() const {
+                return low_severe + low_mild + high_mild + high_severe;
+            }
+        };
+    } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_OUTLIERS_CLASSIFICATION_HPP_INCLUDED
+// The fwd decl & default specialization needs to be seen by VS2017 before
+// BenchmarkStats itself, or VS2017 will report compilation error.
+
+#include <string>
+#include <vector>
+
+namespace Catch {
+
+    struct BenchmarkInfo {
+        std::string name;
+        double estimatedDuration;
+        int iterations;
+        unsigned int samples;
+        unsigned int resamples;
+        double clockResolution;
+        double clockCost;
+    };
+
+    // We need to keep template parameter for backwards compatibility,
+    // but we also do not want to use the template paraneter.
+    template <class Dummy>
+    struct BenchmarkStats {
+        BenchmarkInfo info;
+
+        std::vector<Benchmark::FDuration> samples;
+        Benchmark::Estimate<Benchmark::FDuration> mean;
+        Benchmark::Estimate<Benchmark::FDuration> standardDeviation;
+        Benchmark::OutlierClassification outliers;
+        double outlierVariance;
+    };
+
+
+} // end namespace Catch
+
+#endif // CATCH_BENCHMARK_STATS_HPP_INCLUDED
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_ENVIRONMENT_HPP_INCLUDED
+#define CATCH_ENVIRONMENT_HPP_INCLUDED
+
+
+namespace Catch {
+    namespace Benchmark {
+        struct EnvironmentEstimate {
+            FDuration mean;
+            OutlierClassification outliers;
+        };
+        struct Environment {
+            EnvironmentEstimate clock_resolution;
+            EnvironmentEstimate clock_cost;
+        };
+    } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_ENVIRONMENT_HPP_INCLUDED
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_EXECUTION_PLAN_HPP_INCLUDED
+#define CATCH_EXECUTION_PLAN_HPP_INCLUDED
+
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_BENCHMARK_FUNCTION_HPP_INCLUDED
+#define CATCH_BENCHMARK_FUNCTION_HPP_INCLUDED
+
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_CHRONOMETER_HPP_INCLUDED
+#define CATCH_CHRONOMETER_HPP_INCLUDED
+
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_OPTIMIZER_HPP_INCLUDED
+#define CATCH_OPTIMIZER_HPP_INCLUDED
+
+#if defined(_MSC_VER) || defined(__IAR_SYSTEMS_ICC__)
+#   include <atomic> // atomic_thread_fence
+#endif
+
+
+#include <type_traits>
+
+namespace Catch {
+    namespace Benchmark {
+#if defined(__GNUC__) || defined(__clang__)
+        template <typename T>
+        inline void keep_memory(T* p) {
+            asm volatile("" : : "g"(p) : "memory");
+        }
+        inline void keep_memory() {
+            asm volatile("" : : : "memory");
+        }
+
+        namespace Detail {
+            inline void optimizer_barrier() { keep_memory(); }
+        } // namespace Detail
+#elif defined(_MSC_VER) || defined(__IAR_SYSTEMS_ICC__)
+
+#if defined(_MSVC_VER)
+#pragma optimize("", off)
+#elif defined(__IAR_SYSTEMS_ICC__)
+// For IAR the pragma only affects the following function
+#pragma optimize=disable
+#endif
+        template <typename T>
+        inline void keep_memory(T* p) {
+            // thanks @milleniumbug
+            *reinterpret_cast<char volatile*>(p) = *reinterpret_cast<char const volatile*>(p);
+        }
+        // TODO equivalent keep_memory()
+#if defined(_MSVC_VER)
+#pragma optimize("", on)
+#endif
+
+        namespace Detail {
+            inline void optimizer_barrier() {
+                std::atomic_thread_fence(std::memory_order_seq_cst);
+            }
+        } // namespace Detail
+
+#endif
+
+        template <typename T>
+        inline void deoptimize_value(T&& x) {
+            keep_memory(&x);
+        }
+
+        template <typename Fn, typename... Args>
+        inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> std::enable_if_t<!std::is_same<void, decltype(fn(args...))>::value> {
+            deoptimize_value(CATCH_FORWARD(fn) (CATCH_FORWARD(args)...));
+        }
+
+        template <typename Fn, typename... Args>
+        inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> std::enable_if_t<std::is_same<void, decltype(fn(args...))>::value> {
+            CATCH_FORWARD((fn)) (CATCH_FORWARD(args)...);
+        }
+    } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_OPTIMIZER_HPP_INCLUDED
+
+
+#ifndef CATCH_META_HPP_INCLUDED
+#define CATCH_META_HPP_INCLUDED
+
+#include <type_traits>
+
+namespace Catch {
+    template <typename>
+    struct true_given : std::true_type {};
+
+    struct is_callable_tester {
+        template <typename Fun, typename... Args>
+        static true_given<decltype(std::declval<Fun>()(std::declval<Args>()...))> test(int);
+        template <typename...>
+        static std::false_type test(...);
+    };
+
+    template <typename T>
+    struct is_callable;
+
+    template <typename Fun, typename... Args>
+    struct is_callable<Fun(Args...)> : decltype(is_callable_tester::test<Fun, Args...>(0)) {};
+
+
+#if defined(__cpp_lib_is_invocable) && __cpp_lib_is_invocable >= 201703
+    // std::result_of is deprecated in C++17 and removed in C++20. Hence, it is
+    // replaced with std::invoke_result here.
+    template <typename Func, typename... U>
+    using FunctionReturnType = std::remove_reference_t<std::remove_cv_t<std::invoke_result_t<Func, U...>>>;
+#else
+    template <typename Func, typename... U>
+    using FunctionReturnType = std::remove_reference_t<std::remove_cv_t<std::result_of_t<Func(U...)>>>;
+#endif
+
+} // namespace Catch
+
+namespace mpl_{
+    struct na;
+}
+
+#endif // CATCH_META_HPP_INCLUDED
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            struct ChronometerConcept {
+                virtual void start() = 0;
+                virtual void finish() = 0;
+                virtual ~ChronometerConcept(); // = default;
+
+                ChronometerConcept() = default;
+                ChronometerConcept(ChronometerConcept const&) = default;
+                ChronometerConcept& operator=(ChronometerConcept const&) = default;
+            };
+            template <typename Clock>
+            struct ChronometerModel final : public ChronometerConcept {
+                void start() override { started = Clock::now(); }
+                void finish() override { finished = Clock::now(); }
+
+                IDuration elapsed() const {
+                    return std::chrono::duration_cast<std::chrono::nanoseconds>(
+                        finished - started );
+                }
+
+                TimePoint<Clock> started;
+                TimePoint<Clock> finished;
+            };
+        } // namespace Detail
+
+        struct Chronometer {
+        public:
+            template <typename Fun>
+            void measure(Fun&& fun) { measure(CATCH_FORWARD(fun), is_callable<Fun(int)>()); }
+
+            int runs() const { return repeats; }
+
+            Chronometer(Detail::ChronometerConcept& meter, int repeats_)
+                : impl(&meter)
+                , repeats(repeats_) {}
+
+        private:
+            template <typename Fun>
+            void measure(Fun&& fun, std::false_type) {
+                measure([&fun](int) { return fun(); }, std::true_type());
+            }
+
+            template <typename Fun>
+            void measure(Fun&& fun, std::true_type) {
+                Detail::optimizer_barrier();
+                impl->start();
+                for (int i = 0; i < repeats; ++i) invoke_deoptimized(fun, i);
+                impl->finish();
+                Detail::optimizer_barrier();
+            }
+
+            Detail::ChronometerConcept* impl;
+            int repeats;
+        };
+    } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_CHRONOMETER_HPP_INCLUDED
+
+#include <type_traits>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename T, typename U>
+            struct is_related
+                : std::is_same<std::decay_t<T>, std::decay_t<U>> {};
+
+            /// We need to reinvent std::function because every piece of code that might add overhead
+            /// in a measurement context needs to have consistent performance characteristics so that we
+            /// can account for it in the measurement.
+            /// Implementations of std::function with optimizations that aren't always applicable, like
+            /// small buffer optimizations, are not uncommon.
+            /// This is effectively an implementation of std::function without any such optimizations;
+            /// it may be slow, but it is consistently slow.
+            struct BenchmarkFunction {
+            private:
+                struct callable {
+                    virtual void call(Chronometer meter) const = 0;
+                    virtual ~callable(); // = default;
+
+                    callable() = default;
+                    callable(callable&&) = default;
+                    callable& operator=(callable&&) = default;
+                };
+                template <typename Fun>
+                struct model : public callable {
+                    model(Fun&& fun_) : fun(CATCH_MOVE(fun_)) {}
+                    model(Fun const& fun_) : fun(fun_) {}
+
+                    void call(Chronometer meter) const override {
+                        call(meter, is_callable<Fun(Chronometer)>());
+                    }
+                    void call(Chronometer meter, std::true_type) const {
+                        fun(meter);
+                    }
+                    void call(Chronometer meter, std::false_type) const {
+                        meter.measure(fun);
+                    }
+
+                    Fun fun;
+                };
+
+            public:
+                BenchmarkFunction();
+
+                template <typename Fun,
+                    std::enable_if_t<!is_related<Fun, BenchmarkFunction>::value, int> = 0>
+                    BenchmarkFunction(Fun&& fun)
+                    : f(new model<std::decay_t<Fun>>(CATCH_FORWARD(fun))) {}
+
+                BenchmarkFunction( BenchmarkFunction&& that ) noexcept:
+                    f( CATCH_MOVE( that.f ) ) {}
+
+                BenchmarkFunction&
+                operator=( BenchmarkFunction&& that ) noexcept {
+                    f = CATCH_MOVE( that.f );
+                    return *this;
+                }
+
+                void operator()(Chronometer meter) const { f->call(meter); }
+
+            private:
+                Catch::Detail::unique_ptr<callable> f;
+            };
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_BENCHMARK_FUNCTION_HPP_INCLUDED
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_REPEAT_HPP_INCLUDED
+#define CATCH_REPEAT_HPP_INCLUDED
+
+#include <type_traits>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename Fun>
+            struct repeater {
+                void operator()(int k) const {
+                    for (int i = 0; i < k; ++i) {
+                        fun();
+                    }
+                }
+                Fun fun;
+            };
+            template <typename Fun>
+            repeater<std::decay_t<Fun>> repeat(Fun&& fun) {
+                return { CATCH_FORWARD(fun) };
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_REPEAT_HPP_INCLUDED
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_RUN_FOR_AT_LEAST_HPP_INCLUDED
+#define CATCH_RUN_FOR_AT_LEAST_HPP_INCLUDED
+
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_MEASURE_HPP_INCLUDED
+#define CATCH_MEASURE_HPP_INCLUDED
+
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_COMPLETE_INVOKE_HPP_INCLUDED
+#define CATCH_COMPLETE_INVOKE_HPP_INCLUDED
+
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename T>
+            struct CompleteType { using type = T; };
+            template <>
+            struct CompleteType<void> { struct type {}; };
+
+            template <typename T>
+            using CompleteType_t = typename CompleteType<T>::type;
+
+            template <typename Result>
+            struct CompleteInvoker {
+                template <typename Fun, typename... Args>
+                static Result invoke(Fun&& fun, Args&&... args) {
+                    return CATCH_FORWARD(fun)(CATCH_FORWARD(args)...);
+                }
+            };
+            template <>
+            struct CompleteInvoker<void> {
+                template <typename Fun, typename... Args>
+                static CompleteType_t<void> invoke(Fun&& fun, Args&&... args) {
+                    CATCH_FORWARD(fun)(CATCH_FORWARD(args)...);
+                    return {};
+                }
+            };
+
+            // invoke and not return void :(
+            template <typename Fun, typename... Args>
+            CompleteType_t<FunctionReturnType<Fun, Args...>> complete_invoke(Fun&& fun, Args&&... args) {
+                return CompleteInvoker<FunctionReturnType<Fun, Args...>>::invoke(CATCH_FORWARD(fun), CATCH_FORWARD(args)...);
+            }
+
+        } // namespace Detail
+
+        template <typename Fun>
+        Detail::CompleteType_t<FunctionReturnType<Fun>> user_code(Fun&& fun) {
+            return Detail::complete_invoke(CATCH_FORWARD(fun));
+        }
+    } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_COMPLETE_INVOKE_HPP_INCLUDED
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_TIMING_HPP_INCLUDED
+#define CATCH_TIMING_HPP_INCLUDED
+
+
+#include <type_traits>
+
+namespace Catch {
+    namespace Benchmark {
+        template <typename Result>
+        struct Timing {
+            IDuration elapsed;
+            Result result;
+            int iterations;
+        };
+        template <typename Func, typename... Args>
+        using TimingOf = Timing<Detail::CompleteType_t<FunctionReturnType<Func, Args...>>>;
+    } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_TIMING_HPP_INCLUDED
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename Clock, typename Fun, typename... Args>
+            TimingOf<Fun, Args...> measure(Fun&& fun, Args&&... args) {
+                auto start = Clock::now();
+                auto&& r = Detail::complete_invoke(CATCH_FORWARD(fun), CATCH_FORWARD(args)...);
+                auto end = Clock::now();
+                auto delta = end - start;
+                return { delta, CATCH_FORWARD(r), 1 };
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_MEASURE_HPP_INCLUDED
+
+#include <type_traits>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename Clock, typename Fun>
+            TimingOf<Fun, int> measure_one(Fun&& fun, int iters, std::false_type) {
+                return Detail::measure<Clock>(fun, iters);
+            }
+            template <typename Clock, typename Fun>
+            TimingOf<Fun, Chronometer> measure_one(Fun&& fun, int iters, std::true_type) {
+                Detail::ChronometerModel<Clock> meter;
+                auto&& result = Detail::complete_invoke(fun, Chronometer(meter, iters));
+
+                return { meter.elapsed(), CATCH_MOVE(result), iters };
+            }
+
+            template <typename Clock, typename Fun>
+            using run_for_at_least_argument_t = std::conditional_t<is_callable<Fun(Chronometer)>::value, Chronometer, int>;
+
+
+            [[noreturn]]
+            void throw_optimized_away_error();
+
+            template <typename Clock, typename Fun>
+            TimingOf<Fun, run_for_at_least_argument_t<Clock, Fun>>
+                run_for_at_least(IDuration how_long,
+                                 const int initial_iterations,
+                                 Fun&& fun) {
+                auto iters = initial_iterations;
+                while (iters < (1 << 30)) {
+                    auto&& Timing = measure_one<Clock>(fun, iters, is_callable<Fun(Chronometer)>());
+
+                    if (Timing.elapsed >= how_long) {
+                        return { Timing.elapsed, CATCH_MOVE(Timing.result), iters };
+                    }
+                    iters *= 2;
+                }
+                throw_optimized_away_error();
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_RUN_FOR_AT_LEAST_HPP_INCLUDED
+
+#include <vector>
+
+namespace Catch {
+    namespace Benchmark {
+        struct ExecutionPlan {
+            int iterations_per_sample;
+            FDuration estimated_duration;
+            Detail::BenchmarkFunction benchmark;
+            FDuration warmup_time;
+            int warmup_iterations;
+
+            template <typename Clock>
+            std::vector<FDuration> run(const IConfig &cfg, Environment env) const {
+                // warmup a bit
+                Detail::run_for_at_least<Clock>(
+                    std::chrono::duration_cast<IDuration>( warmup_time ),
+                    warmup_iterations,
+                    Detail::repeat( []() { return Clock::now(); } )
+                );
+
+                std::vector<FDuration> times;
+                const auto num_samples = cfg.benchmarkSamples();
+                times.reserve( num_samples );
+                for ( size_t i = 0; i < num_samples; ++i ) {
+                    Detail::ChronometerModel<Clock> model;
+                    this->benchmark( Chronometer( model, iterations_per_sample ) );
+                    auto sample_time = model.elapsed() - env.clock_cost.mean;
+                    if ( sample_time < FDuration::zero() ) {
+                        sample_time = FDuration::zero();
+                    }
+                    times.push_back(sample_time / iterations_per_sample);
+                }
+                return times;
+            }
+        };
+    } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_EXECUTION_PLAN_HPP_INCLUDED
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_ESTIMATE_CLOCK_HPP_INCLUDED
+#define CATCH_ESTIMATE_CLOCK_HPP_INCLUDED
+
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_STATS_HPP_INCLUDED
+#define CATCH_STATS_HPP_INCLUDED
+
+
+#include <vector>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            using sample = std::vector<double>;
+
+            double weighted_average_quantile( int k,
+                                              int q,
+                                              double* first,
+                                              double* last );
+
+            OutlierClassification
+            classify_outliers( double const* first, double const* last );
+
+            double mean( double const* first, double const* last );
+
+            double normal_cdf( double x );
+
+            double erfc_inv(double x);
+
+            double normal_quantile(double p);
+
+            Estimate<double>
+            bootstrap( double confidence_level,
+                       double* first,
+                       double* last,
+                       sample const& resample,
+                       double ( *estimator )( double const*, double const* ) );
+
+            struct bootstrap_analysis {
+                Estimate<double> mean;
+                Estimate<double> standard_deviation;
+                double outlier_variance;
+            };
+
+            bootstrap_analysis analyse_samples(double confidence_level,
+                                               unsigned int n_resamples,
+                                               double* first,
+                                               double* last);
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_STATS_HPP_INCLUDED
+
+#include <algorithm>
+#include <vector>
+#include <cmath>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename Clock>
+            std::vector<double> resolution(int k) {
+                const size_t points = static_cast<size_t>( k + 1 );
+                // To avoid overhead from the branch inside vector::push_back,
+                // we allocate them all and then overwrite.
+                std::vector<TimePoint<Clock>> times(points);
+                for ( auto& time : times ) {
+                    time = Clock::now();
+                }
+
+                std::vector<double> deltas;
+                deltas.reserve(static_cast<size_t>(k));
+                for ( size_t idx = 1; idx < points; ++idx ) {
+                    deltas.push_back( static_cast<double>(
+                        ( times[idx] - times[idx - 1] ).count() ) );
+                }
+
+                return deltas;
+            }
+
+            constexpr auto warmup_iterations = 10000;
+            constexpr auto warmup_time = std::chrono::milliseconds(100);
+            constexpr auto minimum_ticks = 1000;
+            constexpr auto warmup_seed = 10000;
+            constexpr auto clock_resolution_estimation_time = std::chrono::milliseconds(500);
+            constexpr auto clock_cost_estimation_time_limit = std::chrono::seconds(1);
+            constexpr auto clock_cost_estimation_tick_limit = 100000;
+            constexpr auto clock_cost_estimation_time = std::chrono::milliseconds(10);
+            constexpr auto clock_cost_estimation_iterations = 10000;
+
+            template <typename Clock>
+            int warmup() {
+                return run_for_at_least<Clock>(warmup_time, warmup_seed, &resolution<Clock>)
+                    .iterations;
+            }
+            template <typename Clock>
+            EnvironmentEstimate estimate_clock_resolution(int iterations) {
+                auto r = run_for_at_least<Clock>(clock_resolution_estimation_time, iterations, &resolution<Clock>)
+                    .result;
+                return {
+                    FDuration(mean(r.data(), r.data() + r.size())),
+                    classify_outliers(r.data(), r.data() + r.size()),
+                };
+            }
+            template <typename Clock>
+            EnvironmentEstimate estimate_clock_cost(FDuration resolution) {
+                auto time_limit = (std::min)(
+                    resolution * clock_cost_estimation_tick_limit,
+                    FDuration(clock_cost_estimation_time_limit));
+                auto time_clock = [](int k) {
+                    return Detail::measure<Clock>([k] {
+                        for (int i = 0; i < k; ++i) {
+                            volatile auto ignored = Clock::now();
+                            (void)ignored;
+                        }
+                    }).elapsed;
+                };
+                time_clock(1);
+                int iters = clock_cost_estimation_iterations;
+                auto&& r = run_for_at_least<Clock>(clock_cost_estimation_time, iters, time_clock);
+                std::vector<double> times;
+                int nsamples = static_cast<int>(std::ceil(time_limit / r.elapsed));
+                times.reserve(static_cast<size_t>(nsamples));
+                for ( int s = 0; s < nsamples; ++s ) {
+                    times.push_back( static_cast<double>(
+                        ( time_clock( r.iterations ) / r.iterations )
+                            .count() ) );
+                }
+                return {
+                    FDuration(mean(times.data(), times.data() + times.size())),
+                    classify_outliers(times.data(), times.data() + times.size()),
+                };
+            }
+
+            template <typename Clock>
+            Environment measure_environment() {
+#if defined(__clang__)
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wexit-time-destructors"
+#endif
+                static Catch::Detail::unique_ptr<Environment> env;
+#if defined(__clang__)
+#    pragma clang diagnostic pop
+#endif
+                if (env) {
+                    return *env;
+                }
+
+                auto iters = Detail::warmup<Clock>();
+                auto resolution = Detail::estimate_clock_resolution<Clock>(iters);
+                auto cost = Detail::estimate_clock_cost<Clock>(resolution.mean);
+
+                env = Catch::Detail::make_unique<Environment>( Environment{resolution, cost} );
+                return *env;
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_ESTIMATE_CLOCK_HPP_INCLUDED
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_ANALYSE_HPP_INCLUDED
+#define CATCH_ANALYSE_HPP_INCLUDED
+
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_SAMPLE_ANALYSIS_HPP_INCLUDED
+#define CATCH_SAMPLE_ANALYSIS_HPP_INCLUDED
+
+
+#include <vector>
+
+namespace Catch {
+    namespace Benchmark {
+        struct SampleAnalysis {
+            std::vector<FDuration> samples;
+            Estimate<FDuration> mean;
+            Estimate<FDuration> standard_deviation;
+            OutlierClassification outliers;
+            double outlier_variance;
+        };
+    } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_SAMPLE_ANALYSIS_HPP_INCLUDED
+
+
+namespace Catch {
+    class IConfig;
+
+    namespace Benchmark {
+        namespace Detail {
+            SampleAnalysis analyse(const IConfig &cfg, FDuration* first, FDuration* last);
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_ANALYSE_HPP_INCLUDED
+
+#include <algorithm>
+#include <chrono>
+#include <exception>
+#include <string>
+#include <cmath>
+
+namespace Catch {
+    namespace Benchmark {
+        struct Benchmark {
+            Benchmark(std::string&& benchmarkName)
+                : name(CATCH_MOVE(benchmarkName)) {}
+
+            template <class FUN>
+            Benchmark(std::string&& benchmarkName , FUN &&func)
+                : fun(CATCH_MOVE(func)), name(CATCH_MOVE(benchmarkName)) {}
+
+            template <typename Clock>
+            ExecutionPlan prepare(const IConfig &cfg, Environment env) {
+                auto min_time = env.clock_resolution.mean * Detail::minimum_ticks;
+                auto run_time = std::max(min_time, std::chrono::duration_cast<decltype(min_time)>(cfg.benchmarkWarmupTime()));
+                auto&& test = Detail::run_for_at_least<Clock>(std::chrono::duration_cast<IDuration>(run_time), 1, fun);
+                int new_iters = static_cast<int>(std::ceil(min_time * test.iterations / test.elapsed));
+                return { new_iters, test.elapsed / test.iterations * new_iters * cfg.benchmarkSamples(), CATCH_MOVE(fun), std::chrono::duration_cast<FDuration>(cfg.benchmarkWarmupTime()), Detail::warmup_iterations };
+            }
+
+            template <typename Clock = default_clock>
+            void run() {
+                static_assert( Clock::is_steady,
+                               "Benchmarking clock should be steady" );
+                auto const* cfg = getCurrentContext().getConfig();
+
+                auto env = Detail::measure_environment<Clock>();
+
+                getResultCapture().benchmarkPreparing(name);
+                CATCH_TRY{
+                    auto plan = user_code([&] {
+                        return prepare<Clock>(*cfg, env);
+                    });
+
+                    BenchmarkInfo info {
+                        CATCH_MOVE(name),
+                        plan.estimated_duration.count(),
+                        plan.iterations_per_sample,
+                        cfg->benchmarkSamples(),
+                        cfg->benchmarkResamples(),
+                        env.clock_resolution.mean.count(),
+                        env.clock_cost.mean.count()
+                    };
+
+                    getResultCapture().benchmarkStarting(info);
+
+                    auto samples = user_code([&] {
+                        return plan.template run<Clock>(*cfg, env);
+                    });
+
+                    auto analysis = Detail::analyse(*cfg, samples.data(), samples.data() + samples.size());
+                    BenchmarkStats<> stats{ CATCH_MOVE(info), CATCH_MOVE(analysis.samples), analysis.mean, analysis.standard_deviation, analysis.outliers, analysis.outlier_variance };
+                    getResultCapture().benchmarkEnded(stats);
+                } CATCH_CATCH_ANON (TestFailureException const&) {
+                    getResultCapture().benchmarkFailed("Benchmark failed due to failed assertion"_sr);
+                } CATCH_CATCH_ALL{
+                    getResultCapture().benchmarkFailed(translateActiveException());
+                    // We let the exception go further up so that the
+                    // test case is marked as failed.
+                    std::rethrow_exception(std::current_exception());
+                }
+            }
+
+            // sets lambda to be used in fun *and* executes benchmark!
+            template <typename Fun, std::enable_if_t<!Detail::is_related<Fun, Benchmark>::value, int> = 0>
+                Benchmark & operator=(Fun func) {
+                auto const* cfg = getCurrentContext().getConfig();
+                if (!cfg->skipBenchmarks()) {
+                    fun = Detail::BenchmarkFunction(func);
+                    run();
+                }
+                return *this;
+            }
+
+            explicit operator bool() {
+                return true;
+            }
+
+        private:
+            Detail::BenchmarkFunction fun;
+            std::string name;
+        };
+    }
+} // namespace Catch
+
+#define INTERNAL_CATCH_GET_1_ARG(arg1, arg2, ...) arg1
+#define INTERNAL_CATCH_GET_2_ARG(arg1, arg2, ...) arg2
+
+#define INTERNAL_CATCH_BENCHMARK(BenchmarkName, name, benchmarkIndex)\
+    if( Catch::Benchmark::Benchmark BenchmarkName{name} ) \
+        BenchmarkName = [&](int benchmarkIndex)
+
+#define INTERNAL_CATCH_BENCHMARK_ADVANCED(BenchmarkName, name)\
+    if( Catch::Benchmark::Benchmark BenchmarkName{name} ) \
+        BenchmarkName = [&]
+
+#if defined(CATCH_CONFIG_PREFIX_ALL)
+
+#define CATCH_BENCHMARK(...) \
+    INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(CATCH2_INTERNAL_BENCHMARK_), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
+#define CATCH_BENCHMARK_ADVANCED(name) \
+    INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(CATCH2_INTERNAL_BENCHMARK_), name)
+
+#else
+
+#define BENCHMARK(...) \
+    INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(CATCH2_INTERNAL_BENCHMARK_), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
+#define BENCHMARK_ADVANCED(name) \
+    INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(CATCH2_INTERNAL_BENCHMARK_), name)
+
+#endif
+
+#endif // CATCH_BENCHMARK_HPP_INCLUDED
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_CONSTRUCTOR_HPP_INCLUDED
+#define CATCH_CONSTRUCTOR_HPP_INCLUDED
+
+
+#include <type_traits>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename T, bool Destruct>
+            struct ObjectStorage
+            {
+                ObjectStorage() = default;
+
+                ObjectStorage(const ObjectStorage& other)
+                {
+                    new(&data) T(other.stored_object());
+                }
+
+                ObjectStorage(ObjectStorage&& other)
+                {
+                    new(data) T(CATCH_MOVE(other.stored_object()));
+                }
+
+                ~ObjectStorage() { destruct_on_exit<T>(); }
+
+                template <typename... Args>
+                void construct(Args&&... args)
+                {
+                    new (data) T(CATCH_FORWARD(args)...);
+                }
+
+                template <bool AllowManualDestruction = !Destruct>
+                std::enable_if_t<AllowManualDestruction> destruct()
+                {
+                    stored_object().~T();
+                }
+
+            private:
+                // If this is a constructor benchmark, destruct the underlying object
+                template <typename U>
+                void destruct_on_exit(std::enable_if_t<Destruct, U>* = nullptr) { destruct<true>(); }
+                // Otherwise, don't
+                template <typename U>
+                void destruct_on_exit(std::enable_if_t<!Destruct, U>* = nullptr) { }
+
+#if defined( __GNUC__ ) && __GNUC__ <= 6
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif
+                T& stored_object() { return *reinterpret_cast<T*>( data ); }
+
+                T const& stored_object() const {
+                    return *reinterpret_cast<T const*>( data );
+                }
+#if defined( __GNUC__ ) && __GNUC__ <= 6
+#    pragma GCC diagnostic pop
+#endif
+
+                alignas( T ) unsigned char data[sizeof( T )]{};
+            };
+        } // namespace Detail
+
+        template <typename T>
+        using storage_for = Detail::ObjectStorage<T, true>;
+
+        template <typename T>
+        using destructable_object = Detail::ObjectStorage<T, false>;
+    } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_CONSTRUCTOR_HPP_INCLUDED
+
+#endif // CATCH_BENCHMARK_ALL_HPP_INCLUDED
+
+
+#ifndef CATCH_APPROX_HPP_INCLUDED
+#define CATCH_APPROX_HPP_INCLUDED
+
+
+
+#ifndef CATCH_TOSTRING_HPP_INCLUDED
+#define CATCH_TOSTRING_HPP_INCLUDED
+
+
+#include <vector>
+#include <cstddef>
+#include <type_traits>
+#include <string>
+
+
+
+
+/** \file
+ * Wrapper for the WCHAR configuration option
+ *
+ * We want to support platforms that do not provide `wchar_t`, so we
+ * sometimes have to disable providing wchar_t overloads through Catch2,
+ * e.g. the StringMaker specialization for `std::wstring`.
+ */
+
+#ifndef CATCH_CONFIG_WCHAR_HPP_INCLUDED
+#define CATCH_CONFIG_WCHAR_HPP_INCLUDED
+
+
+// We assume that WCHAR should be enabled by default, and only disabled
+// for a shortlist (so far only DJGPP) of compilers.
+
+#if defined(__DJGPP__)
+#  define CATCH_INTERNAL_CONFIG_NO_WCHAR
+#endif // __DJGPP__
+
+#if !defined( CATCH_INTERNAL_CONFIG_NO_WCHAR ) && \
+    !defined( CATCH_CONFIG_NO_WCHAR ) && \
+    !defined( CATCH_CONFIG_WCHAR )
+#    define CATCH_CONFIG_WCHAR
+#endif
+
+#endif // CATCH_CONFIG_WCHAR_HPP_INCLUDED
+
+
+#ifndef CATCH_REUSABLE_STRING_STREAM_HPP_INCLUDED
+#define CATCH_REUSABLE_STRING_STREAM_HPP_INCLUDED
+
+
+#include <iosfwd>
+#include <cstddef>
+#include <ostream>
+#include <string>
+
+namespace Catch {
+
+    class ReusableStringStream : Detail::NonCopyable {
+        std::size_t m_index;
+        std::ostream* m_oss;
+    public:
+        ReusableStringStream();
+        ~ReusableStringStream();
+
+        //! Returns the serialized state
+        std::string str() const;
+        //! Sets internal state to `str`
+        void str(std::string const& str);
+
+#if defined(__GNUC__) && !defined(__clang__)
+#pragma GCC diagnostic push
+// Old versions of GCC do not understand -Wnonnull-compare
+#pragma GCC diagnostic ignored "-Wpragmas"
+// Streaming a function pointer triggers Waddress and Wnonnull-compare
+// on GCC, because it implicitly converts it to bool and then decides
+// that the check it uses (a? true : false) is tautological and cannot
+// be null...
+#pragma GCC diagnostic ignored "-Waddress"
+#pragma GCC diagnostic ignored "-Wnonnull-compare"
+#endif
+
+        template<typename T>
+        auto operator << ( T const& value ) -> ReusableStringStream& {
+            *m_oss << value;
+            return *this;
+        }
+
+#if defined(__GNUC__) && !defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+        auto get() -> std::ostream& { return *m_oss; }
+    };
+}
+
+#endif // CATCH_REUSABLE_STRING_STREAM_HPP_INCLUDED
+
+
+#ifndef CATCH_VOID_TYPE_HPP_INCLUDED
+#define CATCH_VOID_TYPE_HPP_INCLUDED
+
+
+namespace Catch {
+    namespace Detail {
+
+        template <typename...>
+        struct make_void { using type = void; };
+
+        template <typename... Ts>
+        using void_t = typename make_void<Ts...>::type;
+
+    } // namespace Detail
+} // namespace Catch
+
+
+#endif // CATCH_VOID_TYPE_HPP_INCLUDED
+
+
+#ifndef CATCH_INTERFACES_ENUM_VALUES_REGISTRY_HPP_INCLUDED
+#define CATCH_INTERFACES_ENUM_VALUES_REGISTRY_HPP_INCLUDED
+
+
+#include <vector>
+
+namespace Catch {
+
+    namespace Detail {
+        struct EnumInfo {
+            StringRef m_name;
+            std::vector<std::pair<int, StringRef>> m_values;
+
+            ~EnumInfo();
+
+            StringRef lookup( int value ) const;
+        };
+    } // namespace Detail
+
+    class IMutableEnumValuesRegistry {
+    public:
+        virtual ~IMutableEnumValuesRegistry(); // = default;
+
+        virtual Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::vector<int> const& values ) = 0;
+
+        template<typename E>
+        Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::initializer_list<E> values ) {
+            static_assert(sizeof(int) >= sizeof(E), "Cannot serialize enum to int");
+            std::vector<int> intValues;
+            intValues.reserve( values.size() );
+            for( auto enumValue : values )
+                intValues.push_back( static_cast<int>( enumValue ) );
+            return registerEnum( enumName, allEnums, intValues );
+        }
+    };
+
+} // Catch
+
+#endif // CATCH_INTERFACES_ENUM_VALUES_REGISTRY_HPP_INCLUDED
+
+#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+#include <string_view>
+#endif
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4180) // We attempt to stream a function (address) by const&, which MSVC complains about but is harmless
+#endif
+
+// We need a dummy global operator<< so we can bring it into Catch namespace later
+struct Catch_global_namespace_dummy{};
+std::ostream& operator<<(std::ostream&, Catch_global_namespace_dummy);
+
+namespace Catch {
+    // Bring in global namespace operator<< for ADL lookup in
+    // `IsStreamInsertable` below.
+    using ::operator<<;
+
+    namespace Detail {
+
+        inline std::size_t catch_strnlen(const char *str, std::size_t n) {
+            auto ret = std::char_traits<char>::find(str, n, '\0');
+            if (ret != nullptr) {
+                return static_cast<std::size_t>(ret - str);
+            }
+            return n;
+        }
+
+        constexpr StringRef unprintableString = "{?}"_sr;
+
+        //! Encases `string in quotes, and optionally escapes invisibles
+        std::string convertIntoString( StringRef string, bool escapeInvisibles );
+
+        //! Encases `string` in quotes, and escapes invisibles if user requested
+        //! it via CLI
+        std::string convertIntoString( StringRef string );
+
+        std::string rawMemoryToString( const void *object, std::size_t size );
+
+        template<typename T>
+        std::string rawMemoryToString( const T& object ) {
+          return rawMemoryToString( &object, sizeof(object) );
+        }
+
+        template<typename T>
+        class IsStreamInsertable {
+            template<typename Stream, typename U>
+            static auto test(int)
+                -> decltype(std::declval<Stream&>() << std::declval<U>(), std::true_type());
+
+            template<typename, typename>
+            static auto test(...)->std::false_type;
+
+        public:
+            static const bool value = decltype(test<std::ostream, const T&>(0))::value;
+        };
+
+        template<typename E>
+        std::string convertUnknownEnumToString( E e );
+
+        template<typename T>
+        std::enable_if_t<
+            !std::is_enum<T>::value && !std::is_base_of<std::exception, T>::value,
+        std::string> convertUnstreamable( T const& ) {
+            return std::string(Detail::unprintableString);
+        }
+        template<typename T>
+        std::enable_if_t<
+            !std::is_enum<T>::value && std::is_base_of<std::exception, T>::value,
+         std::string> convertUnstreamable(T const& ex) {
+            return ex.what();
+        }
+
+
+        template<typename T>
+        std::enable_if_t<
+            std::is_enum<T>::value,
+        std::string> convertUnstreamable( T const& value ) {
+            return convertUnknownEnumToString( value );
+        }
+
+#if defined(_MANAGED)
+        //! Convert a CLR string to a utf8 std::string
+        template<typename T>
+        std::string clrReferenceToString( T^ ref ) {
+            if (ref == nullptr)
+                return std::string("null");
+            auto bytes = System::Text::Encoding::UTF8->GetBytes(ref->ToString());
+            cli::pin_ptr<System::Byte> p = &bytes[0];
+            return std::string(reinterpret_cast<char const *>(p), bytes->Length);
+        }
+#endif
+
+    } // namespace Detail
+
+
+    template <typename T, typename = void>
+    struct StringMaker {
+        template <typename Fake = T>
+        static
+        std::enable_if_t<::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>
+            convert(const Fake& value) {
+                ReusableStringStream rss;
+                // NB: call using the function-like syntax to avoid ambiguity with
+                // user-defined templated operator<< under clang.
+                rss.operator<<(value);
+                return rss.str();
+        }
+
+        template <typename Fake = T>
+        static
+        std::enable_if_t<!::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>
+            convert( const Fake& value ) {
+#if !defined(CATCH_CONFIG_FALLBACK_STRINGIFIER)
+            return Detail::convertUnstreamable(value);
+#else
+            return CATCH_CONFIG_FALLBACK_STRINGIFIER(value);
+#endif
+        }
+    };
+
+    namespace Detail {
+
+        // This function dispatches all stringification requests inside of Catch.
+        // Should be preferably called fully qualified, like ::Catch::Detail::stringify
+        template <typename T>
+        std::string stringify(const T& e) {
+            return ::Catch::StringMaker<std::remove_cv_t<std::remove_reference_t<T>>>::convert(e);
+        }
+
+        template<typename E>
+        std::string convertUnknownEnumToString( E e ) {
+            return ::Catch::Detail::stringify(static_cast<std::underlying_type_t<E>>(e));
+        }
+
+#if defined(_MANAGED)
+        template <typename T>
+        std::string stringify( T^ e ) {
+            return ::Catch::StringMaker<T^>::convert(e);
+        }
+#endif
+
+    } // namespace Detail
+
+    // Some predefined specializations
+
+    template<>
+    struct StringMaker<std::string> {
+        static std::string convert(const std::string& str);
+    };
+
+#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+    template<>
+    struct StringMaker<std::string_view> {
+        static std::string convert(std::string_view str);
+    };
+#endif
+
+    template<>
+    struct StringMaker<char const *> {
+        static std::string convert(char const * str);
+    };
+    template<>
+    struct StringMaker<char *> {
+        static std::string convert(char * str);
+    };
+
+#if defined(CATCH_CONFIG_WCHAR)
+    template<>
+    struct StringMaker<std::wstring> {
+        static std::string convert(const std::wstring& wstr);
+    };
+
+# ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+    template<>
+    struct StringMaker<std::wstring_view> {
+        static std::string convert(std::wstring_view str);
+    };
+# endif
+
+    template<>
+    struct StringMaker<wchar_t const *> {
+        static std::string convert(wchar_t const * str);
+    };
+    template<>
+    struct StringMaker<wchar_t *> {
+        static std::string convert(wchar_t * str);
+    };
+#endif // CATCH_CONFIG_WCHAR
+
+    template<size_t SZ>
+    struct StringMaker<char[SZ]> {
+        static std::string convert(char const* str) {
+            return Detail::convertIntoString(
+                StringRef( str, Detail::catch_strnlen( str, SZ ) ) );
+        }
+    };
+    template<size_t SZ>
+    struct StringMaker<signed char[SZ]> {
+        static std::string convert(signed char const* str) {
+            auto reinterpreted = reinterpret_cast<char const*>(str);
+            return Detail::convertIntoString(
+                StringRef(reinterpreted, Detail::catch_strnlen(reinterpreted, SZ)));
+        }
+    };
+    template<size_t SZ>
+    struct StringMaker<unsigned char[SZ]> {
+        static std::string convert(unsigned char const* str) {
+            auto reinterpreted = reinterpret_cast<char const*>(str);
+            return Detail::convertIntoString(
+                StringRef(reinterpreted, Detail::catch_strnlen(reinterpreted, SZ)));
+        }
+    };
+
+#if defined(CATCH_CONFIG_CPP17_BYTE)
+    template<>
+    struct StringMaker<std::byte> {
+        static std::string convert(std::byte value);
+    };
+#endif // defined(CATCH_CONFIG_CPP17_BYTE)
+    template<>
+    struct StringMaker<int> {
+        static std::string convert(int value);
+    };
+    template<>
+    struct StringMaker<long> {
+        static std::string convert(long value);
+    };
+    template<>
+    struct StringMaker<long long> {
+        static std::string convert(long long value);
+    };
+    template<>
+    struct StringMaker<unsigned int> {
+        static std::string convert(unsigned int value);
+    };
+    template<>
+    struct StringMaker<unsigned long> {
+        static std::string convert(unsigned long value);
+    };
+    template<>
+    struct StringMaker<unsigned long long> {
+        static std::string convert(unsigned long long value);
+    };
+
+    template<>
+    struct StringMaker<bool> {
+        static std::string convert(bool b) {
+            using namespace std::string_literals;
+            return b ? "true"s : "false"s;
+        }
+    };
+
+    template<>
+    struct StringMaker<char> {
+        static std::string convert(char c);
+    };
+    template<>
+    struct StringMaker<signed char> {
+        static std::string convert(signed char value);
+    };
+    template<>
+    struct StringMaker<unsigned char> {
+        static std::string convert(unsigned char value);
+    };
+
+    template<>
+    struct StringMaker<std::nullptr_t> {
+        static std::string convert(std::nullptr_t) {
+            using namespace std::string_literals;
+            return "nullptr"s;
+        }
+    };
+
+    template<>
+    struct StringMaker<float> {
+        static std::string convert(float value);
+        CATCH_EXPORT static int precision;
+    };
+
+    template<>
+    struct StringMaker<double> {
+        static std::string convert(double value);
+        CATCH_EXPORT static int precision;
+    };
+
+    template <typename T>
+    struct StringMaker<T*> {
+        template <typename U>
+        static std::string convert(U* p) {
+            if (p) {
+                return ::Catch::Detail::rawMemoryToString(p);
+            } else {
+                return "nullptr";
+            }
+        }
+    };
+
+    template <typename R, typename C>
+    struct StringMaker<R C::*> {
+        static std::string convert(R C::* p) {
+            if (p) {
+                return ::Catch::Detail::rawMemoryToString(p);
+            } else {
+                return "nullptr";
+            }
+        }
+    };
+
+#if defined(_MANAGED)
+    template <typename T>
+    struct StringMaker<T^> {
+        static std::string convert( T^ ref ) {
+            return ::Catch::Detail::clrReferenceToString(ref);
+        }
+    };
+#endif
+
+    namespace Detail {
+        template<typename InputIterator, typename Sentinel = InputIterator>
+        std::string rangeToString(InputIterator first, Sentinel last) {
+            ReusableStringStream rss;
+            rss << "{ ";
+            if (first != last) {
+                rss << ::Catch::Detail::stringify(*first);
+                for (++first; first != last; ++first)
+                    rss << ", " << ::Catch::Detail::stringify(*first);
+            }
+            rss << " }";
+            return rss.str();
+        }
+    }
+
+} // namespace Catch
+
+//////////////////////////////////////////////////////
+// Separate std-lib types stringification, so it can be selectively enabled
+// This means that we do not bring in their headers
+
+#if defined(CATCH_CONFIG_ENABLE_ALL_STRINGMAKERS)
+#  define CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
+#  define CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER
+#  define CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
+#  define CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER
+#endif
+
+// Separate std::pair specialization
+#if defined(CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER)
+#include <utility>
+namespace Catch {
+    template<typename T1, typename T2>
+    struct StringMaker<std::pair<T1, T2> > {
+        static std::string convert(const std::pair<T1, T2>& pair) {
+            ReusableStringStream rss;
+            rss << "{ "
+                << ::Catch::Detail::stringify(pair.first)
+                << ", "
+                << ::Catch::Detail::stringify(pair.second)
+                << " }";
+            return rss.str();
+        }
+    };
+}
+#endif // CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
+
+#if defined(CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_OPTIONAL)
+#include <optional>
+namespace Catch {
+    template<typename T>
+    struct StringMaker<std::optional<T> > {
+        static std::string convert(const std::optional<T>& optional) {
+            if (optional.has_value()) {
+                return ::Catch::Detail::stringify(*optional);
+            } else {
+                return "{ }";
+            }
+        }
+    };
+    template <>
+    struct StringMaker<std::nullopt_t> {
+        static std::string convert(const std::nullopt_t&) {
+            return "{ }";
+        }
+    };
+}
+#endif // CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER
+
+// Separate std::tuple specialization
+#if defined(CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER)
+#include <tuple>
+namespace Catch {
+    namespace Detail {
+        template<
+            typename Tuple,
+            std::size_t N = 0,
+            bool = (N < std::tuple_size<Tuple>::value)
+            >
+            struct TupleElementPrinter {
+            static void print(const Tuple& tuple, std::ostream& os) {
+                os << (N ? ", " : " ")
+                    << ::Catch::Detail::stringify(std::get<N>(tuple));
+                TupleElementPrinter<Tuple, N + 1>::print(tuple, os);
+            }
+        };
+
+        template<
+            typename Tuple,
+            std::size_t N
+        >
+            struct TupleElementPrinter<Tuple, N, false> {
+            static void print(const Tuple&, std::ostream&) {}
+        };
+
+    }
+
+
+    template<typename ...Types>
+    struct StringMaker<std::tuple<Types...>> {
+        static std::string convert(const std::tuple<Types...>& tuple) {
+            ReusableStringStream rss;
+            rss << '{';
+            Detail::TupleElementPrinter<std::tuple<Types...>>::print(tuple, rss.get());
+            rss << " }";
+            return rss.str();
+        }
+    };
+}
+#endif // CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER
+
+#if defined(CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_VARIANT)
+#include <variant>
+namespace Catch {
+    template<>
+    struct StringMaker<std::monostate> {
+        static std::string convert(const std::monostate&) {
+            return "{ }";
+        }
+    };
+
+    template<typename... Elements>
+    struct StringMaker<std::variant<Elements...>> {
+        static std::string convert(const std::variant<Elements...>& variant) {
+            if (variant.valueless_by_exception()) {
+                return "{valueless variant}";
+            } else {
+                return std::visit(
+                    [](const auto& value) {
+                        return ::Catch::Detail::stringify(value);
+                    },
+                    variant
+                );
+            }
+        }
+    };
+}
+#endif // CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
+
+namespace Catch {
+    // Import begin/ end from std here
+    using std::begin;
+    using std::end;
+
+    namespace Detail {
+        template <typename T, typename = void>
+        struct is_range_impl : std::false_type {};
+
+        template <typename T>
+        struct is_range_impl<T, void_t<decltype(begin(std::declval<T>()))>> : std::true_type {};
+    } // namespace Detail
+
+    template <typename T>
+    struct is_range : Detail::is_range_impl<T> {};
+
+#if defined(_MANAGED) // Managed types are never ranges
+    template <typename T>
+    struct is_range<T^> {
+        static const bool value = false;
+    };
+#endif
+
+    template<typename Range>
+    std::string rangeToString( Range const& range ) {
+        return ::Catch::Detail::rangeToString( begin( range ), end( range ) );
+    }
+
+    // Handle vector<bool> specially
+    template<typename Allocator>
+    std::string rangeToString( std::vector<bool, Allocator> const& v ) {
+        ReusableStringStream rss;
+        rss << "{ ";
+        bool first = true;
+        for( bool b : v ) {
+            if( first )
+                first = false;
+            else
+                rss << ", ";
+            rss << ::Catch::Detail::stringify( b );
+        }
+        rss << " }";
+        return rss.str();
+    }
+
+    template<typename R>
+    struct StringMaker<R, std::enable_if_t<is_range<R>::value && !::Catch::Detail::IsStreamInsertable<R>::value>> {
+        static std::string convert( R const& range ) {
+            return rangeToString( range );
+        }
+    };
+
+    template <typename T, size_t SZ>
+    struct StringMaker<T[SZ]> {
+        static std::string convert(T const(&arr)[SZ]) {
+            return rangeToString(arr);
+        }
+    };
+
+
+} // namespace Catch
+
+// Separate std::chrono::duration specialization
+#include <ctime>
+#include <ratio>
+#include <chrono>
+
+
+namespace Catch {
+
+template <class Ratio>
+struct ratio_string {
+    static std::string symbol() {
+        Catch::ReusableStringStream rss;
+        rss << '[' << Ratio::num << '/'
+            << Ratio::den << ']';
+        return rss.str();
+    }
+};
+
+template <>
+struct ratio_string<std::atto> {
+    static char symbol() { return 'a'; }
+};
+template <>
+struct ratio_string<std::femto> {
+    static char symbol() { return 'f'; }
+};
+template <>
+struct ratio_string<std::pico> {
+    static char symbol() { return 'p'; }
+};
+template <>
+struct ratio_string<std::nano> {
+    static char symbol() { return 'n'; }
+};
+template <>
+struct ratio_string<std::micro> {
+    static char symbol() { return 'u'; }
+};
+template <>
+struct ratio_string<std::milli> {
+    static char symbol() { return 'm'; }
+};
+
+    ////////////
+    // std::chrono::duration specializations
+    template<typename Value, typename Ratio>
+    struct StringMaker<std::chrono::duration<Value, Ratio>> {
+        static std::string convert(std::chrono::duration<Value, Ratio> const& duration) {
+            ReusableStringStream rss;
+            rss << duration.count() << ' ' << ratio_string<Ratio>::symbol() << 's';
+            return rss.str();
+        }
+    };
+    template<typename Value>
+    struct StringMaker<std::chrono::duration<Value, std::ratio<1>>> {
+        static std::string convert(std::chrono::duration<Value, std::ratio<1>> const& duration) {
+            ReusableStringStream rss;
+            rss << duration.count() << " s";
+            return rss.str();
+        }
+    };
+    template<typename Value>
+    struct StringMaker<std::chrono::duration<Value, std::ratio<60>>> {
+        static std::string convert(std::chrono::duration<Value, std::ratio<60>> const& duration) {
+            ReusableStringStream rss;
+            rss << duration.count() << " m";
+            return rss.str();
+        }
+    };
+    template<typename Value>
+    struct StringMaker<std::chrono::duration<Value, std::ratio<3600>>> {
+        static std::string convert(std::chrono::duration<Value, std::ratio<3600>> const& duration) {
+            ReusableStringStream rss;
+            rss << duration.count() << " h";
+            return rss.str();
+        }
+    };
+
+    ////////////
+    // std::chrono::time_point specialization
+    // Generic time_point cannot be specialized, only std::chrono::time_point<system_clock>
+    template<typename Clock, typename Duration>
+    struct StringMaker<std::chrono::time_point<Clock, Duration>> {
+        static std::string convert(std::chrono::time_point<Clock, Duration> const& time_point) {
+            return ::Catch::Detail::stringify(time_point.time_since_epoch()) + " since epoch";
+        }
+    };
+    // std::chrono::time_point<system_clock> specialization
+    template<typename Duration>
+    struct StringMaker<std::chrono::time_point<std::chrono::system_clock, Duration>> {
+        static std::string convert(std::chrono::time_point<std::chrono::system_clock, Duration> const& time_point) {
+            auto converted = std::chrono::system_clock::to_time_t(time_point);
+
+#ifdef _MSC_VER
+            std::tm timeInfo = {};
+            gmtime_s(&timeInfo, &converted);
+#else
+            std::tm* timeInfo = std::gmtime(&converted);
+#endif
+
+            auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
+            char timeStamp[timeStampSize];
+            const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";
+
+#ifdef _MSC_VER
+            std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
+#else
+            std::strftime(timeStamp, timeStampSize, fmt, timeInfo);
+#endif
+            return std::string(timeStamp, timeStampSize - 1);
+        }
+    };
+}
+
+
+#define INTERNAL_CATCH_REGISTER_ENUM( enumName, ... ) \
+namespace Catch { \
+    template<> struct StringMaker<enumName> { \
+        static std::string convert( enumName value ) { \
+            static const auto& enumInfo = ::Catch::getMutableRegistryHub().getMutableEnumValuesRegistry().registerEnum( #enumName, #__VA_ARGS__, { __VA_ARGS__ } ); \
+            return static_cast<std::string>(enumInfo.lookup( static_cast<int>( value ) )); \
+        } \
+    }; \
+}
+
+#define CATCH_REGISTER_ENUM( enumName, ... ) INTERNAL_CATCH_REGISTER_ENUM( enumName, __VA_ARGS__ )
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+#endif // CATCH_TOSTRING_HPP_INCLUDED
+
+#include <type_traits>
+
+namespace Catch {
+
+    class Approx {
+    private:
+        bool equalityComparisonImpl(double other) const;
+        // Sets and validates the new margin (margin >= 0)
+        void setMargin(double margin);
+        // Sets and validates the new epsilon (0 < epsilon < 1)
+        void setEpsilon(double epsilon);
+
+    public:
+        explicit Approx ( double value );
+
+        static Approx custom();
+
+        Approx operator-() const;
+
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+        Approx operator()( T const& value ) const {
+            Approx approx( static_cast<double>(value) );
+            approx.m_epsilon = m_epsilon;
+            approx.m_margin = m_margin;
+            approx.m_scale = m_scale;
+            return approx;
+        }
+
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+        explicit Approx( T const& value ): Approx(static_cast<double>(value))
+        {}
+
+
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+        friend bool operator == ( const T& lhs, Approx const& rhs ) {
+            auto lhs_v = static_cast<double>(lhs);
+            return rhs.equalityComparisonImpl(lhs_v);
+        }
+
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+        friend bool operator == ( Approx const& lhs, const T& rhs ) {
+            return operator==( rhs, lhs );
+        }
+
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+        friend bool operator != ( T const& lhs, Approx const& rhs ) {
+            return !operator==( lhs, rhs );
+        }
+
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+        friend bool operator != ( Approx const& lhs, T const& rhs ) {
+            return !operator==( rhs, lhs );
+        }
+
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+        friend bool operator <= ( T const& lhs, Approx const& rhs ) {
+            return static_cast<double>(lhs) < rhs.m_value || lhs == rhs;
+        }
+
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+        friend bool operator <= ( Approx const& lhs, T const& rhs ) {
+            return lhs.m_value < static_cast<double>(rhs) || lhs == rhs;
+        }
+
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+        friend bool operator >= ( T const& lhs, Approx const& rhs ) {
+            return static_cast<double>(lhs) > rhs.m_value || lhs == rhs;
+        }
+
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+        friend bool operator >= ( Approx const& lhs, T const& rhs ) {
+            return lhs.m_value > static_cast<double>(rhs) || lhs == rhs;
+        }
+
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+        Approx& epsilon( T const& newEpsilon ) {
+            const auto epsilonAsDouble = static_cast<double>(newEpsilon);
+            setEpsilon(epsilonAsDouble);
+            return *this;
+        }
+
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+        Approx& margin( T const& newMargin ) {
+            const auto marginAsDouble = static_cast<double>(newMargin);
+            setMargin(marginAsDouble);
+            return *this;
+        }
+
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+        Approx& scale( T const& newScale ) {
+            m_scale = static_cast<double>(newScale);
+            return *this;
+        }
+
+        std::string toString() const;
+
+    private:
+        double m_epsilon;
+        double m_margin;
+        double m_scale;
+        double m_value;
+    };
+
+namespace literals {
+    Approx operator ""_a(long double val);
+    Approx operator ""_a(unsigned long long val);
+} // end namespace literals
+
+template<>
+struct StringMaker<Catch::Approx> {
+    static std::string convert(Catch::Approx const& value);
+};
+
+} // end namespace Catch
+
+#endif // CATCH_APPROX_HPP_INCLUDED
+
+
+#ifndef CATCH_ASSERTION_INFO_HPP_INCLUDED
+#define CATCH_ASSERTION_INFO_HPP_INCLUDED
+
+
+
+#ifndef CATCH_SOURCE_LINE_INFO_HPP_INCLUDED
+#define CATCH_SOURCE_LINE_INFO_HPP_INCLUDED
+
+#include <cstddef>
+#include <iosfwd>
+
+namespace Catch {
+
+    struct SourceLineInfo {
+
+        SourceLineInfo() = delete;
+        constexpr SourceLineInfo( char const* _file, std::size_t _line ) noexcept:
+            file( _file ),
+            line( _line )
+        {}
+
+        bool operator == ( SourceLineInfo const& other ) const noexcept;
+        bool operator < ( SourceLineInfo const& other ) const noexcept;
+
+        char const* file;
+        std::size_t line;
+
+        friend std::ostream& operator << (std::ostream& os, SourceLineInfo const& info);
+    };
+}
+
+#define CATCH_INTERNAL_LINEINFO \
+    ::Catch::SourceLineInfo( __FILE__, static_cast<std::size_t>( __LINE__ ) )
+
+#endif // CATCH_SOURCE_LINE_INFO_HPP_INCLUDED
+
+namespace Catch {
+
+    struct AssertionInfo {
+        // AssertionInfo() = delete;
+
+        StringRef macroName;
+        SourceLineInfo lineInfo;
+        StringRef capturedExpression;
+        ResultDisposition::Flags resultDisposition;
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_ASSERTION_INFO_HPP_INCLUDED
+
+
+#ifndef CATCH_ASSERTION_RESULT_HPP_INCLUDED
+#define CATCH_ASSERTION_RESULT_HPP_INCLUDED
+
+
+
+#ifndef CATCH_LAZY_EXPR_HPP_INCLUDED
+#define CATCH_LAZY_EXPR_HPP_INCLUDED
+
+#include <iosfwd>
+
+namespace Catch {
+
+    class ITransientExpression;
+
+    class LazyExpression {
+        friend class AssertionHandler;
+        friend struct AssertionStats;
+        friend class RunContext;
+
+        ITransientExpression const* m_transientExpression = nullptr;
+        bool m_isNegated;
+    public:
+        constexpr LazyExpression( bool isNegated ):
+            m_isNegated(isNegated)
+        {}
+        constexpr LazyExpression(LazyExpression const& other) = default;
+        LazyExpression& operator = ( LazyExpression const& ) = delete;
+
+        constexpr explicit operator bool() const {
+            return m_transientExpression != nullptr;
+        }
+
+        friend auto operator << ( std::ostream& os, LazyExpression const& lazyExpr ) -> std::ostream&;
+    };
+
+} // namespace Catch
+
+#endif // CATCH_LAZY_EXPR_HPP_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+    struct AssertionResultData
+    {
+        AssertionResultData() = delete;
+
+        AssertionResultData( ResultWas::OfType _resultType, LazyExpression const& _lazyExpression );
+
+        std::string message;
+        mutable std::string reconstructedExpression;
+        LazyExpression lazyExpression;
+        ResultWas::OfType resultType;
+
+        std::string reconstructExpression() const;
+    };
+
+    class AssertionResult {
+    public:
+        AssertionResult() = delete;
+        AssertionResult( AssertionInfo const& info, AssertionResultData&& data );
+
+        bool isOk() const;
+        bool succeeded() const;
+        ResultWas::OfType getResultType() const;
+        bool hasExpression() const;
+        bool hasMessage() const;
+        std::string getExpression() const;
+        std::string getExpressionInMacro() const;
+        bool hasExpandedExpression() const;
+        std::string getExpandedExpression() const;
+        StringRef getMessage() const;
+        SourceLineInfo getSourceInfo() const;
+        StringRef getTestMacroName() const;
+
+    //protected:
+        AssertionInfo m_info;
+        AssertionResultData m_resultData;
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_ASSERTION_RESULT_HPP_INCLUDED
+
+
+#ifndef CATCH_CASE_SENSITIVE_HPP_INCLUDED
+#define CATCH_CASE_SENSITIVE_HPP_INCLUDED
+
+namespace Catch {
+
+    enum class CaseSensitive { Yes, No };
+
+} // namespace Catch
+
+#endif // CATCH_CASE_SENSITIVE_HPP_INCLUDED
+
+
+#ifndef CATCH_CONFIG_HPP_INCLUDED
+#define CATCH_CONFIG_HPP_INCLUDED
+
+
+
+#ifndef CATCH_TEST_SPEC_HPP_INCLUDED
+#define CATCH_TEST_SPEC_HPP_INCLUDED
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+
+
+#ifndef CATCH_WILDCARD_PATTERN_HPP_INCLUDED
+#define CATCH_WILDCARD_PATTERN_HPP_INCLUDED
+
+
+#include <string>
+
+namespace Catch
+{
+    class WildcardPattern {
+        enum WildcardPosition {
+            NoWildcard = 0,
+            WildcardAtStart = 1,
+            WildcardAtEnd = 2,
+            WildcardAtBothEnds = WildcardAtStart | WildcardAtEnd
+        };
+
+    public:
+
+        WildcardPattern( std::string const& pattern, CaseSensitive caseSensitivity );
+        bool matches( std::string const& str ) const;
+
+    private:
+        std::string normaliseString( std::string const& str ) const;
+        CaseSensitive m_caseSensitivity;
+        WildcardPosition m_wildcard = NoWildcard;
+        std::string m_pattern;
+    };
+}
+
+#endif // CATCH_WILDCARD_PATTERN_HPP_INCLUDED
+
+#include <iosfwd>
+#include <string>
+#include <vector>
+
+namespace Catch {
+
+    class IConfig;
+    struct TestCaseInfo;
+    class TestCaseHandle;
+
+    class TestSpec {
+
+        class Pattern {
+        public:
+            explicit Pattern( std::string const& name );
+            virtual ~Pattern();
+            virtual bool matches( TestCaseInfo const& testCase ) const = 0;
+            std::string const& name() const;
+        private:
+            virtual void serializeTo( std::ostream& out ) const = 0;
+            // Writes string that would be reparsed into the pattern
+            friend std::ostream& operator<<(std::ostream& out,
+                                            Pattern const& pattern) {
+                pattern.serializeTo( out );
+                return out;
+            }
+
+            std::string const m_name;
+        };
+
+        class NamePattern : public Pattern {
+        public:
+            explicit NamePattern( std::string const& name, std::string const& filterString );
+            bool matches( TestCaseInfo const& testCase ) const override;
+        private:
+            void serializeTo( std::ostream& out ) const override;
+
+            WildcardPattern m_wildcardPattern;
+        };
+
+        class TagPattern : public Pattern {
+        public:
+            explicit TagPattern( std::string const& tag, std::string const& filterString );
+            bool matches( TestCaseInfo const& testCase ) const override;
+        private:
+            void serializeTo( std::ostream& out ) const override;
+
+            std::string m_tag;
+        };
+
+        struct Filter {
+            std::vector<Detail::unique_ptr<Pattern>> m_required;
+            std::vector<Detail::unique_ptr<Pattern>> m_forbidden;
+
+            //! Serializes this filter into a string that would be parsed into
+            //! an equivalent filter
+            void serializeTo( std::ostream& out ) const;
+            friend std::ostream& operator<<(std::ostream& out, Filter const& f) {
+                f.serializeTo( out );
+                return out;
+            }
+
+            bool matches( TestCaseInfo const& testCase ) const;
+        };
+
+        static std::string extractFilterName( Filter const& filter );
+
+    public:
+        struct FilterMatch {
+            std::string name;
+            std::vector<TestCaseHandle const*> tests;
+        };
+        using Matches = std::vector<FilterMatch>;
+        using vectorStrings = std::vector<std::string>;
+
+        bool hasFilters() const;
+        bool matches( TestCaseInfo const& testCase ) const;
+        Matches matchesByFilter( std::vector<TestCaseHandle> const& testCases, IConfig const& config ) const;
+        const vectorStrings & getInvalidSpecs() const;
+
+    private:
+        std::vector<Filter> m_filters;
+        std::vector<std::string> m_invalidSpecs;
+
+        friend class TestSpecParser;
+        //! Serializes this test spec into a string that would be parsed into
+        //! equivalent test spec
+        void serializeTo( std::ostream& out ) const;
+        friend std::ostream& operator<<(std::ostream& out,
+                                        TestSpec const& spec) {
+            spec.serializeTo( out );
+            return out;
+        }
+    };
+}
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+#endif // CATCH_TEST_SPEC_HPP_INCLUDED
+
+
+#ifndef CATCH_OPTIONAL_HPP_INCLUDED
+#define CATCH_OPTIONAL_HPP_INCLUDED
+
+
+#include <cassert>
+
+namespace Catch {
+
+    // An optional type
+    template<typename T>
+    class Optional {
+    public:
+        Optional(): nullableValue( nullptr ) {}
+        ~Optional() { reset(); }
+
+        Optional( T const& _value ):
+            nullableValue( new ( storage ) T( _value ) ) {}
+        Optional( T&& _value ):
+            nullableValue( new ( storage ) T( CATCH_MOVE( _value ) ) ) {}
+
+        Optional& operator=( T const& _value ) {
+            reset();
+            nullableValue = new ( storage ) T( _value );
+            return *this;
+        }
+        Optional& operator=( T&& _value ) {
+            reset();
+            nullableValue = new ( storage ) T( CATCH_MOVE( _value ) );
+            return *this;
+        }
+
+        Optional( Optional const& _other ):
+            nullableValue( _other ? new ( storage ) T( *_other ) : nullptr ) {}
+        Optional( Optional&& _other ):
+            nullableValue( _other ? new ( storage ) T( CATCH_MOVE( *_other ) )
+                                  : nullptr ) {}
+
+        Optional& operator=( Optional const& _other ) {
+            if ( &_other != this ) {
+                reset();
+                if ( _other ) { nullableValue = new ( storage ) T( *_other ); }
+            }
+            return *this;
+        }
+        Optional& operator=( Optional&& _other ) {
+            if ( &_other != this ) {
+                reset();
+                if ( _other ) {
+                    nullableValue = new ( storage ) T( CATCH_MOVE( *_other ) );
+                }
+            }
+            return *this;
+        }
+
+        void reset() {
+            if ( nullableValue ) { nullableValue->~T(); }
+            nullableValue = nullptr;
+        }
+
+        T& operator*() {
+            assert(nullableValue);
+            return *nullableValue;
+        }
+        T const& operator*() const {
+            assert(nullableValue);
+            return *nullableValue;
+        }
+        T* operator->() {
+            assert(nullableValue);
+            return nullableValue;
+        }
+        const T* operator->() const {
+            assert(nullableValue);
+            return nullableValue;
+        }
+
+        T valueOr( T const& defaultValue ) const {
+            return nullableValue ? *nullableValue : defaultValue;
+        }
+
+        bool some() const { return nullableValue != nullptr; }
+        bool none() const { return nullableValue == nullptr; }
+
+        bool operator !() const { return nullableValue == nullptr; }
+        explicit operator bool() const {
+            return some();
+        }
+
+        friend bool operator==(Optional const& a, Optional const& b) {
+            if (a.none() && b.none()) {
+                return true;
+            } else if (a.some() && b.some()) {
+                return *a == *b;
+            } else {
+                return false;
+            }
+        }
+        friend bool operator!=(Optional const& a, Optional const& b) {
+            return !( a == b );
+        }
+
+    private:
+        T* nullableValue;
+        alignas(alignof(T)) char storage[sizeof(T)];
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_OPTIONAL_HPP_INCLUDED
+
+
+#ifndef CATCH_RANDOM_SEED_GENERATION_HPP_INCLUDED
+#define CATCH_RANDOM_SEED_GENERATION_HPP_INCLUDED
+
+#include <cstdint>
+
+namespace Catch {
+
+    enum class GenerateFrom {
+        Time,
+        RandomDevice,
+        //! Currently equivalent to RandomDevice, but can change at any point
+        Default
+    };
+
+    std::uint32_t generateRandomSeed(GenerateFrom from);
+
+} // end namespace Catch
+
+#endif // CATCH_RANDOM_SEED_GENERATION_HPP_INCLUDED
+
+
+#ifndef CATCH_REPORTER_SPEC_PARSER_HPP_INCLUDED
+#define CATCH_REPORTER_SPEC_PARSER_HPP_INCLUDED
+
+
+#include <map>
+#include <string>
+#include <vector>
+
+namespace Catch {
+
+    enum class ColourMode : std::uint8_t;
+
+    namespace Detail {
+        //! Splits the reporter spec into reporter name and kv-pair options
+        std::vector<std::string> splitReporterSpec( StringRef reporterSpec );
+
+        Optional<ColourMode> stringToColourMode( StringRef colourMode );
+    }
+
+    /**
+     * Structured reporter spec that a reporter can be created from
+     *
+     * Parsing has been validated, but semantics have not. This means e.g.
+     * that the colour mode is known to Catch2, but it might not be
+     * compiled into the binary, and the output filename might not be
+     * openable.
+     */
+    class ReporterSpec {
+        std::string m_name;
+        Optional<std::string> m_outputFileName;
+        Optional<ColourMode> m_colourMode;
+        std::map<std::string, std::string> m_customOptions;
+
+        friend bool operator==( ReporterSpec const& lhs,
+                                ReporterSpec const& rhs );
+        friend bool operator!=( ReporterSpec const& lhs,
+                                ReporterSpec const& rhs ) {
+            return !( lhs == rhs );
+        }
+
+    public:
+        ReporterSpec(
+            std::string name,
+            Optional<std::string> outputFileName,
+            Optional<ColourMode> colourMode,
+            std::map<std::string, std::string> customOptions );
+
+        std::string const& name() const { return m_name; }
+
+        Optional<std::string> const& outputFile() const {
+            return m_outputFileName;
+        }
+
+        Optional<ColourMode> const& colourMode() const { return m_colourMode; }
+
+        std::map<std::string, std::string> const& customOptions() const {
+            return m_customOptions;
+        }
+    };
+
+    /**
+     * Parses provided reporter spec string into
+     *
+     * Returns empty optional on errors, e.g.
+     *  * field that is not first and not a key+value pair
+     *  * duplicated keys in kv pair
+     *  * unknown catch reporter option
+     *  * empty key/value in an custom kv pair
+     *  * ...
+     */
+    Optional<ReporterSpec> parseReporterSpec( StringRef reporterSpec );
+
+}
+
+#endif // CATCH_REPORTER_SPEC_PARSER_HPP_INCLUDED
+
+#include <chrono>
+#include <map>
+#include <string>
+#include <vector>
+
+namespace Catch {
+
+    class IStream;
+
+    /**
+     * `ReporterSpec` but with the defaults filled in.
+     *
+     * Like `ReporterSpec`, the semantics are unchecked.
+     */
+    struct ProcessedReporterSpec {
+        std::string name;
+        std::string outputFilename;
+        ColourMode colourMode;
+        std::map<std::string, std::string> customOptions;
+        friend bool operator==( ProcessedReporterSpec const& lhs,
+                                ProcessedReporterSpec const& rhs );
+        friend bool operator!=( ProcessedReporterSpec const& lhs,
+                                ProcessedReporterSpec const& rhs ) {
+            return !( lhs == rhs );
+        }
+    };
+
+    struct ConfigData {
+
+        bool listTests = false;
+        bool listTags = false;
+        bool listReporters = false;
+        bool listListeners = false;
+
+        bool showSuccessfulTests = false;
+        bool shouldDebugBreak = false;
+        bool noThrow = false;
+        bool showHelp = false;
+        bool showInvisibles = false;
+        bool filenamesAsTags = false;
+        bool libIdentify = false;
+        bool allowZeroTests = false;
+
+        int abortAfter = -1;
+        uint32_t rngSeed = generateRandomSeed(GenerateFrom::Default);
+
+        unsigned int shardCount = 1;
+        unsigned int shardIndex = 0;
+
+        bool skipBenchmarks = false;
+        bool benchmarkNoAnalysis = false;
+        unsigned int benchmarkSamples = 100;
+        double benchmarkConfidenceInterval = 0.95;
+        unsigned int benchmarkResamples = 100'000;
+        std::chrono::milliseconds::rep benchmarkWarmupTime = 100;
+
+        Verbosity verbosity = Verbosity::Normal;
+        WarnAbout::What warnings = WarnAbout::Nothing;
+        ShowDurations showDurations = ShowDurations::DefaultForReporter;
+        double minDuration = -1;
+        TestRunOrder runOrder = TestRunOrder::Declared;
+        ColourMode defaultColourMode = ColourMode::PlatformDefault;
+        WaitForKeypress::When waitForKeypress = WaitForKeypress::Never;
+
+        std::string defaultOutputFilename;
+        std::string name;
+        std::string processName;
+        std::vector<ReporterSpec> reporterSpecifications;
+
+        std::vector<std::string> testsOrTags;
+        std::vector<std::string> sectionsToRun;
+    };
+
+
+    class Config : public IConfig {
+    public:
+
+        Config() = default;
+        Config( ConfigData const& data );
+        ~Config() override; // = default in the cpp file
+
+        bool listTests() const;
+        bool listTags() const;
+        bool listReporters() const;
+        bool listListeners() const;
+
+        std::vector<ReporterSpec> const& getReporterSpecs() const;
+        std::vector<ProcessedReporterSpec> const&
+        getProcessedReporterSpecs() const;
+
+        std::vector<std::string> const& getTestsOrTags() const override;
+        std::vector<std::string> const& getSectionsToRun() const override;
+
+        TestSpec const& testSpec() const override;
+        bool hasTestFilters() const override;
+
+        bool showHelp() const;
+
+        // IConfig interface
+        bool allowThrows() const override;
+        StringRef name() const override;
+        bool includeSuccessfulResults() const override;
+        bool warnAboutMissingAssertions() const override;
+        bool warnAboutUnmatchedTestSpecs() const override;
+        bool zeroTestsCountAsSuccess() const override;
+        ShowDurations showDurations() const override;
+        double minDuration() const override;
+        TestRunOrder runOrder() const override;
+        uint32_t rngSeed() const override;
+        unsigned int shardCount() const override;
+        unsigned int shardIndex() const override;
+        ColourMode defaultColourMode() const override;
+        bool shouldDebugBreak() const override;
+        int abortAfter() const override;
+        bool showInvisibles() const override;
+        Verbosity verbosity() const override;
+        bool skipBenchmarks() const override;
+        bool benchmarkNoAnalysis() const override;
+        unsigned int benchmarkSamples() const override;
+        double benchmarkConfidenceInterval() const override;
+        unsigned int benchmarkResamples() const override;
+        std::chrono::milliseconds benchmarkWarmupTime() const override;
+
+    private:
+        // Reads Bazel env vars and applies them to the config
+        void readBazelEnvVars();
+
+        ConfigData m_data;
+        std::vector<ProcessedReporterSpec> m_processedReporterSpecs;
+        TestSpec m_testSpec;
+        bool m_hasTestFilters = false;
+    };
+} // end namespace Catch
+
+#endif // CATCH_CONFIG_HPP_INCLUDED
+
+
+#ifndef CATCH_GET_RANDOM_SEED_HPP_INCLUDED
+#define CATCH_GET_RANDOM_SEED_HPP_INCLUDED
+
+#include <cstdint>
+
+namespace Catch {
+    //! Returns Catch2's current RNG seed.
+    std::uint32_t getSeed();
+}
+
+#endif // CATCH_GET_RANDOM_SEED_HPP_INCLUDED
+
+
+#ifndef CATCH_MESSAGE_HPP_INCLUDED
+#define CATCH_MESSAGE_HPP_INCLUDED
+
+
+
+
+/** \file
+ * Wrapper for the CATCH_CONFIG_PREFIX_MESSAGES configuration option
+ *
+ * CATCH_CONFIG_PREFIX_ALL can be used to avoid clashes with other macros
+ * by prepending CATCH_. This may not be desirable if the only clashes are with
+ * logger macros such as INFO and WARN. In this cases
+ * CATCH_CONFIG_PREFIX_MESSAGES can be used to only prefix a small subset
+ * of relevant macros.
+ *
+ */
+
+#ifndef CATCH_CONFIG_PREFIX_MESSAGES_HPP_INCLUDED
+#define CATCH_CONFIG_PREFIX_MESSAGES_HPP_INCLUDED
+
+
+#if defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_PREFIX_MESSAGES)
+    #define CATCH_CONFIG_PREFIX_MESSAGES
+#endif
+
+#endif // CATCH_CONFIG_PREFIX_MESSAGES_HPP_INCLUDED
+
+
+#ifndef CATCH_STREAM_END_STOP_HPP_INCLUDED
+#define CATCH_STREAM_END_STOP_HPP_INCLUDED
+
+
+namespace Catch {
+
+    // Use this in variadic streaming macros to allow
+    //    << +StreamEndStop
+    // as well as
+    //    << stuff +StreamEndStop
+    struct StreamEndStop {
+        constexpr StringRef operator+() const { return StringRef(); }
+
+        template <typename T>
+        constexpr friend T const& operator+( T const& value, StreamEndStop ) {
+            return value;
+        }
+    };
+
+} // namespace Catch
+
+#endif // CATCH_STREAM_END_STOP_HPP_INCLUDED
+
+
+#ifndef CATCH_MESSAGE_INFO_HPP_INCLUDED
+#define CATCH_MESSAGE_INFO_HPP_INCLUDED
+
+
+#include <string>
+
+namespace Catch {
+
+    struct MessageInfo {
+        MessageInfo(    StringRef _macroName,
+                        SourceLineInfo const& _lineInfo,
+                        ResultWas::OfType _type );
+
+        StringRef macroName;
+        std::string message;
+        SourceLineInfo lineInfo;
+        ResultWas::OfType type;
+        unsigned int sequence;
+
+        bool operator == (MessageInfo const& other) const {
+            return sequence == other.sequence;
+        }
+        bool operator < (MessageInfo const& other) const {
+            return sequence < other.sequence;
+        }
+    private:
+        static unsigned int globalCount;
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_MESSAGE_INFO_HPP_INCLUDED
+
+#include <string>
+#include <vector>
+
+namespace Catch {
+
+    struct SourceLineInfo;
+    class IResultCapture;
+
+    struct MessageStream {
+
+        template<typename T>
+        MessageStream& operator << ( T const& value ) {
+            m_stream << value;
+            return *this;
+        }
+
+        ReusableStringStream m_stream;
+    };
+
+    struct MessageBuilder : MessageStream {
+        MessageBuilder( StringRef macroName,
+                        SourceLineInfo const& lineInfo,
+                        ResultWas::OfType type ):
+            m_info(macroName, lineInfo, type) {}
+
+        template<typename T>
+        MessageBuilder&& operator << ( T const& value ) && {
+            m_stream << value;
+            return CATCH_MOVE(*this);
+        }
+
+        MessageInfo m_info;
+    };
+
+    class ScopedMessage {
+    public:
+        explicit ScopedMessage( MessageBuilder&& builder );
+        ScopedMessage( ScopedMessage& duplicate ) = delete;
+        ScopedMessage( ScopedMessage&& old ) noexcept;
+        ~ScopedMessage();
+
+        MessageInfo m_info;
+        bool m_moved = false;
+    };
+
+    class Capturer {
+        std::vector<MessageInfo> m_messages;
+        IResultCapture& m_resultCapture;
+        size_t m_captured = 0;
+    public:
+        Capturer( StringRef macroName, SourceLineInfo const& lineInfo, ResultWas::OfType resultType, StringRef names );
+
+        Capturer(Capturer const&) = delete;
+        Capturer& operator=(Capturer const&) = delete;
+
+        ~Capturer();
+
+        void captureValue( size_t index, std::string const& value );
+
+        template<typename T>
+        void captureValues( size_t index, T const& value ) {
+            captureValue( index, Catch::Detail::stringify( value ) );
+        }
+
+        template<typename T, typename... Ts>
+        void captureValues( size_t index, T const& value, Ts const&... values ) {
+            captureValue( index, Catch::Detail::stringify(value) );
+            captureValues( index+1, values... );
+        }
+    };
+
+} // end namespace Catch
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_MSG( macroName, messageType, resultDisposition, ... ) \
+    do { \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::StringRef(), resultDisposition ); \
+        catchAssertionHandler.handleMessage( messageType, ( Catch::MessageStream() << __VA_ARGS__ + ::Catch::StreamEndStop() ).m_stream.str() ); \
+        catchAssertionHandler.complete(); \
+    } while( false )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_CAPTURE( varName, macroName, ... ) \
+    Catch::Capturer varName( macroName##_catch_sr,        \
+                             CATCH_INTERNAL_LINEINFO,     \
+                             Catch::ResultWas::Info,      \
+                             #__VA_ARGS__##_catch_sr );   \
+    varName.captureValues( 0, __VA_ARGS__ )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_INFO( macroName, log ) \
+    const Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage )( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_UNSCOPED_INFO( macroName, log ) \
+    Catch::getResultCapture().emplaceUnscopedMessage( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log )
+
+
+#if defined(CATCH_CONFIG_PREFIX_MESSAGES) && !defined(CATCH_CONFIG_DISABLE)
+
+  #define CATCH_INFO( msg ) INTERNAL_CATCH_INFO( "CATCH_INFO", msg )
+  #define CATCH_UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "CATCH_UNSCOPED_INFO", msg )
+  #define CATCH_WARN( msg ) INTERNAL_CATCH_MSG( "CATCH_WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
+  #define CATCH_CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CATCH_CAPTURE", __VA_ARGS__ )
+
+#elif defined(CATCH_CONFIG_PREFIX_MESSAGES) && defined(CATCH_CONFIG_DISABLE)
+
+  #define CATCH_INFO( msg )          (void)(0)
+  #define CATCH_UNSCOPED_INFO( msg ) (void)(0)
+  #define CATCH_WARN( msg )          (void)(0)
+  #define CATCH_CAPTURE( ... )       (void)(0)
+
+#elif !defined(CATCH_CONFIG_PREFIX_MESSAGES) && !defined(CATCH_CONFIG_DISABLE)
+
+  #define INFO( msg ) INTERNAL_CATCH_INFO( "INFO", msg )
+  #define UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "UNSCOPED_INFO", msg )
+  #define WARN( msg ) INTERNAL_CATCH_MSG( "WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
+  #define CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CAPTURE", __VA_ARGS__ )
+
+#elif !defined(CATCH_CONFIG_PREFIX_MESSAGES) && defined(CATCH_CONFIG_DISABLE)
+
+  #define INFO( msg )          (void)(0)
+  #define UNSCOPED_INFO( msg ) (void)(0)
+  #define WARN( msg )          (void)(0)
+  #define CAPTURE( ... )       (void)(0)
+
+#endif // end of user facing macro declarations
+
+
+
+
+#endif // CATCH_MESSAGE_HPP_INCLUDED
+
+
+#ifndef CATCH_SECTION_INFO_HPP_INCLUDED
+#define CATCH_SECTION_INFO_HPP_INCLUDED
+
+
+
+#ifndef CATCH_TOTALS_HPP_INCLUDED
+#define CATCH_TOTALS_HPP_INCLUDED
+
+#include <cstdint>
+
+namespace Catch {
+
+    struct Counts {
+        Counts operator - ( Counts const& other ) const;
+        Counts& operator += ( Counts const& other );
+
+        std::uint64_t total() const;
+        bool allPassed() const;
+        bool allOk() const;
+
+        std::uint64_t passed = 0;
+        std::uint64_t failed = 0;
+        std::uint64_t failedButOk = 0;
+        std::uint64_t skipped = 0;
+    };
+
+    struct Totals {
+
+        Totals operator - ( Totals const& other ) const;
+        Totals& operator += ( Totals const& other );
+
+        Totals delta( Totals const& prevTotals ) const;
+
+        Counts assertions;
+        Counts testCases;
+    };
+}
+
+#endif // CATCH_TOTALS_HPP_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+    struct SectionInfo {
+        // The last argument is ignored, so that people can write
+        // SECTION("ShortName", "Proper description that is long") and
+        // still use the `-c` flag comfortably.
+        SectionInfo( SourceLineInfo const& _lineInfo, std::string _name,
+                    const char* const = nullptr ):
+            name(CATCH_MOVE(_name)),
+            lineInfo(_lineInfo)
+            {}
+
+        std::string name;
+        SourceLineInfo lineInfo;
+    };
+
+    struct SectionEndInfo {
+        SectionInfo sectionInfo;
+        Counts prevAssertions;
+        double durationInSeconds;
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_SECTION_INFO_HPP_INCLUDED
+
+
+#ifndef CATCH_SESSION_HPP_INCLUDED
+#define CATCH_SESSION_HPP_INCLUDED
+
+
+
+#ifndef CATCH_COMMANDLINE_HPP_INCLUDED
+#define CATCH_COMMANDLINE_HPP_INCLUDED
+
+
+
+#ifndef CATCH_CLARA_HPP_INCLUDED
+#define CATCH_CLARA_HPP_INCLUDED
+
+#if defined( __clang__ )
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wweak-vtables"
+#    pragma clang diagnostic ignored "-Wshadow"
+#    pragma clang diagnostic ignored "-Wdeprecated"
+#endif
+
+#if defined( __GNUC__ )
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wsign-conversion"
+#endif
+
+#ifndef CLARA_CONFIG_OPTIONAL_TYPE
+#    ifdef __has_include
+#        if __has_include( <optional>) && __cplusplus >= 201703L
+#            include <optional>
+#            define CLARA_CONFIG_OPTIONAL_TYPE std::optional
+#        endif
+#    endif
+#endif
+
+
+#include <cassert>
+#include <memory>
+#include <ostream>
+#include <sstream>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+namespace Catch {
+    namespace Clara {
+
+        class Args;
+        class Parser;
+
+        // enum of result types from a parse
+        enum class ParseResultType {
+            Matched,
+            NoMatch,
+            ShortCircuitAll,
+            ShortCircuitSame
+        };
+
+        struct accept_many_t {};
+        constexpr accept_many_t accept_many {};
+
+        namespace Detail {
+            struct fake_arg {
+                template <typename T>
+                operator T();
+            };
+
+            template <typename F, typename = void>
+            struct is_unary_function : std::false_type {};
+
+            template <typename F>
+            struct is_unary_function<
+                F,
+                Catch::Detail::void_t<decltype(
+                    std::declval<F>()( fake_arg() ) )
+                >
+            > : std::true_type {};
+
+            // Traits for extracting arg and return type of lambdas (for single
+            // argument lambdas)
+            template <typename L>
+            struct UnaryLambdaTraits
+                : UnaryLambdaTraits<decltype( &L::operator() )> {};
+
+            template <typename ClassT, typename ReturnT, typename... Args>
+            struct UnaryLambdaTraits<ReturnT ( ClassT::* )( Args... ) const> {
+                static const bool isValid = false;
+            };
+
+            template <typename ClassT, typename ReturnT, typename ArgT>
+            struct UnaryLambdaTraits<ReturnT ( ClassT::* )( ArgT ) const> {
+                static const bool isValid = true;
+                using ArgType = std::remove_const_t<std::remove_reference_t<ArgT>>;
+                using ReturnType = ReturnT;
+            };
+
+            class TokenStream;
+
+            // Wraps a token coming from a token stream. These may not directly
+            // correspond to strings as a single string may encode an option +
+            // its argument if the : or = form is used
+            enum class TokenType { Option, Argument };
+            struct Token {
+                TokenType type;
+                StringRef token;
+            };
+
+            // Abstracts iterators into args as a stream of tokens, with option
+            // arguments uniformly handled
+            class TokenStream {
+                using Iterator = std::vector<StringRef>::const_iterator;
+                Iterator it;
+                Iterator itEnd;
+                std::vector<Token> m_tokenBuffer;
+                void loadBuffer();
+
+            public:
+                explicit TokenStream( Args const& args );
+                TokenStream( Iterator it, Iterator itEnd );
+
+                explicit operator bool() const {
+                    return !m_tokenBuffer.empty() || it != itEnd;
+                }
+
+                size_t count() const {
+                    return m_tokenBuffer.size() + ( itEnd - it );
+                }
+
+                Token operator*() const {
+                    assert( !m_tokenBuffer.empty() );
+                    return m_tokenBuffer.front();
+                }
+
+                Token const* operator->() const {
+                    assert( !m_tokenBuffer.empty() );
+                    return &m_tokenBuffer.front();
+                }
+
+                TokenStream& operator++();
+            };
+
+            //! Denotes type of a parsing result
+            enum class ResultType {
+                Ok,          ///< No errors
+                LogicError,  ///< Error in user-specified arguments for
+                             ///< construction
+                RuntimeError ///< Error in parsing inputs
+            };
+
+            class ResultBase {
+            protected:
+                ResultBase( ResultType type ): m_type( type ) {}
+                virtual ~ResultBase(); // = default;
+
+
+                ResultBase(ResultBase const&) = default;
+                ResultBase& operator=(ResultBase const&) = default;
+                ResultBase(ResultBase&&) = default;
+                ResultBase& operator=(ResultBase&&) = default;
+
+                virtual void enforceOk() const = 0;
+
+                ResultType m_type;
+            };
+
+            template <typename T>
+            class ResultValueBase : public ResultBase {
+            public:
+                T const& value() const& {
+                    enforceOk();
+                    return m_value;
+                }
+                T&& value() && {
+                    enforceOk();
+                    return CATCH_MOVE( m_value );
+                }
+
+            protected:
+                ResultValueBase( ResultType type ): ResultBase( type ) {}
+
+                ResultValueBase( ResultValueBase const& other ):
+                    ResultBase( other ) {
+                    if ( m_type == ResultType::Ok )
+                        new ( &m_value ) T( other.m_value );
+                }
+                ResultValueBase( ResultValueBase&& other ):
+                    ResultBase( other ) {
+                    if ( m_type == ResultType::Ok )
+                        new ( &m_value ) T( CATCH_MOVE(other.m_value) );
+                }
+
+
+                ResultValueBase( ResultType, T const& value ):
+                    ResultBase( ResultType::Ok ) {
+                    new ( &m_value ) T( value );
+                }
+                ResultValueBase( ResultType, T&& value ):
+                    ResultBase( ResultType::Ok ) {
+                    new ( &m_value ) T( CATCH_MOVE(value) );
+                }
+
+                ResultValueBase& operator=( ResultValueBase const& other ) {
+                    if ( m_type == ResultType::Ok )
+                        m_value.~T();
+                    ResultBase::operator=( other );
+                    if ( m_type == ResultType::Ok )
+                        new ( &m_value ) T( other.m_value );
+                    return *this;
+                }
+                ResultValueBase& operator=( ResultValueBase&& other ) {
+                    if ( m_type == ResultType::Ok ) m_value.~T();
+                    ResultBase::operator=( other );
+                    if ( m_type == ResultType::Ok )
+                        new ( &m_value ) T( CATCH_MOVE(other.m_value) );
+                    return *this;
+                }
+
+
+                ~ResultValueBase() override {
+                    if ( m_type == ResultType::Ok )
+                        m_value.~T();
+                }
+
+                union {
+                    T m_value;
+                };
+            };
+
+            template <> class ResultValueBase<void> : public ResultBase {
+            protected:
+                using ResultBase::ResultBase;
+            };
+
+            template <typename T = void>
+            class BasicResult : public ResultValueBase<T> {
+            public:
+                template <typename U>
+                explicit BasicResult( BasicResult<U> const& other ):
+                    ResultValueBase<T>( other.type() ),
+                    m_errorMessage( other.errorMessage() ) {
+                    assert( type() != ResultType::Ok );
+                }
+
+                template <typename U>
+                static auto ok( U&& value ) -> BasicResult {
+                    return { ResultType::Ok, CATCH_FORWARD(value) };
+                }
+                static auto ok() -> BasicResult { return { ResultType::Ok }; }
+                static auto logicError( std::string&& message )
+                    -> BasicResult {
+                    return { ResultType::LogicError, CATCH_MOVE(message) };
+                }
+                static auto runtimeError( std::string&& message )
+                    -> BasicResult {
+                    return { ResultType::RuntimeError, CATCH_MOVE(message) };
+                }
+
+                explicit operator bool() const {
+                    return m_type == ResultType::Ok;
+                }
+                auto type() const -> ResultType { return m_type; }
+                auto errorMessage() const -> std::string const& {
+                    return m_errorMessage;
+                }
+
+            protected:
+                void enforceOk() const override {
+
+                    // Errors shouldn't reach this point, but if they do
+                    // the actual error message will be in m_errorMessage
+                    assert( m_type != ResultType::LogicError );
+                    assert( m_type != ResultType::RuntimeError );
+                    if ( m_type != ResultType::Ok )
+                        std::abort();
+                }
+
+                std::string
+                    m_errorMessage; // Only populated if resultType is an error
+
+                BasicResult( ResultType type,
+                             std::string&& message ):
+                    ResultValueBase<T>( type ), m_errorMessage( CATCH_MOVE(message) ) {
+                    assert( m_type != ResultType::Ok );
+                }
+
+                using ResultValueBase<T>::ResultValueBase;
+                using ResultBase::m_type;
+            };
+
+            class ParseState {
+            public:
+                ParseState( ParseResultType type,
+                            TokenStream remainingTokens );
+
+                ParseResultType type() const { return m_type; }
+                TokenStream const& remainingTokens() const& {
+                    return m_remainingTokens;
+                }
+                TokenStream&& remainingTokens() && {
+                    return CATCH_MOVE( m_remainingTokens );
+                }
+
+            private:
+                ParseResultType m_type;
+                TokenStream m_remainingTokens;
+            };
+
+            using Result = BasicResult<void>;
+            using ParserResult = BasicResult<ParseResultType>;
+            using InternalParseResult = BasicResult<ParseState>;
+
+            struct HelpColumns {
+                std::string left;
+                StringRef descriptions;
+            };
+
+            template <typename T>
+            ParserResult convertInto( std::string const& source, T& target ) {
+                std::stringstream ss( source );
+                ss >> target;
+                if ( ss.fail() ) {
+                    return ParserResult::runtimeError(
+                        "Unable to convert '" + source +
+                        "' to destination type" );
+                } else {
+                    return ParserResult::ok( ParseResultType::Matched );
+                }
+            }
+            ParserResult convertInto( std::string const& source,
+                                      std::string& target );
+            ParserResult convertInto( std::string const& source, bool& target );
+
+#ifdef CLARA_CONFIG_OPTIONAL_TYPE
+            template <typename T>
+            auto convertInto( std::string const& source,
+                              CLARA_CONFIG_OPTIONAL_TYPE<T>& target )
+                -> ParserResult {
+                T temp;
+                auto result = convertInto( source, temp );
+                if ( result )
+                    target = CATCH_MOVE( temp );
+                return result;
+            }
+#endif // CLARA_CONFIG_OPTIONAL_TYPE
+
+            struct BoundRef : Catch::Detail::NonCopyable {
+                virtual ~BoundRef() = default;
+                virtual bool isContainer() const;
+                virtual bool isFlag() const;
+            };
+            struct BoundValueRefBase : BoundRef {
+                virtual auto setValue( std::string const& arg )
+                    -> ParserResult = 0;
+            };
+            struct BoundFlagRefBase : BoundRef {
+                virtual auto setFlag( bool flag ) -> ParserResult = 0;
+                bool isFlag() const override;
+            };
+
+            template <typename T> struct BoundValueRef : BoundValueRefBase {
+                T& m_ref;
+
+                explicit BoundValueRef( T& ref ): m_ref( ref ) {}
+
+                ParserResult setValue( std::string const& arg ) override {
+                    return convertInto( arg, m_ref );
+                }
+            };
+
+            template <typename T>
+            struct BoundValueRef<std::vector<T>> : BoundValueRefBase {
+                std::vector<T>& m_ref;
+
+                explicit BoundValueRef( std::vector<T>& ref ): m_ref( ref ) {}
+
+                auto isContainer() const -> bool override { return true; }
+
+                auto setValue( std::string const& arg )
+                    -> ParserResult override {
+                    T temp;
+                    auto result = convertInto( arg, temp );
+                    if ( result )
+                        m_ref.push_back( temp );
+                    return result;
+                }
+            };
+
+            struct BoundFlagRef : BoundFlagRefBase {
+                bool& m_ref;
+
+                explicit BoundFlagRef( bool& ref ): m_ref( ref ) {}
+
+                ParserResult setFlag( bool flag ) override;
+            };
+
+            template <typename ReturnType> struct LambdaInvoker {
+                static_assert(
+                    std::is_same<ReturnType, ParserResult>::value,
+                    "Lambda must return void or clara::ParserResult" );
+
+                template <typename L, typename ArgType>
+                static auto invoke( L const& lambda, ArgType const& arg )
+                    -> ParserResult {
+                    return lambda( arg );
+                }
+            };
+
+            template <> struct LambdaInvoker<void> {
+                template <typename L, typename ArgType>
+                static auto invoke( L const& lambda, ArgType const& arg )
+                    -> ParserResult {
+                    lambda( arg );
+                    return ParserResult::ok( ParseResultType::Matched );
+                }
+            };
+
+            template <typename ArgType, typename L>
+            auto invokeLambda( L const& lambda, std::string const& arg )
+                -> ParserResult {
+                ArgType temp{};
+                auto result = convertInto( arg, temp );
+                return !result ? result
+                               : LambdaInvoker<typename UnaryLambdaTraits<
+                                     L>::ReturnType>::invoke( lambda, temp );
+            }
+
+            template <typename L> struct BoundLambda : BoundValueRefBase {
+                L m_lambda;
+
+                static_assert(
+                    UnaryLambdaTraits<L>::isValid,
+                    "Supplied lambda must take exactly one argument" );
+                explicit BoundLambda( L const& lambda ): m_lambda( lambda ) {}
+
+                auto setValue( std::string const& arg )
+                    -> ParserResult override {
+                    return invokeLambda<typename UnaryLambdaTraits<L>::ArgType>(
+                        m_lambda, arg );
+                }
+            };
+
+            template <typename L> struct BoundManyLambda : BoundLambda<L> {
+                explicit BoundManyLambda( L const& lambda ): BoundLambda<L>( lambda ) {}
+                bool isContainer() const override { return true; }
+            };
+
+            template <typename L> struct BoundFlagLambda : BoundFlagRefBase {
+                L m_lambda;
+
+                static_assert(
+                    UnaryLambdaTraits<L>::isValid,
+                    "Supplied lambda must take exactly one argument" );
+                static_assert(
+                    std::is_same<typename UnaryLambdaTraits<L>::ArgType,
+                                 bool>::value,
+                    "flags must be boolean" );
+
+                explicit BoundFlagLambda( L const& lambda ):
+                    m_lambda( lambda ) {}
+
+                auto setFlag( bool flag ) -> ParserResult override {
+                    return LambdaInvoker<typename UnaryLambdaTraits<
+                        L>::ReturnType>::invoke( m_lambda, flag );
+                }
+            };
+
+            enum class Optionality { Optional, Required };
+
+            class ParserBase {
+            public:
+                virtual ~ParserBase() = default;
+                virtual auto validate() const -> Result { return Result::ok(); }
+                virtual auto parse( std::string const& exeName,
+                                    TokenStream tokens ) const
+                    -> InternalParseResult = 0;
+                virtual size_t cardinality() const;
+
+                InternalParseResult parse( Args const& args ) const;
+            };
+
+            template <typename DerivedT>
+            class ComposableParserImpl : public ParserBase {
+            public:
+                template <typename T>
+                auto operator|( T const& other ) const -> Parser;
+            };
+
+            // Common code and state for Args and Opts
+            template <typename DerivedT>
+            class ParserRefImpl : public ComposableParserImpl<DerivedT> {
+            protected:
+                Optionality m_optionality = Optionality::Optional;
+                std::shared_ptr<BoundRef> m_ref;
+                StringRef m_hint;
+                StringRef m_description;
+
+                explicit ParserRefImpl( std::shared_ptr<BoundRef> const& ref ):
+                    m_ref( ref ) {}
+
+            public:
+                template <typename LambdaT>
+                ParserRefImpl( accept_many_t,
+                               LambdaT const& ref,
+                               StringRef hint ):
+                    m_ref( std::make_shared<BoundManyLambda<LambdaT>>( ref ) ),
+                    m_hint( hint ) {}
+
+                template <typename T,
+                          typename = typename std::enable_if_t<
+                              !Detail::is_unary_function<T>::value>>
+                ParserRefImpl( T& ref, StringRef hint ):
+                    m_ref( std::make_shared<BoundValueRef<T>>( ref ) ),
+                    m_hint( hint ) {}
+
+                template <typename LambdaT,
+                          typename = typename std::enable_if_t<
+                              Detail::is_unary_function<LambdaT>::value>>
+                ParserRefImpl( LambdaT const& ref, StringRef hint ):
+                    m_ref( std::make_shared<BoundLambda<LambdaT>>( ref ) ),
+                    m_hint( hint ) {}
+
+                DerivedT& operator()( StringRef description ) & {
+                    m_description = description;
+                    return static_cast<DerivedT&>( *this );
+                }
+                DerivedT&& operator()( StringRef description ) && {
+                    m_description = description;
+                    return static_cast<DerivedT&&>( *this );
+                }
+
+                auto optional() -> DerivedT& {
+                    m_optionality = Optionality::Optional;
+                    return static_cast<DerivedT&>( *this );
+                }
+
+                auto required() -> DerivedT& {
+                    m_optionality = Optionality::Required;
+                    return static_cast<DerivedT&>( *this );
+                }
+
+                auto isOptional() const -> bool {
+                    return m_optionality == Optionality::Optional;
+                }
+
+                auto cardinality() const -> size_t override {
+                    if ( m_ref->isContainer() )
+                        return 0;
+                    else
+                        return 1;
+                }
+
+                StringRef hint() const { return m_hint; }
+            };
+
+        } // namespace detail
+
+
+        // A parser for arguments
+        class Arg : public Detail::ParserRefImpl<Arg> {
+        public:
+            using ParserRefImpl::ParserRefImpl;
+            using ParserBase::parse;
+
+            Detail::InternalParseResult
+                parse(std::string const&,
+                      Detail::TokenStream tokens) const override;
+        };
+
+        // A parser for options
+        class Opt : public Detail::ParserRefImpl<Opt> {
+        protected:
+            std::vector<StringRef> m_optNames;
+
+        public:
+            template <typename LambdaT>
+            explicit Opt(LambdaT const& ref) :
+                ParserRefImpl(
+                    std::make_shared<Detail::BoundFlagLambda<LambdaT>>(ref)) {}
+
+            explicit Opt(bool& ref);
+
+            template <typename LambdaT,
+                      typename = typename std::enable_if_t<
+                          Detail::is_unary_function<LambdaT>::value>>
+            Opt( LambdaT const& ref, StringRef hint ):
+                ParserRefImpl( ref, hint ) {}
+
+            template <typename LambdaT>
+            Opt( accept_many_t, LambdaT const& ref, StringRef hint ):
+                ParserRefImpl( accept_many, ref, hint ) {}
+
+            template <typename T,
+                      typename = typename std::enable_if_t<
+                          !Detail::is_unary_function<T>::value>>
+            Opt( T& ref, StringRef hint ):
+                ParserRefImpl( ref, hint ) {}
+
+            Opt& operator[]( StringRef optName ) & {
+                m_optNames.push_back(optName);
+                return *this;
+            }
+            Opt&& operator[]( StringRef optName ) && {
+                m_optNames.push_back( optName );
+                return CATCH_MOVE(*this);
+            }
+
+            Detail::HelpColumns getHelpColumns() const;
+
+            bool isMatch(StringRef optToken) const;
+
+            using ParserBase::parse;
+
+            Detail::InternalParseResult
+                parse(std::string const&,
+                      Detail::TokenStream tokens) const override;
+
+            Detail::Result validate() const override;
+        };
+
+        // Specifies the name of the executable
+        class ExeName : public Detail::ComposableParserImpl<ExeName> {
+            std::shared_ptr<std::string> m_name;
+            std::shared_ptr<Detail::BoundValueRefBase> m_ref;
+
+        public:
+            ExeName();
+            explicit ExeName(std::string& ref);
+
+            template <typename LambdaT>
+            explicit ExeName(LambdaT const& lambda) : ExeName() {
+                m_ref = std::make_shared<Detail::BoundLambda<LambdaT>>(lambda);
+            }
+
+            // The exe name is not parsed out of the normal tokens, but is
+            // handled specially
+            Detail::InternalParseResult
+                parse(std::string const&,
+                      Detail::TokenStream tokens) const override;
+
+            std::string const& name() const { return *m_name; }
+            Detail::ParserResult set(std::string const& newName);
+        };
+
+
+        // A Combined parser
+        class Parser : Detail::ParserBase {
+            mutable ExeName m_exeName;
+            std::vector<Opt> m_options;
+            std::vector<Arg> m_args;
+
+        public:
+
+            auto operator|=(ExeName const& exeName) -> Parser& {
+                m_exeName = exeName;
+                return *this;
+            }
+
+            auto operator|=(Arg const& arg) -> Parser& {
+                m_args.push_back(arg);
+                return *this;
+            }
+
+            friend Parser& operator|=( Parser& p, Opt const& opt ) {
+                p.m_options.push_back( opt );
+                return p;
+            }
+            friend Parser& operator|=( Parser& p, Opt&& opt ) {
+                p.m_options.push_back( CATCH_MOVE(opt) );
+                return p;
+            }
+
+            Parser& operator|=(Parser const& other);
+
+            template <typename T>
+            friend Parser operator|( Parser const& p, T&& rhs ) {
+                Parser temp( p );
+                temp |= rhs;
+                return temp;
+            }
+
+            template <typename T>
+            friend Parser operator|( Parser&& p, T&& rhs ) {
+                p |= CATCH_FORWARD(rhs);
+                return CATCH_MOVE(p);
+            }
+
+            std::vector<Detail::HelpColumns> getHelpColumns() const;
+
+            void writeToStream(std::ostream& os) const;
+
+            friend auto operator<<(std::ostream& os, Parser const& parser)
+                -> std::ostream& {
+                parser.writeToStream(os);
+                return os;
+            }
+
+            Detail::Result validate() const override;
+
+            using ParserBase::parse;
+            Detail::InternalParseResult
+                parse(std::string const& exeName,
+                      Detail::TokenStream tokens) const override;
+        };
+
+        /**
+         * Wrapper over argc + argv, assumes that the inputs outlive it
+         */
+        class Args {
+            friend Detail::TokenStream;
+            StringRef m_exeName;
+            std::vector<StringRef> m_args;
+
+        public:
+            Args(int argc, char const* const* argv);
+            // Helper constructor for testing
+            Args(std::initializer_list<StringRef> args);
+
+            StringRef exeName() const { return m_exeName; }
+        };
+
+
+        // Convenience wrapper for option parser that specifies the help option
+        struct Help : Opt {
+            Help(bool& showHelpFlag);
+        };
+
+        // Result type for parser operation
+        using Detail::ParserResult;
+
+        namespace Detail {
+            template <typename DerivedT>
+            template <typename T>
+            Parser
+                ComposableParserImpl<DerivedT>::operator|(T const& other) const {
+                return Parser() | static_cast<DerivedT const&>(*this) | other;
+            }
+        }
+
+    } // namespace Clara
+} // namespace Catch
+
+#if defined( __clang__ )
+#    pragma clang diagnostic pop
+#endif
+
+#if defined( __GNUC__ )
+#    pragma GCC diagnostic pop
+#endif
+
+#endif // CATCH_CLARA_HPP_INCLUDED
+
+namespace Catch {
+
+    struct ConfigData;
+
+    Clara::Parser makeCommandLineParser( ConfigData& config );
+
+} // end namespace Catch
+
+#endif // CATCH_COMMANDLINE_HPP_INCLUDED
+
+namespace Catch {
+
+    class Session : Detail::NonCopyable {
+    public:
+
+        Session();
+        ~Session();
+
+        void showHelp() const;
+        void libIdentify();
+
+        int applyCommandLine( int argc, char const * const * argv );
+    #if defined(CATCH_CONFIG_WCHAR) && defined(_WIN32) && defined(UNICODE)
+        int applyCommandLine( int argc, wchar_t const * const * argv );
+    #endif
+
+        void useConfigData( ConfigData const& configData );
+
+        template<typename CharT>
+        int run(int argc, CharT const * const argv[]) {
+            if (m_startupExceptions)
+                return 1;
+            int returnCode = applyCommandLine(argc, argv);
+            if (returnCode == 0)
+                returnCode = run();
+            return returnCode;
+        }
+
+        int run();
+
+        Clara::Parser const& cli() const;
+        void cli( Clara::Parser const& newParser );
+        ConfigData& configData();
+        Config& config();
+    private:
+        int runInternal();
+
+        Clara::Parser m_cli;
+        ConfigData m_configData;
+        Detail::unique_ptr<Config> m_config;
+        bool m_startupExceptions = false;
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_SESSION_HPP_INCLUDED
+
+
+#ifndef CATCH_TAG_ALIAS_HPP_INCLUDED
+#define CATCH_TAG_ALIAS_HPP_INCLUDED
+
+
+#include <string>
+
+namespace Catch {
+
+    struct TagAlias {
+        TagAlias(std::string const& _tag, SourceLineInfo _lineInfo):
+            tag(_tag),
+            lineInfo(_lineInfo)
+        {}
+
+        std::string tag;
+        SourceLineInfo lineInfo;
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_TAG_ALIAS_HPP_INCLUDED
+
+
+#ifndef CATCH_TAG_ALIAS_AUTOREGISTRAR_HPP_INCLUDED
+#define CATCH_TAG_ALIAS_AUTOREGISTRAR_HPP_INCLUDED
+
+
+namespace Catch {
+
+    struct RegistrarForTagAliases {
+        RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo );
+    };
+
+} // end namespace Catch
+
+#define CATCH_REGISTER_TAG_ALIAS( alias, spec ) \
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+    namespace{ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); } \
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+#endif // CATCH_TAG_ALIAS_AUTOREGISTRAR_HPP_INCLUDED
+
+
+#ifndef CATCH_TEMPLATE_TEST_MACROS_HPP_INCLUDED
+#define CATCH_TEMPLATE_TEST_MACROS_HPP_INCLUDED
+
+// We need this suppression to leak, because it took until GCC 10
+// for the front end to handle local suppression via _Pragma properly
+// inside templates (so `TEMPLATE_TEST_CASE` and co).
+// **THIS IS DIFFERENT FOR STANDARD TESTS, WHERE GCC 9 IS SUFFICIENT**
+#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC) && __GNUC__ < 10
+#pragma GCC diagnostic ignored "-Wparentheses"
+#endif
+
+
+
+
+#ifndef CATCH_TEST_MACROS_HPP_INCLUDED
+#define CATCH_TEST_MACROS_HPP_INCLUDED
+
+
+
+#ifndef CATCH_TEST_MACRO_IMPL_HPP_INCLUDED
+#define CATCH_TEST_MACRO_IMPL_HPP_INCLUDED
+
+
+
+#ifndef CATCH_ASSERTION_HANDLER_HPP_INCLUDED
+#define CATCH_ASSERTION_HANDLER_HPP_INCLUDED
+
+
+
+#ifndef CATCH_DECOMPOSER_HPP_INCLUDED
+#define CATCH_DECOMPOSER_HPP_INCLUDED
+
+
+
+#ifndef CATCH_COMPARE_TRAITS_HPP_INCLUDED
+#define CATCH_COMPARE_TRAITS_HPP_INCLUDED
+
+
+#include <type_traits>
+
+namespace Catch {
+    namespace Detail {
+
+#if defined( __GNUC__ ) && !defined( __clang__ )
+#    pragma GCC diagnostic push
+    // GCC likes to complain about comparing bool with 0, in the decltype()
+    // that defines the comparable traits below.
+#    pragma GCC diagnostic ignored "-Wbool-compare"
+    // "ordered comparison of pointer with integer zero" same as above,
+    // but it does not have a separate warning flag to suppress
+#    pragma GCC diagnostic ignored "-Wextra"
+    // Did you know that comparing floats with `0` directly
+    // is super-duper dangerous in unevaluated context?
+#    pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+
+#if defined( __clang__ )
+#    pragma clang diagnostic push
+    // Did you know that comparing floats with `0` directly
+    // is super-duper dangerous in unevaluated context?
+#    pragma clang diagnostic ignored "-Wfloat-equal"
+#endif
+
+#define CATCH_DEFINE_COMPARABLE_TRAIT( id, op )                               \
+    template <typename, typename, typename = void>                            \
+    struct is_##id##_comparable : std::false_type {};                         \
+    template <typename T, typename U>                                         \
+    struct is_##id##_comparable<                                              \
+        T,                                                                    \
+        U,                                                                    \
+        void_t<decltype( std::declval<T>() op std::declval<U>() )>>           \
+        : std::true_type {};                                                  \
+    template <typename, typename = void>                                      \
+    struct is_##id##_0_comparable : std::false_type {};                       \
+    template <typename T>                                                     \
+    struct is_##id##_0_comparable<T,                                          \
+                                  void_t<decltype( std::declval<T>() op 0 )>> \
+        : std::true_type {};
+
+        // We need all 6 pre-spaceship comparison ops: <, <=, >, >=, ==, !=
+        CATCH_DEFINE_COMPARABLE_TRAIT( lt, < )
+        CATCH_DEFINE_COMPARABLE_TRAIT( le, <= )
+        CATCH_DEFINE_COMPARABLE_TRAIT( gt, > )
+        CATCH_DEFINE_COMPARABLE_TRAIT( ge, >= )
+        CATCH_DEFINE_COMPARABLE_TRAIT( eq, == )
+        CATCH_DEFINE_COMPARABLE_TRAIT( ne, != )
+
+#undef CATCH_DEFINE_COMPARABLE_TRAIT
+
+#if defined( __GNUC__ ) && !defined( __clang__ )
+#    pragma GCC diagnostic pop
+#endif
+#if defined( __clang__ )
+#    pragma clang diagnostic pop
+#endif
+
+
+    } // namespace Detail
+} // namespace Catch
+
+#endif // CATCH_COMPARE_TRAITS_HPP_INCLUDED
+
+
+#ifndef CATCH_LOGICAL_TRAITS_HPP_INCLUDED
+#define CATCH_LOGICAL_TRAITS_HPP_INCLUDED
+
+#include <type_traits>
+
+namespace Catch {
+namespace Detail {
+
+#if defined( __cpp_lib_logical_traits ) && __cpp_lib_logical_traits >= 201510
+
+    using std::conjunction;
+    using std::disjunction;
+    using std::negation;
+
+#else
+
+    template <class...> struct conjunction : std::true_type {};
+    template <class B1> struct conjunction<B1> : B1 {};
+    template <class B1, class... Bn>
+    struct conjunction<B1, Bn...>
+        : std::conditional_t<bool( B1::value ), conjunction<Bn...>, B1> {};
+
+    template <class...> struct disjunction : std::false_type {};
+    template <class B1> struct disjunction<B1> : B1 {};
+    template <class B1, class... Bn>
+    struct disjunction<B1, Bn...>
+        : std::conditional_t<bool( B1::value ), B1, disjunction<Bn...>> {};
+
+    template <class B>
+    struct negation : std::integral_constant<bool, !bool(B::value)> {};
+
+#endif
+
+} // namespace Detail
+} // namespace Catch
+
+#endif // CATCH_LOGICAL_TRAITS_HPP_INCLUDED
+
+#include <type_traits>
+#include <iosfwd>
+
+/** \file
+ * Why does decomposing look the way it does:
+ *
+ * Conceptually, decomposing is simple. We change `REQUIRE( a == b )` into
+ * `Decomposer{} <= a == b`, so that `Decomposer{} <= a` is evaluated first,
+ * and our custom operator is used for `a == b`, because `a` is transformed
+ * into `ExprLhs<T&>` and then into `BinaryExpr<T&, U&>`.
+ *
+ * In practice, decomposing ends up a mess, because we have to support
+ * various fun things.
+ *
+ * 1) Types that are only comparable with literal 0, and they do this by
+ *    comparing against a magic type with pointer constructor and deleted
+ *    other constructors. Example: `REQUIRE((a <=> b) == 0)` in libstdc++
+ *
+ * 2) Types that are only comparable with literal 0, and they do this by
+ *    comparing against a magic type with consteval integer constructor.
+ *    Example: `REQUIRE((a <=> b) == 0)` in current MSVC STL.
+ *
+ * 3) Types that have no linkage, and so we cannot form a reference to
+ *    them. Example: some implementations of traits.
+ *
+ * 4) Starting with C++20, when the compiler sees `a == b`, it also uses
+ *    `b == a` when constructing the overload set. For us this means that
+ *    when the compiler handles `ExprLhs<T> == b`, it also tries to resolve
+ *    the overload set for `b == ExprLhs<T>`.
+ *
+ * To accommodate these use cases, decomposer ended up rather complex.
+ *
+ * 1) These types are handled by adding SFINAE overloads to our comparison
+ *    operators, checking whether `T == U` are comparable with the given
+ *    operator, and if not, whether T (or U) are comparable with literal 0.
+ *    If yes, the overload compares T (or U) with 0 literal inline in the
+ *    definition.
+ *
+ *    Note that for extra correctness, we check  that the other type is
+ *    either an `int` (literal 0 is captured as `int` by templates), or
+ *    a `long` (some platforms use 0L for `NULL` and we want to support
+ *    that for pointer comparisons).
+ *
+ * 2) For these types, `is_foo_comparable<T, int>` is true, but letting
+ *    them fall into the overload that actually does `T == int` causes
+ *    compilation error. Handling them requires that the decomposition
+ *    is `constexpr`, so that P2564R3 applies and the `consteval` from
+ *    their accompanying magic type is propagated through the `constexpr`
+ *    call stack.
+ *
+ *    However this is not enough to handle these types automatically,
+ *    because our default is to capture types by reference, to avoid
+ *    runtime copies. While these references cannot become dangling,
+ *    they outlive the constexpr context and thus the default capture
+ *    path cannot be actually constexpr.
+ *
+ *    The solution is to capture these types by value, by explicitly
+ *    specializing `Catch::capture_by_value` for them. Catch2 provides
+ *    specialization for `std::foo_ordering`s, but users can specialize
+ *    the trait for their own types as well.
+ *
+ * 3) If a type has no linkage, we also cannot capture it by reference.
+ *    The solution is once again to capture them by value. We handle
+ *    the common cases by using `std::is_arithmetic` as the default
+ *    for `Catch::capture_by_value`, but that is only a some-effort
+ *    heuristic. But as with 2), users can specialize `capture_by_value`
+ *    for their own types as needed.
+ *
+ * 4) To support C++20 and make the SFINAE on our decomposing operators
+ *    work, the SFINAE has to happen in return type, rather than in
+ *    a template type. This is due to our use of logical type traits
+ *    (`conjunction`/`disjunction`/`negation`), that we use to workaround
+ *    an issue in older (9-) versions of GCC. I still blame C++20 for
+ *    this, because without the comparison order switching, the logical
+ *    traits could still be used in template type.
+ *
+ * There are also other side concerns, e.g. supporting both `REQUIRE(a)`
+ * and `REQUIRE(a == b)`, or making `REQUIRE_THAT(a, IsEqual(b))` slot
+ * nicely into the same expression handling logic, but these are rather
+ * straightforward and add only a bit of complexity (e.g. common base
+ * class for decomposed expressions).
+ */
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4389) // '==' : signed/unsigned mismatch
+#pragma warning(disable:4018) // more "signed/unsigned mismatch"
+#pragma warning(disable:4312) // Converting int to T* using reinterpret_cast (issue on x64 platform)
+#pragma warning(disable:4180) // qualifier applied to function type has no meaning
+#pragma warning(disable:4800) // Forcing result to true or false
+#endif
+
+#ifdef __clang__
+#  pragma clang diagnostic push
+#  pragma clang diagnostic ignored "-Wsign-compare"
+#  pragma clang diagnostic ignored "-Wnon-virtual-dtor"
+#elif defined __GNUC__
+#  pragma GCC diagnostic push
+#  pragma GCC diagnostic ignored "-Wsign-compare"
+#  pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
+#endif
+
+#if defined(CATCH_CPP20_OR_GREATER) && __has_include(<compare>)
+#  include <compare>
+#    if defined( __cpp_lib_three_way_comparison ) && \
+            __cpp_lib_three_way_comparison >= 201907L
+#      define CATCH_CONFIG_CPP20_COMPARE_OVERLOADS
+#    endif
+#endif
+
+namespace Catch {
+
+    namespace Detail {
+        // This was added in C++20, but we require only C++14 for now.
+        template <typename T>
+        using RemoveCVRef_t = std::remove_cv_t<std::remove_reference_t<T>>;
+    }
+
+    // Note: There is nothing that stops us from extending this,
+    //       e.g. to `std::is_scalar`, but the more encompassing
+    //       traits are usually also more expensive. For now we
+    //       keep this as it used to be and it can be changed later.
+    template <typename T>
+    struct capture_by_value
+        : std::integral_constant<bool, std::is_arithmetic<T>{}> {};
+
+#if defined( CATCH_CONFIG_CPP20_COMPARE_OVERLOADS )
+    template <>
+    struct capture_by_value<std::strong_ordering> : std::true_type {};
+    template <>
+    struct capture_by_value<std::weak_ordering> : std::true_type {};
+    template <>
+    struct capture_by_value<std::partial_ordering> : std::true_type {};
+#endif
+
+    template <typename T>
+    struct always_false : std::false_type {};
+
+    class ITransientExpression {
+        bool m_isBinaryExpression;
+        bool m_result;
+
+    protected:
+        ~ITransientExpression() = default;
+
+    public:
+        constexpr auto isBinaryExpression() const -> bool { return m_isBinaryExpression; }
+        constexpr auto getResult() const -> bool { return m_result; }
+        //! This function **has** to be overridden by the derived class.
+        virtual void streamReconstructedExpression( std::ostream& os ) const;
+
+        constexpr ITransientExpression( bool isBinaryExpression, bool result )
+        :   m_isBinaryExpression( isBinaryExpression ),
+            m_result( result )
+        {}
+
+        constexpr ITransientExpression( ITransientExpression const& ) = default;
+        constexpr ITransientExpression& operator=( ITransientExpression const& ) = default;
+
+        friend std::ostream& operator<<(std::ostream& out, ITransientExpression const& expr) {
+            expr.streamReconstructedExpression(out);
+            return out;
+        }
+    };
+
+    void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs );
+
+    template<typename LhsT, typename RhsT>
+    class BinaryExpr  : public ITransientExpression {
+        LhsT m_lhs;
+        StringRef m_op;
+        RhsT m_rhs;
+
+        void streamReconstructedExpression( std::ostream &os ) const override {
+            formatReconstructedExpression
+                    ( os, Catch::Detail::stringify( m_lhs ), m_op, Catch::Detail::stringify( m_rhs ) );
+        }
+
+    public:
+        constexpr BinaryExpr( bool comparisonResult, LhsT lhs, StringRef op, RhsT rhs )
+        :   ITransientExpression{ true, comparisonResult },
+            m_lhs( lhs ),
+            m_op( op ),
+            m_rhs( rhs )
+        {}
+
+        template<typename T>
+        auto operator && ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator || ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator == ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator != ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator > ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator < ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator >= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator <= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+    };
+
+    template<typename LhsT>
+    class UnaryExpr : public ITransientExpression {
+        LhsT m_lhs;
+
+        void streamReconstructedExpression( std::ostream &os ) const override {
+            os << Catch::Detail::stringify( m_lhs );
+        }
+
+    public:
+        explicit constexpr UnaryExpr( LhsT lhs )
+        :   ITransientExpression{ false, static_cast<bool>(lhs) },
+            m_lhs( lhs )
+        {}
+    };
+
+
+    template<typename LhsT>
+    class ExprLhs {
+        LhsT m_lhs;
+    public:
+        explicit constexpr ExprLhs( LhsT lhs ) : m_lhs( lhs ) {}
+
+#define CATCH_INTERNAL_DEFINE_EXPRESSION_EQUALITY_OPERATOR( id, op )           \
+    template <typename RhsT>                                                   \
+    constexpr friend auto operator op( ExprLhs&& lhs, RhsT&& rhs )             \
+        -> std::enable_if_t<                                                   \
+            Detail::conjunction<Detail::is_##id##_comparable<LhsT, RhsT>,      \
+                                Detail::negation<capture_by_value<             \
+                                    Detail::RemoveCVRef_t<RhsT>>>>::value,     \
+            BinaryExpr<LhsT, RhsT const&>> {                                   \
+        return {                                                               \
+            static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
+    }                                                                          \
+    template <typename RhsT>                                                   \
+    constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs )               \
+        -> std::enable_if_t<                                                   \
+            Detail::conjunction<Detail::is_##id##_comparable<LhsT, RhsT>,      \
+                                capture_by_value<RhsT>>::value,                \
+            BinaryExpr<LhsT, RhsT>> {                                          \
+        return {                                                               \
+            static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
+    }                                                                          \
+    template <typename RhsT>                                                   \
+    constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs )               \
+        -> std::enable_if_t<                                                   \
+            Detail::conjunction<                                               \
+                Detail::negation<Detail::is_##id##_comparable<LhsT, RhsT>>,    \
+                Detail::is_eq_0_comparable<LhsT>,                              \
+              /* We allow long because we want `ptr op NULL` to be accepted */ \
+                Detail::disjunction<std::is_same<RhsT, int>,                   \
+                                    std::is_same<RhsT, long>>>::value,         \
+            BinaryExpr<LhsT, RhsT>> {                                          \
+        if ( rhs != 0 ) { throw_test_failure_exception(); }                    \
+        return {                                                               \
+            static_cast<bool>( lhs.m_lhs op 0 ), lhs.m_lhs, #op##_sr, rhs };   \
+    }                                                                          \
+    template <typename RhsT>                                                   \
+    constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs )               \
+        -> std::enable_if_t<                                                   \
+            Detail::conjunction<                                               \
+                Detail::negation<Detail::is_##id##_comparable<LhsT, RhsT>>,    \
+                Detail::is_eq_0_comparable<RhsT>,                              \
+              /* We allow long because we want `ptr op NULL` to be accepted */ \
+                Detail::disjunction<std::is_same<LhsT, int>,                   \
+                                    std::is_same<LhsT, long>>>::value,         \
+            BinaryExpr<LhsT, RhsT>> {                                          \
+        if ( lhs.m_lhs != 0 ) { throw_test_failure_exception(); }              \
+        return { static_cast<bool>( 0 op rhs ), lhs.m_lhs, #op##_sr, rhs };    \
+    }
+
+        CATCH_INTERNAL_DEFINE_EXPRESSION_EQUALITY_OPERATOR( eq, == )
+        CATCH_INTERNAL_DEFINE_EXPRESSION_EQUALITY_OPERATOR( ne, != )
+
+    #undef CATCH_INTERNAL_DEFINE_EXPRESSION_EQUALITY_OPERATOR
+
+
+#define CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR( id, op )         \
+    template <typename RhsT>                                                   \
+    constexpr friend auto operator op( ExprLhs&& lhs, RhsT&& rhs )             \
+        -> std::enable_if_t<                                                   \
+            Detail::conjunction<Detail::is_##id##_comparable<LhsT, RhsT>,      \
+                                Detail::negation<capture_by_value<             \
+                                    Detail::RemoveCVRef_t<RhsT>>>>::value,     \
+            BinaryExpr<LhsT, RhsT const&>> {                                   \
+        return {                                                               \
+            static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
+    }                                                                          \
+    template <typename RhsT>                                                   \
+    constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs )               \
+        -> std::enable_if_t<                                                   \
+            Detail::conjunction<Detail::is_##id##_comparable<LhsT, RhsT>,      \
+                                capture_by_value<RhsT>>::value,                \
+            BinaryExpr<LhsT, RhsT>> {                                          \
+        return {                                                               \
+            static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
+    }                                                                          \
+    template <typename RhsT>                                                   \
+    constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs )               \
+        -> std::enable_if_t<                                                   \
+            Detail::conjunction<                                               \
+                Detail::negation<Detail::is_##id##_comparable<LhsT, RhsT>>,    \
+                Detail::is_##id##_0_comparable<LhsT>,                          \
+                std::is_same<RhsT, int>>::value,                               \
+            BinaryExpr<LhsT, RhsT>> {                                          \
+        if ( rhs != 0 ) { throw_test_failure_exception(); }                    \
+        return {                                                               \
+            static_cast<bool>( lhs.m_lhs op 0 ), lhs.m_lhs, #op##_sr, rhs };   \
+    }                                                                          \
+    template <typename RhsT>                                                   \
+    constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs )               \
+        -> std::enable_if_t<                                                   \
+            Detail::conjunction<                                               \
+                Detail::negation<Detail::is_##id##_comparable<LhsT, RhsT>>,    \
+                Detail::is_##id##_0_comparable<RhsT>,                          \
+                std::is_same<LhsT, int>>::value,                               \
+            BinaryExpr<LhsT, RhsT>> {                                          \
+        if ( lhs.m_lhs != 0 ) { throw_test_failure_exception(); }              \
+        return { static_cast<bool>( 0 op rhs ), lhs.m_lhs, #op##_sr, rhs };    \
+    }
+
+        CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR( lt, < )
+        CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR( le, <= )
+        CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR( gt, > )
+        CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR( ge, >= )
+
+    #undef CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR
+
+
+#define CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR( op )                        \
+    template <typename RhsT>                                                   \
+    constexpr friend auto operator op( ExprLhs&& lhs, RhsT&& rhs )             \
+        -> std::enable_if_t<                                                   \
+            !capture_by_value<Detail::RemoveCVRef_t<RhsT>>::value,             \
+            BinaryExpr<LhsT, RhsT const&>> {                                   \
+        return {                                                               \
+            static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
+    }                                                                          \
+    template <typename RhsT>                                                   \
+    constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs )               \
+        -> std::enable_if_t<capture_by_value<RhsT>::value,                     \
+                            BinaryExpr<LhsT, RhsT>> {                          \
+        return {                                                               \
+            static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
+    }
+
+        CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(|)
+        CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(&)
+        CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(^)
+
+    #undef CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR
+
+        template<typename RhsT>
+        friend auto operator && ( ExprLhs &&, RhsT && ) -> BinaryExpr<LhsT, RhsT const&> {
+            static_assert(always_false<RhsT>::value,
+            "operator&& is not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename RhsT>
+        friend auto operator || ( ExprLhs &&, RhsT && ) -> BinaryExpr<LhsT, RhsT const&> {
+            static_assert(always_false<RhsT>::value,
+            "operator|| is not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        constexpr auto makeUnaryExpr() const -> UnaryExpr<LhsT> {
+            return UnaryExpr<LhsT>{ m_lhs };
+        }
+    };
+
+    struct Decomposer {
+        template <typename T,
+                  std::enable_if_t<!capture_by_value<Detail::RemoveCVRef_t<T>>::value,
+                      int> = 0>
+        constexpr friend auto operator <= ( Decomposer &&, T && lhs ) -> ExprLhs<T const&> {
+            return ExprLhs<const T&>{ lhs };
+        }
+
+        template <typename T,
+                  std::enable_if_t<capture_by_value<T>::value, int> = 0>
+        constexpr friend auto operator <= ( Decomposer &&, T value ) -> ExprLhs<T> {
+            return ExprLhs<T>{ value };
+        }
+    };
+
+} // end namespace Catch
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+#ifdef __clang__
+#  pragma clang diagnostic pop
+#elif defined __GNUC__
+#  pragma GCC diagnostic pop
+#endif
+
+#endif // CATCH_DECOMPOSER_HPP_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+    struct AssertionReaction {
+        bool shouldDebugBreak = false;
+        bool shouldThrow = false;
+        bool shouldSkip = false;
+    };
+
+    class AssertionHandler {
+        AssertionInfo m_assertionInfo;
+        AssertionReaction m_reaction;
+        bool m_completed = false;
+        IResultCapture& m_resultCapture;
+
+    public:
+        AssertionHandler
+            (   StringRef macroName,
+                SourceLineInfo const& lineInfo,
+                StringRef capturedExpression,
+                ResultDisposition::Flags resultDisposition );
+        ~AssertionHandler() {
+            if ( !m_completed ) {
+                m_resultCapture.handleIncomplete( m_assertionInfo );
+            }
+        }
+
+
+        template<typename T>
+        constexpr void handleExpr( ExprLhs<T> const& expr ) {
+            handleExpr( expr.makeUnaryExpr() );
+        }
+        void handleExpr( ITransientExpression const& expr );
+
+        void handleMessage(ResultWas::OfType resultType, std::string&& message);
+
+        void handleExceptionThrownAsExpected();
+        void handleUnexpectedExceptionNotThrown();
+        void handleExceptionNotThrownAsExpected();
+        void handleThrowingCallSkipped();
+        void handleUnexpectedInflightException();
+
+        void complete();
+
+        // query
+        auto allowThrows() const -> bool;
+    };
+
+    void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str );
+
+} // namespace Catch
+
+#endif // CATCH_ASSERTION_HANDLER_HPP_INCLUDED
+
+
+#ifndef CATCH_PREPROCESSOR_INTERNAL_STRINGIFY_HPP_INCLUDED
+#define CATCH_PREPROCESSOR_INTERNAL_STRINGIFY_HPP_INCLUDED
+
+
+#if !defined(CATCH_CONFIG_DISABLE_STRINGIFICATION)
+  #define CATCH_INTERNAL_STRINGIFY(...) #__VA_ARGS__##_catch_sr
+#else
+  #define CATCH_INTERNAL_STRINGIFY(...) "Disabled by CATCH_CONFIG_DISABLE_STRINGIFICATION"_catch_sr
+#endif
+
+#endif // CATCH_PREPROCESSOR_INTERNAL_STRINGIFY_HPP_INCLUDED
+
+// We need this suppression to leak, because it took until GCC 10
+// for the front end to handle local suppression via _Pragma properly
+#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC) && __GNUC__ <= 9
+  #pragma GCC diagnostic ignored "-Wparentheses"
+#endif
+
+#if !defined(CATCH_CONFIG_DISABLE)
+
+#if defined(CATCH_CONFIG_FAST_COMPILE) || defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+
+///////////////////////////////////////////////////////////////////////////////
+// Another way to speed-up compilation is to omit local try-catch for REQUIRE*
+// macros.
+#define INTERNAL_CATCH_TRY
+#define INTERNAL_CATCH_CATCH( capturer )
+
+#else // CATCH_CONFIG_FAST_COMPILE
+
+#define INTERNAL_CATCH_TRY try
+#define INTERNAL_CATCH_CATCH( handler ) catch(...) { (handler).handleUnexpectedInflightException(); }
+
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_TEST( macroName, resultDisposition, ... ) \
+    do { /* NOLINT(bugprone-infinite-loop) */ \
+        /* The expression should not be evaluated, but warnings should hopefully be checked */ \
+        CATCH_INTERNAL_IGNORE_BUT_WARN(__VA_ARGS__); \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
+        INTERNAL_CATCH_TRY { \
+            CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+            CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
+            catchAssertionHandler.handleExpr( Catch::Decomposer() <= __VA_ARGS__ ); /* NOLINT(bugprone-chained-comparison) */ \
+            CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
+        catchAssertionHandler.complete(); \
+    } while( (void)0, (false) && static_cast<const bool&>( !!(__VA_ARGS__) ) ) // the expression here is never evaluated at runtime but it forces the compiler to give it a look
+    // The double negation silences MSVC's C4800 warning, the static_cast forces short-circuit evaluation if the type has overloaded &&.
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_IF( macroName, resultDisposition, ... ) \
+    INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \
+    if( Catch::getResultCapture().lastAssertionPassed() )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_ELSE( macroName, resultDisposition, ... ) \
+    INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \
+    if( !Catch::getResultCapture().lastAssertionPassed() )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_NO_THROW( macroName, resultDisposition, ... ) \
+    do { \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
+        try { \
+            CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+            CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
+            static_cast<void>(__VA_ARGS__); \
+            CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+            catchAssertionHandler.handleExceptionNotThrownAsExpected(); \
+        } \
+        catch( ... ) { \
+            catchAssertionHandler.handleUnexpectedInflightException(); \
+        } \
+        catchAssertionHandler.complete(); \
+    } while( false )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_THROWS( macroName, resultDisposition, ... ) \
+    do { \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition); \
+        if( catchAssertionHandler.allowThrows() ) \
+            try { \
+                CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+                CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT \
+                CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
+                static_cast<void>(__VA_ARGS__); \
+                CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
+            } \
+            catch( ... ) { \
+                catchAssertionHandler.handleExceptionThrownAsExpected(); \
+            } \
+        else \
+            catchAssertionHandler.handleThrowingCallSkipped(); \
+        catchAssertionHandler.complete(); \
+    } while( false )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_THROWS_AS( macroName, exceptionType, resultDisposition, expr ) \
+    do { \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr) ", " CATCH_INTERNAL_STRINGIFY(exceptionType), resultDisposition ); \
+        if( catchAssertionHandler.allowThrows() ) \
+            try { \
+                CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+                CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT \
+                CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
+                static_cast<void>(expr); \
+                CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
+            } \
+            catch( exceptionType const& ) { \
+                catchAssertionHandler.handleExceptionThrownAsExpected(); \
+            } \
+            catch( ... ) { \
+                catchAssertionHandler.handleUnexpectedInflightException(); \
+            } \
+        else \
+            catchAssertionHandler.handleThrowingCallSkipped(); \
+        catchAssertionHandler.complete(); \
+    } while( false )
+
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Although this is matcher-based, it can be used with just a string
+#define INTERNAL_CATCH_THROWS_STR_MATCHES( macroName, resultDisposition, matcher, ... ) \
+    do { \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
+        if( catchAssertionHandler.allowThrows() ) \
+            try { \
+                CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+                CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT \
+                CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
+                static_cast<void>(__VA_ARGS__); \
+                CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
+            } \
+            catch( ... ) { \
+                Catch::handleExceptionMatchExpr( catchAssertionHandler, matcher ); \
+            } \
+        else \
+            catchAssertionHandler.handleThrowingCallSkipped(); \
+        catchAssertionHandler.complete(); \
+    } while( false )
+
+#endif // CATCH_CONFIG_DISABLE
+
+#endif // CATCH_TEST_MACRO_IMPL_HPP_INCLUDED
+
+
+#ifndef CATCH_SECTION_HPP_INCLUDED
+#define CATCH_SECTION_HPP_INCLUDED
+
+
+
+
+/** \file
+ * Wrapper for the STATIC_ANALYSIS_SUPPORT configuration option
+ *
+ * Some of Catch2's macros can be defined differently to work better with
+ * static analysis tools, like clang-tidy or coverity.
+ * Currently the main use case is to show that `SECTION`s are executed
+ * exclusively, and not all in one run of a `TEST_CASE`.
+ */
+
+#ifndef CATCH_CONFIG_STATIC_ANALYSIS_SUPPORT_HPP_INCLUDED
+#define CATCH_CONFIG_STATIC_ANALYSIS_SUPPORT_HPP_INCLUDED
+
+
+#if defined(__clang_analyzer__) || defined(__COVERITY__)
+    #define CATCH_INTERNAL_CONFIG_STATIC_ANALYSIS_SUPPORT
+#endif
+
+#if defined( CATCH_INTERNAL_CONFIG_STATIC_ANALYSIS_SUPPORT ) && \
+    !defined( CATCH_CONFIG_NO_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT ) && \
+    !defined( CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT )
+#    define CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT
+#endif
+
+
+#endif // CATCH_CONFIG_STATIC_ANALYSIS_SUPPORT_HPP_INCLUDED
+
+
+#ifndef CATCH_TIMER_HPP_INCLUDED
+#define CATCH_TIMER_HPP_INCLUDED
+
+#include <cstdint>
+
+namespace Catch {
+
+    class Timer {
+        uint64_t m_nanoseconds = 0;
+    public:
+        void start();
+        auto getElapsedNanoseconds() const -> uint64_t;
+        auto getElapsedMicroseconds() const -> uint64_t;
+        auto getElapsedMilliseconds() const -> unsigned int;
+        auto getElapsedSeconds() const -> double;
+    };
+
+} // namespace Catch
+
+#endif // CATCH_TIMER_HPP_INCLUDED
+
+namespace Catch {
+
+    class Section : Detail::NonCopyable {
+    public:
+        Section( SectionInfo&& info );
+        Section( SourceLineInfo const& _lineInfo,
+                 StringRef _name,
+                 const char* const = nullptr );
+        ~Section();
+
+        // This indicates whether the section should be executed or not
+        explicit operator bool() const;
+
+    private:
+        SectionInfo m_info;
+
+        Counts m_assertions;
+        bool m_sectionIncluded;
+        Timer m_timer;
+    };
+
+} // end namespace Catch
+
+#if !defined(CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT)
+#    define INTERNAL_CATCH_SECTION( ... )                                 \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                         \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS                  \
+        if ( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME(            \
+                 catch_internal_Section ) =                               \
+                 Catch::Section( CATCH_INTERNAL_LINEINFO, __VA_ARGS__ ) ) \
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+#    define INTERNAL_CATCH_DYNAMIC_SECTION( ... )                     \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                     \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS              \
+        if ( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME(        \
+                 catch_internal_Section ) =                           \
+                 Catch::SectionInfo(                                  \
+                     CATCH_INTERNAL_LINEINFO,                         \
+                     ( Catch::ReusableStringStream() << __VA_ARGS__ ) \
+                         .str() ) )                                   \
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+#else
+
+// These section definitions imply that at most one section at one level
+// will be intered (because only one section's __LINE__ can be equal to
+// the dummy `catchInternalSectionHint` variable from `TEST_CASE`).
+
+namespace Catch {
+    namespace Detail {
+        // Intentionally without linkage, as it should only be used as a dummy
+        // symbol for static analysis.
+        // The arguments are used as a dummy for checking warnings in the passed
+        // expressions.
+        int GetNewSectionHint( StringRef, const char* const = nullptr );
+    } // namespace Detail
+} // namespace Catch
+
+
+#    define INTERNAL_CATCH_SECTION( ... )                                   \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                           \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS                    \
+        CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS                             \
+        if ( [[maybe_unused]] const int catchInternalPreviousSectionHint =  \
+                 catchInternalSectionHint,                                  \
+             catchInternalSectionHint =                                     \
+                 Catch::Detail::GetNewSectionHint(__VA_ARGS__);             \
+             catchInternalPreviousSectionHint == __LINE__ )                 \
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+#    define INTERNAL_CATCH_DYNAMIC_SECTION( ... )                           \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                           \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS                    \
+        CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS                             \
+        if ( [[maybe_unused]] const int catchInternalPreviousSectionHint =  \
+                 catchInternalSectionHint,                                  \
+             catchInternalSectionHint = Catch::Detail::GetNewSectionHint(   \
+                ( Catch::ReusableStringStream() << __VA_ARGS__ ).str());    \
+             catchInternalPreviousSectionHint == __LINE__ )                 \
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+#endif
+
+
+#endif // CATCH_SECTION_HPP_INCLUDED
+
+
+#ifndef CATCH_TEST_REGISTRY_HPP_INCLUDED
+#define CATCH_TEST_REGISTRY_HPP_INCLUDED
+
+
+
+#ifndef CATCH_INTERFACES_TEST_INVOKER_HPP_INCLUDED
+#define CATCH_INTERFACES_TEST_INVOKER_HPP_INCLUDED
+
+namespace Catch {
+
+    class ITestInvoker {
+    public:
+        virtual void prepareTestCase();
+        virtual void tearDownTestCase();
+        virtual void invoke() const = 0;
+        virtual ~ITestInvoker(); // = default
+    };
+
+} // namespace Catch
+
+#endif // CATCH_INTERFACES_TEST_INVOKER_HPP_INCLUDED
+
+
+#ifndef CATCH_PREPROCESSOR_REMOVE_PARENS_HPP_INCLUDED
+#define CATCH_PREPROCESSOR_REMOVE_PARENS_HPP_INCLUDED
+
+#define INTERNAL_CATCH_EXPAND1( param ) INTERNAL_CATCH_EXPAND2( param )
+#define INTERNAL_CATCH_EXPAND2( ... ) INTERNAL_CATCH_NO##__VA_ARGS__
+#define INTERNAL_CATCH_DEF( ... ) INTERNAL_CATCH_DEF __VA_ARGS__
+#define INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
+
+#define INTERNAL_CATCH_REMOVE_PARENS( ... ) \
+    INTERNAL_CATCH_EXPAND1( INTERNAL_CATCH_DEF __VA_ARGS__ )
+
+#endif // CATCH_PREPROCESSOR_REMOVE_PARENS_HPP_INCLUDED
+
+// GCC 5 and older do not properly handle disabling unused-variable warning
+// with a _Pragma. This means that we have to leak the suppression to the
+// user code as well :-(
+#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ <= 5
+#pragma GCC diagnostic ignored "-Wunused-variable"
+#endif
+
+
+
+namespace Catch {
+
+template<typename C>
+class TestInvokerAsMethod : public ITestInvoker {
+    void (C::*m_testAsMethod)();
+public:
+    constexpr TestInvokerAsMethod( void ( C::*testAsMethod )() ) noexcept:
+        m_testAsMethod( testAsMethod ) {}
+
+    void invoke() const override {
+        C obj;
+        (obj.*m_testAsMethod)();
+    }
+};
+
+Detail::unique_ptr<ITestInvoker> makeTestInvoker( void(*testAsFunction)() );
+
+template<typename C>
+Detail::unique_ptr<ITestInvoker> makeTestInvoker( void (C::*testAsMethod)() ) {
+    return Detail::make_unique<TestInvokerAsMethod<C>>( testAsMethod );
+}
+
+template <typename C>
+class TestInvokerFixture : public ITestInvoker {
+    void ( C::*m_testAsMethod )() const;
+    Detail::unique_ptr<C> m_fixture = nullptr;
+
+public:
+    constexpr TestInvokerFixture( void ( C::*testAsMethod )() const ) noexcept:
+        m_testAsMethod( testAsMethod ) {}
+
+    void prepareTestCase() override {
+        m_fixture = Detail::make_unique<C>();
+    }
+
+    void tearDownTestCase() override {
+        m_fixture.reset();
+    }
+
+    void invoke() const override {
+        auto* f = m_fixture.get();
+        ( f->*m_testAsMethod )();
+    }
+};
+
+template<typename C>
+Detail::unique_ptr<ITestInvoker> makeTestInvokerFixture( void ( C::*testAsMethod )() const ) {
+    return Detail::make_unique<TestInvokerFixture<C>>( testAsMethod );
+}
+
+struct NameAndTags {
+    constexpr NameAndTags( StringRef name_ = StringRef(),
+                           StringRef tags_ = StringRef() ) noexcept:
+        name( name_ ), tags( tags_ ) {}
+    StringRef name;
+    StringRef tags;
+};
+
+struct AutoReg : Detail::NonCopyable {
+    AutoReg( Detail::unique_ptr<ITestInvoker> invoker, SourceLineInfo const& lineInfo, StringRef classOrMethod, NameAndTags const& nameAndTags ) noexcept;
+};
+
+} // end namespace Catch
+
+#if defined(CATCH_CONFIG_DISABLE)
+    #define INTERNAL_CATCH_TESTCASE_NO_REGISTRATION( TestName, ... ) \
+        static inline void TestName()
+    #define INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION( TestName, ClassName, ... ) \
+        namespace{                        \
+            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
+                void test();              \
+            };                            \
+        }                                 \
+        void TestName::test()
+#endif
+
+
+#if !defined(CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT)
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_TESTCASE2( TestName, ... ) \
+        static void TestName(); \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+        namespace{ const Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &TestName ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        static void TestName()
+    #define INTERNAL_CATCH_TESTCASE( ... ) \
+        INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), __VA_ARGS__ )
+
+#else  // ^^ !CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT | vv CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT
+
+
+// Dummy registrator for the dumy test case macros
+namespace Catch {
+    namespace Detail {
+        struct DummyUse {
+            DummyUse( void ( * )( int ), Catch::NameAndTags const& );
+        };
+    } // namespace Detail
+} // namespace Catch
+
+// Note that both the presence of the argument and its exact name are
+// necessary for the section support.
+
+// We provide a shadowed variable so that a `SECTION` inside non-`TEST_CASE`
+// tests can compile. The redefined `TEST_CASE` shadows this with param.
+static int catchInternalSectionHint = 0;
+
+#    define INTERNAL_CATCH_TESTCASE2( fname, ... )                         \
+        static void fname( int );                                          \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                          \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                           \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS                   \
+        static const Catch::Detail::DummyUse INTERNAL_CATCH_UNIQUE_NAME(   \
+            dummyUser )( &(fname), Catch::NameAndTags{ __VA_ARGS__ } );    \
+        CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS                            \
+        static void fname( [[maybe_unused]] int catchInternalSectionHint ) \
+            CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+#    define INTERNAL_CATCH_TESTCASE( ... ) \
+        INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( dummyFunction ), __VA_ARGS__ )
+
+
+#endif // CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_TEST_CASE_METHOD2( TestName, ClassName, ... )\
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+        namespace{ \
+            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
+                void test(); \
+            }; \
+            const Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( \
+            Catch::makeTestInvoker( &TestName::test ),                    \
+            CATCH_INTERNAL_LINEINFO,                                      \
+            #ClassName##_catch_sr,                                        \
+            Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
+        } \
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        void TestName::test()
+    #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, ... ) \
+        INTERNAL_CATCH_TEST_CASE_METHOD2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), ClassName, __VA_ARGS__ )
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_TEST_CASE_PERSISTENT_FIXTURE2( TestName, ClassName, ... )      \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                             \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                              \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS                      \
+        namespace {                                                           \
+            struct TestName : INTERNAL_CATCH_REMOVE_PARENS( ClassName ) {     \
+                void test() const;                                            \
+            };                                                                \
+            const Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( \
+                Catch::makeTestInvokerFixture( &TestName::test ),                    \
+                CATCH_INTERNAL_LINEINFO,                                      \
+                #ClassName##_catch_sr,                                        \
+                Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */             \
+        }                                                                     \
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION                              \
+        void TestName::test() const
+    #define INTERNAL_CATCH_TEST_CASE_PERSISTENT_FIXTURE( ClassName, ... )    \
+        INTERNAL_CATCH_TEST_CASE_PERSISTENT_FIXTURE2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), ClassName, __VA_ARGS__ )
+
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, ... ) \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+        namespace {                                                           \
+        const Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( \
+            Catch::makeTestInvoker( &QualifiedMethod ),                   \
+            CATCH_INTERNAL_LINEINFO,                                      \
+            "&" #QualifiedMethod##_catch_sr,                              \
+            Catch::NameAndTags{ __VA_ARGS__ } );                          \
+    } /* NOLINT */ \
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_REGISTER_TESTCASE( Function, ... ) \
+        do { \
+            CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+            CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+            CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+            Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( Function ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
+            CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        } while(false)
+
+
+#endif // CATCH_TEST_REGISTRY_HPP_INCLUDED
+
+
+// All of our user-facing macros support configuration toggle, that
+// forces them to be defined prefixed with CATCH_. We also like to
+// support another toggle that can minimize (disable) their implementation.
+// Given this, we have 4 different configuration options below
+
+#if defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_DISABLE)
+
+  #define CATCH_REQUIRE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__ )
+  #define CATCH_REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
+
+  #define CATCH_REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "CATCH_REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__ )
+  #define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
+  #define CATCH_REQUIRE_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CATCH_REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__ )
+
+  #define CATCH_CHECK( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+  #define CATCH_CHECK_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
+  #define CATCH_CHECKED_IF( ... ) INTERNAL_CATCH_IF( "CATCH_CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
+  #define CATCH_CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CATCH_CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
+  #define CATCH_CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
+
+  #define CATCH_CHECK_THROWS( ... )  INTERNAL_CATCH_THROWS( "CATCH_CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+  #define CATCH_CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
+  #define CATCH_CHECK_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CATCH_CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+
+  #define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
+  #define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
+  #define CATCH_METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
+  #define CATCH_TEST_CASE_PERSISTENT_FIXTURE( className, ... ) INTERNAL_CATCH_TEST_CASE_PERSISTENT_FIXTURE( className, __VA_ARGS__ )
+  #define CATCH_REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
+  #define CATCH_SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
+  #define CATCH_DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
+  #define CATCH_FAIL( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
+  #define CATCH_FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+  #define CATCH_SUCCEED( ... ) INTERNAL_CATCH_MSG( "CATCH_SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+  #define CATCH_SKIP( ... ) INTERNAL_CATCH_MSG( "SKIP", Catch::ResultWas::ExplicitSkip, Catch::ResultDisposition::Normal, __VA_ARGS__ )
+
+
+  #if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
+    #define CATCH_STATIC_REQUIRE( ... )       static_assert(   __VA_ARGS__ ,      #__VA_ARGS__ );     CATCH_SUCCEED( #__VA_ARGS__ )
+    #define CATCH_STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); CATCH_SUCCEED( #__VA_ARGS__ )
+    #define CATCH_STATIC_CHECK( ... )       static_assert(   __VA_ARGS__ ,      #__VA_ARGS__ );     CATCH_SUCCEED( #__VA_ARGS__ )
+    #define CATCH_STATIC_CHECK_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); CATCH_SUCCEED( #__VA_ARGS__ )
+  #else
+    #define CATCH_STATIC_REQUIRE( ... )       CATCH_REQUIRE( __VA_ARGS__ )
+    #define CATCH_STATIC_REQUIRE_FALSE( ... ) CATCH_REQUIRE_FALSE( __VA_ARGS__ )
+    #define CATCH_STATIC_CHECK( ... )       CATCH_CHECK( __VA_ARGS__ )
+    #define CATCH_STATIC_CHECK_FALSE( ... ) CATCH_CHECK_FALSE( __VA_ARGS__ )
+  #endif
+
+
+  // "BDD-style" convenience wrappers
+  #define CATCH_SCENARIO( ... ) CATCH_TEST_CASE( "Scenario: " __VA_ARGS__ )
+  #define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
+  #define CATCH_GIVEN( desc )     INTERNAL_CATCH_DYNAMIC_SECTION( "    Given: " << desc )
+  #define CATCH_AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc )
+  #define CATCH_WHEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     When: " << desc )
+  #define CATCH_AND_WHEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc )
+  #define CATCH_THEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     Then: " << desc )
+  #define CATCH_AND_THEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( "      And: " << desc )
+
+#elif defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE) // ^^ prefixed, implemented | vv prefixed, disabled
+
+  #define CATCH_REQUIRE( ... )        (void)(0)
+  #define CATCH_REQUIRE_FALSE( ... )  (void)(0)
+
+  #define CATCH_REQUIRE_THROWS( ... ) (void)(0)
+  #define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) (void)(0)
+  #define CATCH_REQUIRE_NOTHROW( ... ) (void)(0)
+
+  #define CATCH_CHECK( ... )         (void)(0)
+  #define CATCH_CHECK_FALSE( ... )   (void)(0)
+  #define CATCH_CHECKED_IF( ... )    if (__VA_ARGS__)
+  #define CATCH_CHECKED_ELSE( ... )  if (!(__VA_ARGS__))
+  #define CATCH_CHECK_NOFAIL( ... )  (void)(0)
+
+  #define CATCH_CHECK_THROWS( ... )  (void)(0)
+  #define CATCH_CHECK_THROWS_AS( expr, exceptionType ) (void)(0)
+  #define CATCH_CHECK_NOTHROW( ... ) (void)(0)
+
+  #define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ))
+  #define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ))
+  #define CATCH_METHOD_AS_TEST_CASE( method, ... )
+  #define CATCH_TEST_CASE_PERSISTENT_FIXTURE( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ))
+  #define CATCH_REGISTER_TEST_CASE( Function, ... ) (void)(0)
+  #define CATCH_SECTION( ... )
+  #define CATCH_DYNAMIC_SECTION( ... )
+  #define CATCH_FAIL( ... ) (void)(0)
+  #define CATCH_FAIL_CHECK( ... ) (void)(0)
+  #define CATCH_SUCCEED( ... ) (void)(0)
+  #define CATCH_SKIP( ... ) (void)(0)
+
+  #define CATCH_STATIC_REQUIRE( ... )       (void)(0)
+  #define CATCH_STATIC_REQUIRE_FALSE( ... ) (void)(0)
+  #define CATCH_STATIC_CHECK( ... )       (void)(0)
+  #define CATCH_STATIC_CHECK_FALSE( ... ) (void)(0)
+
+  // "BDD-style" convenience wrappers
+  #define CATCH_SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ))
+  #define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), className )
+  #define CATCH_GIVEN( desc )
+  #define CATCH_AND_GIVEN( desc )
+  #define CATCH_WHEN( desc )
+  #define CATCH_AND_WHEN( desc )
+  #define CATCH_THEN( desc )
+  #define CATCH_AND_THEN( desc )
+
+#elif !defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_DISABLE) // ^^ prefixed, disabled | vv unprefixed, implemented
+
+  #define REQUIRE( ... ) INTERNAL_CATCH_TEST( "REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__  )
+  #define REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
+
+  #define REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__ )
+  #define REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
+  #define REQUIRE_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__ )
+
+  #define CHECK( ... ) INTERNAL_CATCH_TEST( "CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+  #define CHECK_FALSE( ... ) INTERNAL_CATCH_TEST( "CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
+  #define CHECKED_IF( ... ) INTERNAL_CATCH_IF( "CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
+  #define CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
+  #define CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
+
+  #define CHECK_THROWS( ... )  INTERNAL_CATCH_THROWS( "CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+  #define CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
+  #define CHECK_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+
+  #define TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
+  #define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
+  #define METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
+  #define TEST_CASE_PERSISTENT_FIXTURE( className, ... ) INTERNAL_CATCH_TEST_CASE_PERSISTENT_FIXTURE( className, __VA_ARGS__ )
+  #define REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
+  #define SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
+  #define DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
+  #define FAIL( ... ) INTERNAL_CATCH_MSG( "FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
+  #define FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+  #define SUCCEED( ... ) INTERNAL_CATCH_MSG( "SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+  #define SKIP( ... ) INTERNAL_CATCH_MSG( "SKIP", Catch::ResultWas::ExplicitSkip, Catch::ResultDisposition::Normal, __VA_ARGS__ )
+
+
+  #if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
+    #define STATIC_REQUIRE( ... )       static_assert(   __VA_ARGS__,  #__VA_ARGS__ ); SUCCEED( #__VA_ARGS__ )
+    #define STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); SUCCEED( "!(" #__VA_ARGS__ ")" )
+    #define STATIC_CHECK( ... )       static_assert(   __VA_ARGS__,  #__VA_ARGS__ ); SUCCEED( #__VA_ARGS__ )
+    #define STATIC_CHECK_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); SUCCEED( "!(" #__VA_ARGS__ ")" )
+  #else
+    #define STATIC_REQUIRE( ... )       REQUIRE( __VA_ARGS__ )
+    #define STATIC_REQUIRE_FALSE( ... ) REQUIRE_FALSE( __VA_ARGS__ )
+    #define STATIC_CHECK( ... )       CHECK( __VA_ARGS__ )
+    #define STATIC_CHECK_FALSE( ... ) CHECK_FALSE( __VA_ARGS__ )
+  #endif
+
+  // "BDD-style" convenience wrappers
+  #define SCENARIO( ... ) TEST_CASE( "Scenario: " __VA_ARGS__ )
+  #define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
+  #define GIVEN( desc )     INTERNAL_CATCH_DYNAMIC_SECTION( "    Given: " << desc )
+  #define AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc )
+  #define WHEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     When: " << desc )
+  #define AND_WHEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc )
+  #define THEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     Then: " << desc )
+  #define AND_THEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( "      And: " << desc )
+
+#elif !defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE) // ^^ unprefixed, implemented | vv unprefixed, disabled
+
+  #define REQUIRE( ... )       (void)(0)
+  #define REQUIRE_FALSE( ... ) (void)(0)
+
+  #define REQUIRE_THROWS( ... ) (void)(0)
+  #define REQUIRE_THROWS_AS( expr, exceptionType ) (void)(0)
+  #define REQUIRE_NOTHROW( ... ) (void)(0)
+
+  #define CHECK( ... ) (void)(0)
+  #define CHECK_FALSE( ... ) (void)(0)
+  #define CHECKED_IF( ... ) if (__VA_ARGS__)
+  #define CHECKED_ELSE( ... ) if (!(__VA_ARGS__))
+  #define CHECK_NOFAIL( ... ) (void)(0)
+
+  #define CHECK_THROWS( ... )  (void)(0)
+  #define CHECK_THROWS_AS( expr, exceptionType ) (void)(0)
+  #define CHECK_NOTHROW( ... ) (void)(0)
+
+  #define TEST_CASE( ... )  INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), __VA_ARGS__)
+  #define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ))
+  #define METHOD_AS_TEST_CASE( method, ... )
+  #define TEST_CASE_PERSISTENT_FIXTURE( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), __VA_ARGS__)
+  #define REGISTER_TEST_CASE( Function, ... ) (void)(0)
+  #define SECTION( ... )
+  #define DYNAMIC_SECTION( ... )
+  #define FAIL( ... ) (void)(0)
+  #define FAIL_CHECK( ... ) (void)(0)
+  #define SUCCEED( ... ) (void)(0)
+  #define SKIP( ... ) (void)(0)
+
+  #define STATIC_REQUIRE( ... )       (void)(0)
+  #define STATIC_REQUIRE_FALSE( ... ) (void)(0)
+  #define STATIC_CHECK( ... )       (void)(0)
+  #define STATIC_CHECK_FALSE( ... ) (void)(0)
+
+  // "BDD-style" convenience wrappers
+  #define SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ) )
+  #define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), className )
+
+  #define GIVEN( desc )
+  #define AND_GIVEN( desc )
+  #define WHEN( desc )
+  #define AND_WHEN( desc )
+  #define THEN( desc )
+  #define AND_THEN( desc )
+
+#endif // ^^ unprefixed, disabled
+
+// end of user facing macros
+
+#endif // CATCH_TEST_MACROS_HPP_INCLUDED
+
+
+#ifndef CATCH_TEMPLATE_TEST_REGISTRY_HPP_INCLUDED
+#define CATCH_TEMPLATE_TEST_REGISTRY_HPP_INCLUDED
+
+
+
+#ifndef CATCH_PREPROCESSOR_HPP_INCLUDED
+#define CATCH_PREPROCESSOR_HPP_INCLUDED
+
+
+#if defined(__GNUC__)
+// We need to silence "empty __VA_ARGS__ warning", and using just _Pragma does not work
+#pragma GCC system_header
+#endif
+
+
+#define CATCH_RECURSION_LEVEL0(...) __VA_ARGS__
+#define CATCH_RECURSION_LEVEL1(...) CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(__VA_ARGS__)))
+#define CATCH_RECURSION_LEVEL2(...) CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(__VA_ARGS__)))
+#define CATCH_RECURSION_LEVEL3(...) CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(__VA_ARGS__)))
+#define CATCH_RECURSION_LEVEL4(...) CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(__VA_ARGS__)))
+#define CATCH_RECURSION_LEVEL5(...) CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(__VA_ARGS__)))
+
+#ifdef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define INTERNAL_CATCH_EXPAND_VARGS(...) __VA_ARGS__
+// MSVC needs more evaluations
+#define CATCH_RECURSION_LEVEL6(...) CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(__VA_ARGS__)))
+#define CATCH_RECURSE(...)  CATCH_RECURSION_LEVEL6(CATCH_RECURSION_LEVEL6(__VA_ARGS__))
+#else
+#define CATCH_RECURSE(...)  CATCH_RECURSION_LEVEL5(__VA_ARGS__)
+#endif
+
+#define CATCH_REC_END(...)
+#define CATCH_REC_OUT
+
+#define CATCH_EMPTY()
+#define CATCH_DEFER(id) id CATCH_EMPTY()
+
+#define CATCH_REC_GET_END2() 0, CATCH_REC_END
+#define CATCH_REC_GET_END1(...) CATCH_REC_GET_END2
+#define CATCH_REC_GET_END(...) CATCH_REC_GET_END1
+#define CATCH_REC_NEXT0(test, next, ...) next CATCH_REC_OUT
+#define CATCH_REC_NEXT1(test, next) CATCH_DEFER ( CATCH_REC_NEXT0 ) ( test, next, 0)
+#define CATCH_REC_NEXT(test, next)  CATCH_REC_NEXT1(CATCH_REC_GET_END test, next)
+
+#define CATCH_REC_LIST0(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )
+#define CATCH_REC_LIST1(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0) ) ( f, peek, __VA_ARGS__ )
+#define CATCH_REC_LIST2(f, x, peek, ...)   f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )
+
+#define CATCH_REC_LIST0_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )
+#define CATCH_REC_LIST1_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0_UD) ) ( f, userdata, peek, __VA_ARGS__ )
+#define CATCH_REC_LIST2_UD(f, userdata, x, peek, ...)   f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )
+
+// Applies the function macro `f` to each of the remaining parameters, inserts commas between the results,
+// and passes userdata as the first parameter to each invocation,
+// e.g. CATCH_REC_LIST_UD(f, x, a, b, c) evaluates to f(x, a), f(x, b), f(x, c)
+#define CATCH_REC_LIST_UD(f, userdata, ...) CATCH_RECURSE(CATCH_REC_LIST2_UD(f, userdata, __VA_ARGS__, ()()(), ()()(), ()()(), 0))
+
+#define CATCH_REC_LIST(f, ...) CATCH_RECURSE(CATCH_REC_LIST2(f, __VA_ARGS__, ()()(), ()()(), ()()(), 0))
+
+#define INTERNAL_CATCH_STRINGIZE(...) INTERNAL_CATCH_STRINGIZE2(__VA_ARGS__)
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define INTERNAL_CATCH_STRINGIZE2(...) #__VA_ARGS__
+#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param))
+#else
+// MSVC is adding extra space and needs another indirection to expand INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
+#define INTERNAL_CATCH_STRINGIZE2(...) INTERNAL_CATCH_STRINGIZE3(__VA_ARGS__)
+#define INTERNAL_CATCH_STRINGIZE3(...) #__VA_ARGS__
+#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) (INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param)) + 1)
+#endif
+
+#define INTERNAL_CATCH_MAKE_NAMESPACE2(...) ns_##__VA_ARGS__
+#define INTERNAL_CATCH_MAKE_NAMESPACE(name) INTERNAL_CATCH_MAKE_NAMESPACE2(name)
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>())
+#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__))
+#else
+#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) INTERNAL_CATCH_EXPAND_VARGS(decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>()))
+#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__)))
+#endif
+
+#define INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(...)\
+    CATCH_REC_LIST(INTERNAL_CATCH_MAKE_TYPE_LIST,__VA_ARGS__)
+
+#define INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_0) INTERNAL_CATCH_REMOVE_PARENS(_0)
+#define INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_0, _1) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_1)
+#define INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_0, _1, _2) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_1, _2)
+#define INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_0, _1, _2, _3) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_1, _2, _3)
+#define INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_0, _1, _2, _3, _4) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_1, _2, _3, _4)
+#define INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_0, _1, _2, _3, _4, _5) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_1, _2, _3, _4, _5)
+#define INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_0, _1, _2, _3, _4, _5, _6) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_1, _2, _3, _4, _5, _6)
+#define INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_0, _1, _2, _3, _4, _5, _6, _7) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_1, _2, _3, _4, _5, _6, _7)
+#define INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_1, _2, _3, _4, _5, _6, _7, _8)
+#define INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9)
+#define INTERNAL_CATCH_REMOVE_PARENS_11_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10)
+
+#define INTERNAL_CATCH_VA_NARGS_IMPL(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N
+
+#define INTERNAL_CATCH_TYPE_GEN\
+    template<typename...> struct TypeList {};\
+    template<typename...Ts>\
+    constexpr auto get_wrapper() noexcept -> TypeList<Ts...> { return {}; }\
+    template<template<typename...> class...> struct TemplateTypeList{};\
+    template<template<typename...> class...Cs>\
+    constexpr auto get_wrapper() noexcept -> TemplateTypeList<Cs...> { return {}; }\
+    template<typename...>\
+    struct append;\
+    template<typename...>\
+    struct rewrap;\
+    template<template<typename...> class, typename...>\
+    struct create;\
+    template<template<typename...> class, typename>\
+    struct convert;\
+    \
+    template<typename T> \
+    struct append<T> { using type = T; };\
+    template< template<typename...> class L1, typename...E1, template<typename...> class L2, typename...E2, typename...Rest>\
+    struct append<L1<E1...>, L2<E2...>, Rest...> { using type = typename append<L1<E1...,E2...>, Rest...>::type; };\
+    template< template<typename...> class L1, typename...E1, typename...Rest>\
+    struct append<L1<E1...>, TypeList<mpl_::na>, Rest...> { using type = L1<E1...>; };\
+    \
+    template< template<typename...> class Container, template<typename...> class List, typename...elems>\
+    struct rewrap<TemplateTypeList<Container>, List<elems...>> { using type = TypeList<Container<elems...>>; };\
+    template< template<typename...> class Container, template<typename...> class List, class...Elems, typename...Elements>\
+    struct rewrap<TemplateTypeList<Container>, List<Elems...>, Elements...> { using type = typename append<TypeList<Container<Elems...>>, typename rewrap<TemplateTypeList<Container>, Elements...>::type>::type; };\
+    \
+    template<template <typename...> class Final, template< typename...> class...Containers, typename...Types>\
+    struct create<Final, TemplateTypeList<Containers...>, TypeList<Types...>> { using type = typename append<Final<>, typename rewrap<TemplateTypeList<Containers>, Types...>::type...>::type; };\
+    template<template <typename...> class Final, template <typename...> class List, typename...Ts>\
+    struct convert<Final, List<Ts...>> { using type = typename append<Final<>,TypeList<Ts>...>::type; };
+
+#define INTERNAL_CATCH_NTTP_1(signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> struct Nttp{};\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    constexpr auto get_wrapper() noexcept -> Nttp<__VA_ARGS__> { return {}; } \
+    template<template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...> struct NttpTemplateTypeList{};\
+    template<template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...Cs>\
+    constexpr auto get_wrapper() noexcept -> NttpTemplateTypeList<Cs...> { return {}; } \
+    \
+    template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    struct rewrap<NttpTemplateTypeList<Container>, List<__VA_ARGS__>> { using type = TypeList<Container<__VA_ARGS__>>; };\
+    template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature), typename...Elements>\
+    struct rewrap<NttpTemplateTypeList<Container>, List<__VA_ARGS__>, Elements...> { using type = typename append<TypeList<Container<__VA_ARGS__>>, typename rewrap<NttpTemplateTypeList<Container>, Elements...>::type>::type; };\
+    template<template <typename...> class Final, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...Containers, typename...Types>\
+    struct create<Final, NttpTemplateTypeList<Containers...>, TypeList<Types...>> { using type = typename append<Final<>, typename rewrap<NttpTemplateTypeList<Containers>, Types...>::type...>::type; };
+
+#define INTERNAL_CATCH_DECLARE_SIG_TEST0(TestName)
+#define INTERNAL_CATCH_DECLARE_SIG_TEST1(TestName, signature)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    static void TestName()
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_X(TestName, signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    static void TestName()
+
+#define INTERNAL_CATCH_DEFINE_SIG_TEST0(TestName)
+#define INTERNAL_CATCH_DEFINE_SIG_TEST1(TestName, signature)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    static void TestName()
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_X(TestName, signature,...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    static void TestName()
+
+#define INTERNAL_CATCH_NTTP_REGISTER0(TestFunc, signature)\
+    template<typename Type>\
+    void reg_test(TypeList<Type>, Catch::NameAndTags nameAndTags)\
+    {\
+        Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<Type>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
+    }
+
+#define INTERNAL_CATCH_NTTP_REGISTER(TestFunc, signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    void reg_test(Nttp<__VA_ARGS__>, Catch::NameAndTags nameAndTags)\
+    {\
+        Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<__VA_ARGS__>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
+    }
+
+#define INTERNAL_CATCH_NTTP_REGISTER_METHOD0(TestName, signature, ...)\
+    template<typename Type>\
+    void reg_test(TypeList<Type>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
+    {\
+        Catch::AutoReg( Catch::makeTestInvoker(&TestName<Type>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
+    }
+
+#define INTERNAL_CATCH_NTTP_REGISTER_METHOD(TestName, signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    void reg_test(Nttp<__VA_ARGS__>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
+    {\
+        Catch::AutoReg( Catch::makeTestInvoker(&TestName<__VA_ARGS__>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
+    }
+
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0(TestName, ClassName)
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1(TestName, ClassName, signature)\
+    template<typename TestType> \
+    struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<TestType> { \
+        void test();\
+    }
+
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X(TestName, ClassName, signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
+    struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<__VA_ARGS__> { \
+        void test();\
+    }
+
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0(TestName)
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1(TestName, signature)\
+    template<typename TestType> \
+    void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<TestType>::test()
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X(TestName, signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
+    void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<__VA_ARGS__>::test()
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define INTERNAL_CATCH_NTTP_0
+#define INTERNAL_CATCH_NTTP_GEN(...) INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__),INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_0)
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__)
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__)
+#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__)
+#define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__)
+#define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__)
+#define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__)
+#define INTERNAL_CATCH_REMOVE_PARENS_GEN(...) INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG,INTERNAL_CATCH_REMOVE_PARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,INTERNAL_CATCH_REMOVE_PARENS_8_ARG,INTERNAL_CATCH_REMOVE_PARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,INTERNAL_CATCH_REMOVE_PARENS_5_ARG,INTERNAL_CATCH_REMOVE_PARENS_4_ARG,INTERNAL_CATCH_REMOVE_PARENS_3_ARG,INTERNAL_CATCH_REMOVE_PARENS_2_ARG,INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__)
+#else
+#define INTERNAL_CATCH_NTTP_0(signature)
+#define INTERNAL_CATCH_NTTP_GEN(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1,INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_0)( __VA_ARGS__))
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__))
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__))
+#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__))
+#define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__))
+#define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__))
+#define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__))
+#define INTERNAL_CATCH_REMOVE_PARENS_GEN(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG,INTERNAL_CATCH_REMOVE_PARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,INTERNAL_CATCH_REMOVE_PARENS_8_ARG,INTERNAL_CATCH_REMOVE_PARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,INTERNAL_CATCH_REMOVE_PARENS_5_ARG,INTERNAL_CATCH_REMOVE_PARENS_4_ARG,INTERNAL_CATCH_REMOVE_PARENS_3_ARG,INTERNAL_CATCH_REMOVE_PARENS_2_ARG,INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__))
+#endif
+
+#endif // CATCH_PREPROCESSOR_HPP_INCLUDED
+
+
+// GCC 5 and older do not properly handle disabling unused-variable warning
+// with a _Pragma. This means that we have to leak the suppression to the
+// user code as well :-(
+#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ <= 5
+#pragma GCC diagnostic ignored "-Wunused-variable"
+#endif
+
+#if defined(CATCH_CONFIG_DISABLE)
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( TestName, TestFunc, Name, Tags, Signature, ... )  \
+        INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature))
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( TestNameClass, TestName, ClassName, Name, Tags, Signature, ... )    \
+        namespace{                                                                                  \
+            namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) {                                      \
+            INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
+        }                                                                                           \
+        }                                                                                           \
+        INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))
+
+    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...) \
+            INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, typename TestType, __VA_ARGS__ )
+    #else
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...) \
+            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, typename TestType, __VA_ARGS__ ) )
+    #endif
+
+    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...) \
+            INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, Signature, __VA_ARGS__ )
+    #else
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...) \
+            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, Signature, __VA_ARGS__ ) )
+    #endif
+
+    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( ClassName, Name, Tags,... ) \
+            INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ )
+    #else
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( ClassName, Name, Tags,... ) \
+            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ ) )
+    #endif
+
+    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION( ClassName, Name, Tags, Signature, ... ) \
+            INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ )
+    #else
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION( ClassName, Name, Tags, Signature, ... ) \
+            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ ) )
+    #endif
+#endif
+
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_2(TestName, TestFunc, Name, Tags, Signature, ... )\
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
+        INTERNAL_CATCH_DECLARE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
+            INTERNAL_CATCH_TYPE_GEN\
+            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+            INTERNAL_CATCH_NTTP_REG_GEN(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+            template<typename...Types> \
+            struct TestName{\
+                TestName(){\
+                    size_t index = 0;                                    \
+                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)}; /* NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays,hicpp-avoid-c-arrays) */\
+                    using expander = size_t[]; /* NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays,hicpp-avoid-c-arrays) */\
+                    (void)expander{(reg_test(Types{}, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++)... };/* NOLINT */ \
+                }\
+            };\
+            static const int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
+            TestName<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
+            return 0;\
+        }();\
+        }\
+        }\
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
+        INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, typename TestType, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, typename TestType, __VA_ARGS__ ) )
+#endif
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...) \
+        INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, Signature, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...) \
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, Signature, __VA_ARGS__ ) )
+#endif
+
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(TestName, TestFuncName, Name, Tags, Signature, TmplTypes, TypesList) \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                      \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                      \
+        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS                \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS       \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
+        template<typename TestType> static void TestFuncName();       \
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) {                                     \
+            INTERNAL_CATCH_TYPE_GEN                                                  \
+            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))         \
+            template<typename... Types>                               \
+            struct TestName {                                         \
+                void reg_tests() {                                          \
+                    size_t index = 0;                                    \
+                    using expander = size_t[];                           \
+                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\
+                    constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\
+                    constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\
+                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFuncName<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + '<' + std::string(types_list[index % num_types]) + '>', Tags } ), index++)... };/* NOLINT */\
+                }                                                     \
+            };                                                        \
+            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
+                using TestInit = typename create<TestName, decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>()), TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type; \
+                TestInit t;                                           \
+                t.reg_tests();                                        \
+                return 0;                                             \
+            }();                                                      \
+        }                                                             \
+        }                                                             \
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION                       \
+        template<typename TestType>                                   \
+        static void TestFuncName()
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)\
+        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, typename T,__VA_ARGS__)
+#else
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)\
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, typename T, __VA_ARGS__ ) )
+#endif
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)\
+        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, Signature, __VA_ARGS__)
+#else
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)\
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, Signature, __VA_ARGS__ ) )
+#endif
+
+    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2(TestName, TestFunc, Name, Tags, TmplList)\
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
+        template<typename TestType> static void TestFunc();       \
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
+        INTERNAL_CATCH_TYPE_GEN\
+        template<typename... Types>                               \
+        struct TestName {                                         \
+            void reg_tests() {                                          \
+                size_t index = 0;                                    \
+                using expander = size_t[];                           \
+                (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFunc<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " INTERNAL_CATCH_STRINGIZE(TmplList) " - " + std::to_string(index), Tags } ), index++)... };/* NOLINT */\
+            }                                                     \
+        };\
+        static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
+                using TestInit = typename convert<TestName, TmplList>::type; \
+                TestInit t;                                           \
+                t.reg_tests();                                        \
+                return 0;                                             \
+            }();                                                      \
+        }}\
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION                       \
+        template<typename TestType>                                   \
+        static void TestFunc()
+
+    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(Name, Tags, TmplList) \
+        INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, TmplList )
+
+
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, Signature, ... ) \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
+            INTERNAL_CATCH_TYPE_GEN\
+            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+            INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
+            INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+            template<typename...Types> \
+            struct TestNameClass{\
+                TestNameClass(){\
+                    size_t index = 0;                                    \
+                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};\
+                    using expander = size_t[];\
+                    (void)expander{(reg_test(Types{}, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++)... };/* NOLINT */ \
+                }\
+            };\
+            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
+                TestNameClass<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
+                return 0;\
+        }();\
+        }\
+        }\
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
+        INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ ) )
+#endif
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... ) \
+        INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... ) \
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ ) )
+#endif
+
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2(TestNameClass, TestName, ClassName, Name, Tags, Signature, TmplTypes, TypesList)\
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+        template<typename TestType> \
+            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
+                void test();\
+            };\
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestNameClass) {\
+            INTERNAL_CATCH_TYPE_GEN                  \
+            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+            template<typename...Types>\
+            struct TestNameClass{\
+                void reg_tests(){\
+                    std::size_t index = 0;\
+                    using expander = std::size_t[];\
+                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\
+                    constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\
+                    constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\
+                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + '<' + std::string(types_list[index % num_types]) + '>', Tags } ), index++)... };/* NOLINT */ \
+                }\
+            };\
+            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
+                using TestInit = typename create<TestNameClass, decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>()), TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type;\
+                TestInit t;\
+                t.reg_tests();\
+                return 0;\
+            }(); \
+        }\
+        }\
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        template<typename TestType> \
+        void TestName<TestType>::test()
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( ClassName, Name, Tags, ... )\
+        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), ClassName, Name, Tags, typename T, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( ClassName, Name, Tags, ... )\
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), ClassName, Name, Tags, typename T,__VA_ARGS__ ) )
+#endif
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... )\
+        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), ClassName, Name, Tags, Signature, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... )\
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), ClassName, Name, Tags, Signature,__VA_ARGS__ ) )
+#endif
+
+    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, TmplList) \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
+        template<typename TestType> \
+        struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
+            void test();\
+        };\
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
+            INTERNAL_CATCH_TYPE_GEN\
+            template<typename...Types>\
+            struct TestNameClass{\
+                void reg_tests(){\
+                    size_t index = 0;\
+                    using expander = size_t[];\
+                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName##_catch_sr, Catch::NameAndTags{ Name " - " INTERNAL_CATCH_STRINGIZE(TmplList) " - " + std::to_string(index), Tags } ), index++)... };/* NOLINT */ \
+                }\
+            };\
+            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
+                using TestInit = typename convert<TestNameClass, TmplList>::type;\
+                TestInit t;\
+                t.reg_tests();\
+                return 0;\
+            }(); \
+        }}\
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        template<typename TestType> \
+        void TestName<TestType>::test()
+
+#define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD(ClassName, Name, Tags, TmplList) \
+        INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), ClassName, Name, Tags, TmplList )
+
+
+#endif // CATCH_TEMPLATE_TEST_REGISTRY_HPP_INCLUDED
+
+
+#if defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_DISABLE)
+
+  #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+    #define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )
+    #define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+    #define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
+    #define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
+    #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ )
+    #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
+    #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
+    #define CATCH_TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(__VA_ARGS__)
+    #define CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ )
+  #else
+    #define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
+    #define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ ) )
+    #define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+    #define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
+    #define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
+    #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ ) )
+    #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+    #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
+    #define CATCH_TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE( __VA_ARGS__ ) )
+    #define CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+  #endif
+
+#elif defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE)
+
+  #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
+    #define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
+    #define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
+    #define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ )
+  #else
+    #define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__) )
+    #define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__) )
+    #define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__ ) )
+    #define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ ) )
+  #endif
+
+  // When disabled, these can be shared between proper preprocessor and MSVC preprocessor
+  #define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+  #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+  #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+  #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+  #define CATCH_TEMPLATE_LIST_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE(__VA_ARGS__)
+  #define CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+
+#elif !defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_DISABLE)
+
+  #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+    #define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )
+    #define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+    #define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
+    #define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
+    #define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ )
+    #define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
+    #define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
+    #define TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(__VA_ARGS__)
+    #define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ )
+  #else
+    #define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
+    #define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ ) )
+    #define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+    #define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
+    #define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
+    #define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ ) )
+    #define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+    #define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
+    #define TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE( __VA_ARGS__ ) )
+    #define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+  #endif
+
+#elif !defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE)
+
+  #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
+    #define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
+    #define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
+    #define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ )
+  #else
+    #define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__) )
+    #define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__) )
+    #define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__ ) )
+    #define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ ) )
+  #endif
+
+  // When disabled, these can be shared between proper preprocessor and MSVC preprocessor
+  #define TEMPLATE_PRODUCT_TEST_CASE( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
+  #define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
+  #define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+  #define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+  #define TEMPLATE_LIST_TEST_CASE( ... ) TEMPLATE_TEST_CASE(__VA_ARGS__)
+  #define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+
+#endif // end of user facing macro declarations
+
+
+#endif // CATCH_TEMPLATE_TEST_MACROS_HPP_INCLUDED
+
+
+#ifndef CATCH_TEST_CASE_INFO_HPP_INCLUDED
+#define CATCH_TEST_CASE_INFO_HPP_INCLUDED
+
+
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+namespace Catch {
+
+    /**
+     * A **view** of a tag string that provides case insensitive comparisons
+     *
+     * Note that in Catch2 internals, the square brackets around tags are
+     * not a part of tag's representation, so e.g. "[cool-tag]" is represented
+     * as "cool-tag" internally.
+     */
+    struct Tag {
+        constexpr Tag(StringRef original_):
+            original(original_)
+        {}
+        StringRef original;
+
+        friend bool operator< ( Tag const& lhs, Tag const& rhs );
+        friend bool operator==( Tag const& lhs, Tag const& rhs );
+    };
+
+    class ITestInvoker;
+    struct NameAndTags;
+
+    enum class TestCaseProperties : uint8_t {
+        None = 0,
+        IsHidden = 1 << 1,
+        ShouldFail = 1 << 2,
+        MayFail = 1 << 3,
+        Throws = 1 << 4,
+        NonPortable = 1 << 5,
+        Benchmark = 1 << 6
+    };
+
+    /**
+     * Various metadata about the test case.
+     *
+     * A test case is uniquely identified by its (class)name and tags
+     * combination, with source location being ignored, and other properties
+     * being determined from tags.
+     *
+     * Tags are kept sorted.
+     */
+    struct TestCaseInfo : Detail::NonCopyable {
+
+        TestCaseInfo(StringRef _className,
+                     NameAndTags const& _nameAndTags,
+                     SourceLineInfo const& _lineInfo);
+
+        bool isHidden() const;
+        bool throws() const;
+        bool okToFail() const;
+        bool expectedToFail() const;
+
+        // Adds the tag(s) with test's filename (for the -# flag)
+        void addFilenameTag();
+
+        //! Orders by name, classname and tags
+        friend bool operator<( TestCaseInfo const& lhs,
+                               TestCaseInfo const& rhs );
+
+
+        std::string tagsAsString() const;
+
+        std::string name;
+        StringRef className;
+    private:
+        std::string backingTags;
+        // Internally we copy tags to the backing storage and then add
+        // refs to this storage to the tags vector.
+        void internalAppendTag(StringRef tagString);
+    public:
+        std::vector<Tag> tags;
+        SourceLineInfo lineInfo;
+        TestCaseProperties properties = TestCaseProperties::None;
+    };
+
+    /**
+     * Wrapper over the test case information and the test case invoker
+     *
+     * Does not own either, and is specifically made to be cheap
+     * to copy around.
+     */
+    class TestCaseHandle {
+        TestCaseInfo* m_info;
+        ITestInvoker* m_invoker;
+    public:
+        constexpr TestCaseHandle(TestCaseInfo* info, ITestInvoker* invoker) :
+            m_info(info), m_invoker(invoker) {}
+
+        void prepareTestCase() const {
+            m_invoker->prepareTestCase();
+        }
+
+        void tearDownTestCase() const {
+            m_invoker->tearDownTestCase();
+        }
+
+        void invoke() const {
+            m_invoker->invoke();
+        }
+
+        constexpr TestCaseInfo const& getTestCaseInfo() const {
+            return *m_info;
+        }
+    };
+
+    Detail::unique_ptr<TestCaseInfo>
+    makeTestCaseInfo( StringRef className,
+                      NameAndTags const& nameAndTags,
+                      SourceLineInfo const& lineInfo );
+}
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+#endif // CATCH_TEST_CASE_INFO_HPP_INCLUDED
+
+
+#ifndef CATCH_TRANSLATE_EXCEPTION_HPP_INCLUDED
+#define CATCH_TRANSLATE_EXCEPTION_HPP_INCLUDED
+
+
+
+#ifndef CATCH_INTERFACES_EXCEPTION_HPP_INCLUDED
+#define CATCH_INTERFACES_EXCEPTION_HPP_INCLUDED
+
+
+#include <string>
+#include <vector>
+
+namespace Catch {
+    using exceptionTranslateFunction = std::string(*)();
+
+    class IExceptionTranslator;
+    using ExceptionTranslators = std::vector<Detail::unique_ptr<IExceptionTranslator const>>;
+
+    class IExceptionTranslator {
+    public:
+        virtual ~IExceptionTranslator(); // = default
+        virtual std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const = 0;
+    };
+
+    class IExceptionTranslatorRegistry {
+    public:
+        virtual ~IExceptionTranslatorRegistry(); // = default
+        virtual std::string translateActiveException() const = 0;
+    };
+
+} // namespace Catch
+
+#endif // CATCH_INTERFACES_EXCEPTION_HPP_INCLUDED
+
+#include <exception>
+
+namespace Catch {
+    namespace Detail {
+        void registerTranslatorImpl(
+            Detail::unique_ptr<IExceptionTranslator>&& translator );
+    }
+
+    class ExceptionTranslatorRegistrar {
+        template<typename T>
+        class ExceptionTranslator : public IExceptionTranslator {
+        public:
+
+            constexpr ExceptionTranslator( std::string(*translateFunction)( T const& ) )
+            : m_translateFunction( translateFunction )
+            {}
+
+            std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const override {
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+                try {
+                    if( it == itEnd )
+                        std::rethrow_exception(std::current_exception());
+                    else
+                        return (*it)->translate( it+1, itEnd );
+                }
+                catch( T const& ex ) {
+                    return m_translateFunction( ex );
+                }
+#else
+                return "You should never get here!";
+#endif
+            }
+
+        protected:
+            std::string(*m_translateFunction)( T const& );
+        };
+
+    public:
+        template<typename T>
+        ExceptionTranslatorRegistrar( std::string(*translateFunction)( T const& ) ) {
+            Detail::registerTranslatorImpl(
+                Detail::make_unique<ExceptionTranslator<T>>(
+                    translateFunction ) );
+        }
+    };
+
+} // namespace Catch
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_TRANSLATE_EXCEPTION2( translatorName, signature ) \
+    static std::string translatorName( signature ); \
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+    namespace{ Catch::ExceptionTranslatorRegistrar INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionRegistrar )( &translatorName ); } \
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+    static std::string translatorName( signature )
+
+#define INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION2( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
+
+#if defined(CATCH_CONFIG_DISABLE)
+    #define INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( translatorName, signature) \
+            static std::string translatorName( signature )
+#endif
+
+
+// This macro is always prefixed
+#if !defined(CATCH_CONFIG_DISABLE)
+#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature )
+#else
+#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
+#endif
+
+
+#endif // CATCH_TRANSLATE_EXCEPTION_HPP_INCLUDED
+
+
+#ifndef CATCH_VERSION_HPP_INCLUDED
+#define CATCH_VERSION_HPP_INCLUDED
+
+#include <iosfwd>
+
+namespace Catch {
+
+    // Versioning information
+    struct Version {
+        Version( Version const& ) = delete;
+        Version& operator=( Version const& ) = delete;
+        Version(    unsigned int _majorVersion,
+                    unsigned int _minorVersion,
+                    unsigned int _patchNumber,
+                    char const * const _branchName,
+                    unsigned int _buildNumber );
+
+        unsigned int const majorVersion;
+        unsigned int const minorVersion;
+        unsigned int const patchNumber;
+
+        // buildNumber is only used if branchName is not null
+        char const * const branchName;
+        unsigned int const buildNumber;
+
+        friend std::ostream& operator << ( std::ostream& os, Version const& version );
+    };
+
+    Version const& libraryVersion();
+}
+
+#endif // CATCH_VERSION_HPP_INCLUDED
+
+
+#ifndef CATCH_VERSION_MACROS_HPP_INCLUDED
+#define CATCH_VERSION_MACROS_HPP_INCLUDED
+
+#define CATCH_VERSION_MAJOR 3
+#define CATCH_VERSION_MINOR 7
+#define CATCH_VERSION_PATCH 1
+
+#endif // CATCH_VERSION_MACROS_HPP_INCLUDED
+
+
+/** \file
+ * This is a convenience header for Catch2's Generator support. It includes
+ * **all** of Catch2 headers related to generators.
+ *
+ * Generally the Catch2 users should use specific includes they need,
+ * but this header can be used instead for ease-of-experimentation, or
+ * just plain convenience, at the cost of (significantly) increased
+ * compilation times.
+ *
+ * When a new header is added to either the `generators` folder,
+ * or to the corresponding internal subfolder, it should be added here.
+ */
+
+#ifndef CATCH_GENERATORS_ALL_HPP_INCLUDED
+#define CATCH_GENERATORS_ALL_HPP_INCLUDED
+
+
+
+#ifndef CATCH_GENERATOR_EXCEPTION_HPP_INCLUDED
+#define CATCH_GENERATOR_EXCEPTION_HPP_INCLUDED
+
+#include <exception>
+
+namespace Catch {
+
+    // Exception type to be thrown when a Generator runs into an error,
+    // e.g. it cannot initialize the first return value based on
+    // runtime information
+    class GeneratorException : public std::exception {
+        const char* const m_msg = "";
+
+    public:
+        GeneratorException(const char* msg):
+            m_msg(msg)
+        {}
+
+        const char* what() const noexcept override final;
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_GENERATOR_EXCEPTION_HPP_INCLUDED
+
+
+#ifndef CATCH_GENERATORS_HPP_INCLUDED
+#define CATCH_GENERATORS_HPP_INCLUDED
+
+
+
+#ifndef CATCH_INTERFACES_GENERATORTRACKER_HPP_INCLUDED
+#define CATCH_INTERFACES_GENERATORTRACKER_HPP_INCLUDED
+
+
+#include <string>
+
+namespace Catch {
+
+    namespace Generators {
+        class GeneratorUntypedBase {
+            // Caches result from `toStringImpl`, assume that when it is an
+            // empty string, the cache is invalidated.
+            mutable std::string m_stringReprCache;
+
+            // Counts based on `next` returning true
+            std::size_t m_currentElementIndex = 0;
+
+            /**
+             * Attempts to move the generator to the next element
+             *
+             * Returns true iff the move succeeded (and a valid element
+             * can be retrieved).
+             */
+            virtual bool next() = 0;
+
+            //! Customization point for `currentElementAsString`
+            virtual std::string stringifyImpl() const = 0;
+
+        public:
+            GeneratorUntypedBase() = default;
+            // Generation of copy ops is deprecated (and Clang will complain)
+            // if there is a user destructor defined
+            GeneratorUntypedBase(GeneratorUntypedBase const&) = default;
+            GeneratorUntypedBase& operator=(GeneratorUntypedBase const&) = default;
+
+            virtual ~GeneratorUntypedBase(); // = default;
+
+            /**
+             * Attempts to move the generator to the next element
+             *
+             * Serves as a non-virtual interface to `next`, so that the
+             * top level interface can provide sanity checking and shared
+             * features.
+             *
+             * As with `next`, returns true iff the move succeeded and
+             * the generator has new valid element to provide.
+             */
+            bool countedNext();
+
+            std::size_t currentElementIndex() const { return m_currentElementIndex; }
+
+            /**
+             * Returns generator's current element as user-friendly string.
+             *
+             * By default returns string equivalent to calling
+             * `Catch::Detail::stringify` on the current element, but generators
+             * can customize their implementation as needed.
+             *
+             * Not thread-safe due to internal caching.
+             *
+             * The returned ref is valid only until the generator instance
+             * is destructed, or it moves onto the next element, whichever
+             * comes first.
+             */
+            StringRef currentElementAsString() const;
+        };
+        using GeneratorBasePtr = Catch::Detail::unique_ptr<GeneratorUntypedBase>;
+
+    } // namespace Generators
+
+    class IGeneratorTracker {
+    public:
+        virtual ~IGeneratorTracker(); // = default;
+        virtual auto hasGenerator() const -> bool = 0;
+        virtual auto getGenerator() const -> Generators::GeneratorBasePtr const& = 0;
+        virtual void setGenerator( Generators::GeneratorBasePtr&& generator ) = 0;
+    };
+
+} // namespace Catch
+
+#endif // CATCH_INTERFACES_GENERATORTRACKER_HPP_INCLUDED
+
+#include <vector>
+#include <tuple>
+
+namespace Catch {
+
+namespace Generators {
+
+namespace Detail {
+
+    //! Throws GeneratorException with the provided message
+    [[noreturn]]
+    void throw_generator_exception(char const * msg);
+
+} // end namespace detail
+
+    template<typename T>
+    class IGenerator : public GeneratorUntypedBase {
+        std::string stringifyImpl() const override {
+            return ::Catch::Detail::stringify( get() );
+        }
+
+    public:
+        // Returns the current element of the generator
+        //
+        // \Precondition The generator is either freshly constructed,
+        // or the last call to `next()` returned true
+        virtual T const& get() const = 0;
+        using type = T;
+    };
+
+    template <typename T>
+    using GeneratorPtr = Catch::Detail::unique_ptr<IGenerator<T>>;
+
+    template <typename T>
+    class GeneratorWrapper final {
+        GeneratorPtr<T> m_generator;
+    public:
+        //! Takes ownership of the passed pointer.
+        GeneratorWrapper(IGenerator<T>* generator):
+            m_generator(generator) {}
+        GeneratorWrapper(GeneratorPtr<T> generator):
+            m_generator(CATCH_MOVE(generator)) {}
+
+        T const& get() const {
+            return m_generator->get();
+        }
+        bool next() {
+            return m_generator->countedNext();
+        }
+    };
+
+
+    template<typename T>
+    class SingleValueGenerator final : public IGenerator<T> {
+        T m_value;
+    public:
+        SingleValueGenerator(T const& value) :
+            m_value(value)
+        {}
+        SingleValueGenerator(T&& value):
+            m_value(CATCH_MOVE(value))
+        {}
+
+        T const& get() const override {
+            return m_value;
+        }
+        bool next() override {
+            return false;
+        }
+    };
+
+    template<typename T>
+    class FixedValuesGenerator final : public IGenerator<T> {
+        static_assert(!std::is_same<T, bool>::value,
+            "FixedValuesGenerator does not support bools because of std::vector<bool>"
+            "specialization, use SingleValue Generator instead.");
+        std::vector<T> m_values;
+        size_t m_idx = 0;
+    public:
+        FixedValuesGenerator( std::initializer_list<T> values ) : m_values( values ) {}
+
+        T const& get() const override {
+            return m_values[m_idx];
+        }
+        bool next() override {
+            ++m_idx;
+            return m_idx < m_values.size();
+        }
+    };
+
+    template <typename T, typename DecayedT = std::decay_t<T>>
+    GeneratorWrapper<DecayedT> value( T&& value ) {
+        return GeneratorWrapper<DecayedT>(
+            Catch::Detail::make_unique<SingleValueGenerator<DecayedT>>(
+                CATCH_FORWARD( value ) ) );
+    }
+    template <typename T>
+    GeneratorWrapper<T> values(std::initializer_list<T> values) {
+        return GeneratorWrapper<T>(Catch::Detail::make_unique<FixedValuesGenerator<T>>(values));
+    }
+
+    template<typename T>
+    class Generators : public IGenerator<T> {
+        std::vector<GeneratorWrapper<T>> m_generators;
+        size_t m_current = 0;
+
+        void add_generator( GeneratorWrapper<T>&& generator ) {
+            m_generators.emplace_back( CATCH_MOVE( generator ) );
+        }
+        void add_generator( T const& val ) {
+            m_generators.emplace_back( value( val ) );
+        }
+        void add_generator( T&& val ) {
+            m_generators.emplace_back( value( CATCH_MOVE( val ) ) );
+        }
+        template <typename U>
+        std::enable_if_t<!std::is_same<std::decay_t<U>, T>::value>
+        add_generator( U&& val ) {
+            add_generator( T( CATCH_FORWARD( val ) ) );
+        }
+
+        template <typename U> void add_generators( U&& valueOrGenerator ) {
+            add_generator( CATCH_FORWARD( valueOrGenerator ) );
+        }
+
+        template <typename U, typename... Gs>
+        void add_generators( U&& valueOrGenerator, Gs&&... moreGenerators ) {
+            add_generator( CATCH_FORWARD( valueOrGenerator ) );
+            add_generators( CATCH_FORWARD( moreGenerators )... );
+        }
+
+    public:
+        template <typename... Gs>
+        Generators(Gs &&... moreGenerators) {
+            m_generators.reserve(sizeof...(Gs));
+            add_generators(CATCH_FORWARD(moreGenerators)...);
+        }
+
+        T const& get() const override {
+            return m_generators[m_current].get();
+        }
+
+        bool next() override {
+            if (m_current >= m_generators.size()) {
+                return false;
+            }
+            const bool current_status = m_generators[m_current].next();
+            if (!current_status) {
+                ++m_current;
+            }
+            return m_current < m_generators.size();
+        }
+    };
+
+
+    template <typename... Ts>
+    GeneratorWrapper<std::tuple<std::decay_t<Ts>...>>
+    table( std::initializer_list<std::tuple<std::decay_t<Ts>...>> tuples ) {
+        return values<std::tuple<Ts...>>( tuples );
+    }
+
+    // Tag type to signal that a generator sequence should convert arguments to a specific type
+    template <typename T>
+    struct as {};
+
+    template<typename T, typename... Gs>
+    auto makeGenerators( GeneratorWrapper<T>&& generator, Gs &&... moreGenerators ) -> Generators<T> {
+        return Generators<T>(CATCH_MOVE(generator), CATCH_FORWARD(moreGenerators)...);
+    }
+    template<typename T>
+    auto makeGenerators( GeneratorWrapper<T>&& generator ) -> Generators<T> {
+        return Generators<T>(CATCH_MOVE(generator));
+    }
+    template<typename T, typename... Gs>
+    auto makeGenerators( T&& val, Gs &&... moreGenerators ) -> Generators<std::decay_t<T>> {
+        return makeGenerators( value( CATCH_FORWARD( val ) ), CATCH_FORWARD( moreGenerators )... );
+    }
+    template<typename T, typename U, typename... Gs>
+    auto makeGenerators( as<T>, U&& val, Gs &&... moreGenerators ) -> Generators<T> {
+        return makeGenerators( value( T( CATCH_FORWARD( val ) ) ), CATCH_FORWARD( moreGenerators )... );
+    }
+
+    IGeneratorTracker* acquireGeneratorTracker( StringRef generatorName,
+                                                SourceLineInfo const& lineInfo );
+    IGeneratorTracker* createGeneratorTracker( StringRef generatorName,
+                                               SourceLineInfo lineInfo,
+                                               GeneratorBasePtr&& generator );
+
+    template<typename L>
+    auto generate( StringRef generatorName, SourceLineInfo const& lineInfo, L const& generatorExpression ) -> typename decltype(generatorExpression())::type {
+        using UnderlyingType = typename decltype(generatorExpression())::type;
+
+        IGeneratorTracker* tracker = acquireGeneratorTracker( generatorName, lineInfo );
+        // Creation of tracker is delayed after generator creation, so
+        // that constructing generator can fail without breaking everything.
+        if (!tracker) {
+            tracker = createGeneratorTracker(
+                generatorName,
+                lineInfo,
+                Catch::Detail::make_unique<Generators<UnderlyingType>>(
+                    generatorExpression() ) );
+        }
+
+        auto const& generator = static_cast<IGenerator<UnderlyingType> const&>( *tracker->getGenerator() );
+        return generator.get();
+    }
+
+} // namespace Generators
+} // namespace Catch
+
+#define CATCH_INTERNAL_GENERATOR_STRINGIZE_IMPL( ... ) #__VA_ARGS__##_catch_sr
+#define CATCH_INTERNAL_GENERATOR_STRINGIZE(...) CATCH_INTERNAL_GENERATOR_STRINGIZE_IMPL(__VA_ARGS__)
+
+#define GENERATE( ... ) \
+    Catch::Generators::generate( CATCH_INTERNAL_GENERATOR_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
+                                 CATCH_INTERNAL_LINEINFO, \
+                                 [ ]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
+#define GENERATE_COPY( ... ) \
+    Catch::Generators::generate( CATCH_INTERNAL_GENERATOR_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
+                                 CATCH_INTERNAL_LINEINFO, \
+                                 [=]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
+#define GENERATE_REF( ... ) \
+    Catch::Generators::generate( CATCH_INTERNAL_GENERATOR_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
+                                 CATCH_INTERNAL_LINEINFO, \
+                                 [&]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
+
+#endif // CATCH_GENERATORS_HPP_INCLUDED
+
+
+#ifndef CATCH_GENERATORS_ADAPTERS_HPP_INCLUDED
+#define CATCH_GENERATORS_ADAPTERS_HPP_INCLUDED
+
+
+#include <cassert>
+
+namespace Catch {
+namespace Generators {
+
+    template <typename T>
+    class TakeGenerator final : public IGenerator<T> {
+        GeneratorWrapper<T> m_generator;
+        size_t m_returned = 0;
+        size_t m_target;
+    public:
+        TakeGenerator(size_t target, GeneratorWrapper<T>&& generator):
+            m_generator(CATCH_MOVE(generator)),
+            m_target(target)
+        {
+            assert(target != 0 && "Empty generators are not allowed");
+        }
+        T const& get() const override {
+            return m_generator.get();
+        }
+        bool next() override {
+            ++m_returned;
+            if (m_returned >= m_target) {
+                return false;
+            }
+
+            const auto success = m_generator.next();
+            // If the underlying generator does not contain enough values
+            // then we cut short as well
+            if (!success) {
+                m_returned = m_target;
+            }
+            return success;
+        }
+    };
+
+    template <typename T>
+    GeneratorWrapper<T> take(size_t target, GeneratorWrapper<T>&& generator) {
+        return GeneratorWrapper<T>(Catch::Detail::make_unique<TakeGenerator<T>>(target, CATCH_MOVE(generator)));
+    }
+
+
+    template <typename T, typename Predicate>
+    class FilterGenerator final : public IGenerator<T> {
+        GeneratorWrapper<T> m_generator;
+        Predicate m_predicate;
+    public:
+        template <typename P = Predicate>
+        FilterGenerator(P&& pred, GeneratorWrapper<T>&& generator):
+            m_generator(CATCH_MOVE(generator)),
+            m_predicate(CATCH_FORWARD(pred))
+        {
+            if (!m_predicate(m_generator.get())) {
+                // It might happen that there are no values that pass the
+                // filter. In that case we throw an exception.
+                auto has_initial_value = next();
+                if (!has_initial_value) {
+                    Detail::throw_generator_exception("No valid value found in filtered generator");
+                }
+            }
+        }
+
+        T const& get() const override {
+            return m_generator.get();
+        }
+
+        bool next() override {
+            bool success = m_generator.next();
+            if (!success) {
+                return false;
+            }
+            while (!m_predicate(m_generator.get()) && (success = m_generator.next()) == true);
+            return success;
+        }
+    };
+
+
+    template <typename T, typename Predicate>
+    GeneratorWrapper<T> filter(Predicate&& pred, GeneratorWrapper<T>&& generator) {
+        return GeneratorWrapper<T>(Catch::Detail::make_unique<FilterGenerator<T, Predicate>>(CATCH_FORWARD(pred), CATCH_MOVE(generator)));
+    }
+
+    template <typename T>
+    class RepeatGenerator final : public IGenerator<T> {
+        static_assert(!std::is_same<T, bool>::value,
+            "RepeatGenerator currently does not support bools"
+            "because of std::vector<bool> specialization");
+        GeneratorWrapper<T> m_generator;
+        mutable std::vector<T> m_returned;
+        size_t m_target_repeats;
+        size_t m_current_repeat = 0;
+        size_t m_repeat_index = 0;
+    public:
+        RepeatGenerator(size_t repeats, GeneratorWrapper<T>&& generator):
+            m_generator(CATCH_MOVE(generator)),
+            m_target_repeats(repeats)
+        {
+            assert(m_target_repeats > 0 && "Repeat generator must repeat at least once");
+        }
+
+        T const& get() const override {
+            if (m_current_repeat == 0) {
+                m_returned.push_back(m_generator.get());
+                return m_returned.back();
+            }
+            return m_returned[m_repeat_index];
+        }
+
+        bool next() override {
+            // There are 2 basic cases:
+            // 1) We are still reading the generator
+            // 2) We are reading our own cache
+
+            // In the first case, we need to poke the underlying generator.
+            // If it happily moves, we are left in that state, otherwise it is time to start reading from our cache
+            if (m_current_repeat == 0) {
+                const auto success = m_generator.next();
+                if (!success) {
+                    ++m_current_repeat;
+                }
+                return m_current_repeat < m_target_repeats;
+            }
+
+            // In the second case, we need to move indices forward and check that we haven't run up against the end
+            ++m_repeat_index;
+            if (m_repeat_index == m_returned.size()) {
+                m_repeat_index = 0;
+                ++m_current_repeat;
+            }
+            return m_current_repeat < m_target_repeats;
+        }
+    };
+
+    template <typename T>
+    GeneratorWrapper<T> repeat(size_t repeats, GeneratorWrapper<T>&& generator) {
+        return GeneratorWrapper<T>(Catch::Detail::make_unique<RepeatGenerator<T>>(repeats, CATCH_MOVE(generator)));
+    }
+
+    template <typename T, typename U, typename Func>
+    class MapGenerator final : public IGenerator<T> {
+        // TBD: provide static assert for mapping function, for friendly error message
+        GeneratorWrapper<U> m_generator;
+        Func m_function;
+        // To avoid returning dangling reference, we have to save the values
+        T m_cache;
+    public:
+        template <typename F2 = Func>
+        MapGenerator(F2&& function, GeneratorWrapper<U>&& generator) :
+            m_generator(CATCH_MOVE(generator)),
+            m_function(CATCH_FORWARD(function)),
+            m_cache(m_function(m_generator.get()))
+        {}
+
+        T const& get() const override {
+            return m_cache;
+        }
+        bool next() override {
+            const auto success = m_generator.next();
+            if (success) {
+                m_cache = m_function(m_generator.get());
+            }
+            return success;
+        }
+    };
+
+    template <typename Func, typename U, typename T = FunctionReturnType<Func, U>>
+    GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& generator) {
+        return GeneratorWrapper<T>(
+            Catch::Detail::make_unique<MapGenerator<T, U, Func>>(CATCH_FORWARD(function), CATCH_MOVE(generator))
+        );
+    }
+
+    template <typename T, typename U, typename Func>
+    GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& generator) {
+        return GeneratorWrapper<T>(
+            Catch::Detail::make_unique<MapGenerator<T, U, Func>>(CATCH_FORWARD(function), CATCH_MOVE(generator))
+        );
+    }
+
+    template <typename T>
+    class ChunkGenerator final : public IGenerator<std::vector<T>> {
+        std::vector<T> m_chunk;
+        size_t m_chunk_size;
+        GeneratorWrapper<T> m_generator;
+        bool m_used_up = false;
+    public:
+        ChunkGenerator(size_t size, GeneratorWrapper<T> generator) :
+            m_chunk_size(size), m_generator(CATCH_MOVE(generator))
+        {
+            m_chunk.reserve(m_chunk_size);
+            if (m_chunk_size != 0) {
+                m_chunk.push_back(m_generator.get());
+                for (size_t i = 1; i < m_chunk_size; ++i) {
+                    if (!m_generator.next()) {
+                        Detail::throw_generator_exception("Not enough values to initialize the first chunk");
+                    }
+                    m_chunk.push_back(m_generator.get());
+                }
+            }
+        }
+        std::vector<T> const& get() const override {
+            return m_chunk;
+        }
+        bool next() override {
+            m_chunk.clear();
+            for (size_t idx = 0; idx < m_chunk_size; ++idx) {
+                if (!m_generator.next()) {
+                    return false;
+                }
+                m_chunk.push_back(m_generator.get());
+            }
+            return true;
+        }
+    };
+
+    template <typename T>
+    GeneratorWrapper<std::vector<T>> chunk(size_t size, GeneratorWrapper<T>&& generator) {
+        return GeneratorWrapper<std::vector<T>>(
+            Catch::Detail::make_unique<ChunkGenerator<T>>(size, CATCH_MOVE(generator))
+        );
+    }
+
+} // namespace Generators
+} // namespace Catch
+
+
+#endif // CATCH_GENERATORS_ADAPTERS_HPP_INCLUDED
+
+
+#ifndef CATCH_GENERATORS_RANDOM_HPP_INCLUDED
+#define CATCH_GENERATORS_RANDOM_HPP_INCLUDED
+
+
+
+#ifndef CATCH_RANDOM_NUMBER_GENERATOR_HPP_INCLUDED
+#define CATCH_RANDOM_NUMBER_GENERATOR_HPP_INCLUDED
+
+#include <cstdint>
+
+namespace Catch {
+
+    // This is a simple implementation of C++11 Uniform Random Number
+    // Generator. It does not provide all operators, because Catch2
+    // does not use it, but it should behave as expected inside stdlib's
+    // distributions.
+    // The implementation is based on the PCG family (http://pcg-random.org)
+    class SimplePcg32 {
+        using state_type = std::uint64_t;
+    public:
+        using result_type = std::uint32_t;
+        static constexpr result_type (min)() {
+            return 0;
+        }
+        static constexpr result_type (max)() {
+            return static_cast<result_type>(-1);
+        }
+
+        // Provide some default initial state for the default constructor
+        SimplePcg32():SimplePcg32(0xed743cc4U) {}
+
+        explicit SimplePcg32(result_type seed_);
+
+        void seed(result_type seed_);
+        void discard(uint64_t skip);
+
+        result_type operator()();
+
+    private:
+        friend bool operator==(SimplePcg32 const& lhs, SimplePcg32 const& rhs);
+        friend bool operator!=(SimplePcg32 const& lhs, SimplePcg32 const& rhs);
+
+        // In theory we also need operator<< and operator>>
+        // In practice we do not use them, so we will skip them for now
+
+
+        std::uint64_t m_state;
+        // This part of the state determines which "stream" of the numbers
+        // is chosen -- we take it as a constant for Catch2, so we only
+        // need to deal with seeding the main state.
+        // Picked by reading 8 bytes from `/dev/random` :-)
+        static const std::uint64_t s_inc = (0x13ed0cc53f939476ULL << 1ULL) | 1ULL;
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_RANDOM_NUMBER_GENERATOR_HPP_INCLUDED
+
+
+
+#ifndef CATCH_UNIFORM_INTEGER_DISTRIBUTION_HPP_INCLUDED
+#define CATCH_UNIFORM_INTEGER_DISTRIBUTION_HPP_INCLUDED
+
+
+
+
+#ifndef CATCH_RANDOM_INTEGER_HELPERS_HPP_INCLUDED
+#define CATCH_RANDOM_INTEGER_HELPERS_HPP_INCLUDED
+
+#include <climits>
+#include <cstddef>
+#include <cstdint>
+#include <type_traits>
+
+// Note: We use the usual enable-disable-autodetect dance here even though
+//       we do not support these in CMake configuration options (yet?).
+//       It is highly unlikely that we will need to make these actually
+//       user-configurable, but this will make it simpler if weend up needing
+//       it, and it provides an escape hatch to the users who need it.
+#if defined( __SIZEOF_INT128__ )
+#    define CATCH_CONFIG_INTERNAL_UINT128
+// Unlike GCC, MSVC does not polyfill umul as mulh + mul pair on ARM machines.
+// Currently we do not bother doing this ourselves, but we could if it became
+// important for perf.
+#elif defined( _MSC_VER ) && defined( _M_X64 )
+#    define CATCH_CONFIG_INTERNAL_MSVC_UMUL128
+#endif
+
+#if defined( CATCH_CONFIG_INTERNAL_UINT128 ) && \
+    !defined( CATCH_CONFIG_NO_UINT128 ) &&      \
+    !defined( CATCH_CONFIG_UINT128 )
+#define CATCH_CONFIG_UINT128
+#endif
+
+#if defined( CATCH_CONFIG_INTERNAL_MSVC_UMUL128 ) && \
+    !defined( CATCH_CONFIG_NO_MSVC_UMUL128 ) &&      \
+    !defined( CATCH_CONFIG_MSVC_UMUL128 )
+#    define CATCH_CONFIG_MSVC_UMUL128
+#    include <intrin.h>
+#endif
+
+
+namespace Catch {
+    namespace Detail {
+
+        template <std::size_t>
+        struct SizedUnsignedType;
+#define SizedUnsignedTypeHelper( TYPE )        \
+    template <>                                \
+    struct SizedUnsignedType<sizeof( TYPE )> { \
+        using type = TYPE;                     \
+    }
+
+        SizedUnsignedTypeHelper( std::uint8_t );
+        SizedUnsignedTypeHelper( std::uint16_t );
+        SizedUnsignedTypeHelper( std::uint32_t );
+        SizedUnsignedTypeHelper( std::uint64_t );
+#undef SizedUnsignedTypeHelper
+
+        template <std::size_t sz>
+        using SizedUnsignedType_t = typename SizedUnsignedType<sz>::type;
+
+        template <typename T>
+        using DoubleWidthUnsignedType_t = SizedUnsignedType_t<2 * sizeof( T )>;
+
+        template <typename T>
+        struct ExtendedMultResult {
+            T upper;
+            T lower;
+            constexpr bool operator==( ExtendedMultResult const& rhs ) const {
+                return upper == rhs.upper && lower == rhs.lower;
+            }
+        };
+
+        /**
+         * Returns 128 bit result of lhs * rhs using portable C++ code
+         *
+         * This implementation is almost twice as fast as naive long multiplication,
+         * and unlike intrinsic-based approach, it supports constexpr evaluation.
+         */
+        constexpr ExtendedMultResult<std::uint64_t>
+        extendedMultPortable(std::uint64_t lhs, std::uint64_t rhs) {
+#define CarryBits( x ) ( x >> 32 )
+#define Digits( x ) ( x & 0xFF'FF'FF'FF )
+            std::uint64_t lhs_low = Digits( lhs );
+            std::uint64_t rhs_low = Digits( rhs );
+            std::uint64_t low_low = ( lhs_low * rhs_low );
+            std::uint64_t high_high = CarryBits( lhs ) * CarryBits( rhs );
+
+            // We add in carry bits from low-low already
+            std::uint64_t high_low =
+                ( CarryBits( lhs ) * rhs_low ) + CarryBits( low_low );
+            // Note that we can add only low bits from high_low, to avoid
+            // overflow with large inputs
+            std::uint64_t low_high =
+                ( lhs_low * CarryBits( rhs ) ) + Digits( high_low );
+
+            return { high_high + CarryBits( high_low ) + CarryBits( low_high ),
+                     ( low_high << 32 ) | Digits( low_low ) };
+#undef CarryBits
+#undef Digits
+        }
+
+        //! Returns 128 bit result of lhs * rhs
+        inline ExtendedMultResult<std::uint64_t>
+        extendedMult( std::uint64_t lhs, std::uint64_t rhs ) {
+#if defined( CATCH_CONFIG_UINT128 )
+            auto result = __uint128_t( lhs ) * __uint128_t( rhs );
+            return { static_cast<std::uint64_t>( result >> 64 ),
+                     static_cast<std::uint64_t>( result ) };
+#elif defined( CATCH_CONFIG_MSVC_UMUL128 )
+            std::uint64_t high;
+            std::uint64_t low = _umul128( lhs, rhs, &high );
+            return { high, low };
+#else
+            return extendedMultPortable( lhs, rhs );
+#endif
+        }
+
+
+        template <typename UInt>
+        constexpr ExtendedMultResult<UInt> extendedMult( UInt lhs, UInt rhs ) {
+            static_assert( std::is_unsigned<UInt>::value,
+                           "extendedMult can only handle unsigned integers" );
+            static_assert( sizeof( UInt ) < sizeof( std::uint64_t ),
+                           "Generic extendedMult can only handle types smaller "
+                           "than uint64_t" );
+            using WideType = DoubleWidthUnsignedType_t<UInt>;
+
+            auto result = WideType( lhs ) * WideType( rhs );
+            return {
+                static_cast<UInt>( result >> ( CHAR_BIT * sizeof( UInt ) ) ),
+                static_cast<UInt>( result & UInt( -1 ) ) };
+        }
+
+
+        template <typename TargetType,
+                  typename Generator>
+            std::enable_if_t<sizeof(typename Generator::result_type) >= sizeof(TargetType),
+            TargetType> fillBitsFrom(Generator& gen) {
+            using gresult_type = typename Generator::result_type;
+            static_assert( std::is_unsigned<TargetType>::value, "Only unsigned integers are supported" );
+            static_assert( Generator::min() == 0 &&
+                           Generator::max() == static_cast<gresult_type>( -1 ),
+                           "Generator must be able to output all numbers in its result type (effectively it must be a random bit generator)" );
+
+            // We want to return the top bits from a generator, as they are
+            // usually considered higher quality.
+            constexpr auto generated_bits = sizeof( gresult_type ) * CHAR_BIT;
+            constexpr auto return_bits = sizeof( TargetType ) * CHAR_BIT;
+
+            return static_cast<TargetType>( gen() >>
+                                            ( generated_bits - return_bits) );
+        }
+
+        template <typename TargetType,
+                  typename Generator>
+            std::enable_if_t<sizeof(typename Generator::result_type) < sizeof(TargetType),
+            TargetType> fillBitsFrom(Generator& gen) {
+            using gresult_type = typename Generator::result_type;
+            static_assert( std::is_unsigned<TargetType>::value,
+                           "Only unsigned integers are supported" );
+            static_assert( Generator::min() == 0 &&
+                           Generator::max() == static_cast<gresult_type>( -1 ),
+                           "Generator must be able to output all numbers in its result type (effectively it must be a random bit generator)" );
+
+            constexpr auto generated_bits = sizeof( gresult_type ) * CHAR_BIT;
+            constexpr auto return_bits = sizeof( TargetType ) * CHAR_BIT;
+            std::size_t filled_bits = 0;
+            TargetType ret = 0;
+            do {
+                ret <<= generated_bits;
+                ret |= gen();
+                filled_bits += generated_bits;
+            } while ( filled_bits < return_bits );
+
+            return ret;
+        }
+
+        /*
+         * Transposes numbers into unsigned type while keeping their ordering
+         *
+         * This means that signed types are changed so that the ordering is
+         * [INT_MIN, ..., -1, 0, ..., INT_MAX], rather than order we would
+         * get by simple casting ([0, ..., INT_MAX, INT_MIN, ..., -1])
+         */
+        template <typename OriginalType, typename UnsignedType>
+        constexpr
+        std::enable_if_t<std::is_signed<OriginalType>::value, UnsignedType>
+        transposeToNaturalOrder( UnsignedType in ) {
+            static_assert(
+                sizeof( OriginalType ) == sizeof( UnsignedType ),
+                "reordering requires the same sized types on both sides" );
+            static_assert( std::is_unsigned<UnsignedType>::value,
+                           "Input type must be unsigned" );
+            // Assuming 2s complement (standardized in current C++), the
+            // positive and negative numbers are already internally ordered,
+            // and their difference is in the top bit. Swapping it orders
+            // them the desired way.
+            constexpr auto highest_bit =
+                UnsignedType( 1 ) << ( sizeof( UnsignedType ) * CHAR_BIT - 1 );
+            return static_cast<UnsignedType>( in ^ highest_bit );
+        }
+
+
+
+        template <typename OriginalType,
+                  typename UnsignedType>
+        constexpr
+        std::enable_if_t<std::is_unsigned<OriginalType>::value, UnsignedType>
+            transposeToNaturalOrder(UnsignedType in) {
+            static_assert(
+                sizeof( OriginalType ) == sizeof( UnsignedType ),
+                "reordering requires the same sized types on both sides" );
+            static_assert( std::is_unsigned<UnsignedType>::value, "Input type must be unsigned" );
+            // No reordering is needed for unsigned -> unsigned
+            return in;
+        }
+    } // namespace Detail
+} // namespace Catch
+
+#endif // CATCH_RANDOM_INTEGER_HELPERS_HPP_INCLUDED
+
+namespace Catch {
+
+/**
+ * Implementation of uniform distribution on integers.
+ *
+ * Unlike `std::uniform_int_distribution`, this implementation supports
+ * various 1 byte integral types, including bool (but you should not
+ * actually use it for bools).
+ *
+ * The underlying algorithm is based on the one described in "Fast Random
+ * Integer Generation in an Interval" by Daniel Lemire, but has been
+ * optimized under the assumption of reuse of the same distribution object.
+ */
+template <typename IntegerType>
+class uniform_integer_distribution {
+    static_assert(std::is_integral<IntegerType>::value, "...");
+
+    using UnsignedIntegerType = Detail::SizedUnsignedType_t<sizeof(IntegerType)>;
+
+    // Only the left bound is stored, and we store it converted to its
+    // unsigned image. This avoids having to do the conversions inside
+    // the operator(), at the cost of having to do the conversion in
+    // the a() getter. The right bound is only needed in the b() getter,
+    // so we recompute it there from other stored data.
+    UnsignedIntegerType m_a;
+
+    // How many different values are there in [a, b]. a == b => 1, can be 0 for distribution over all values in the type.
+    UnsignedIntegerType m_ab_distance;
+
+    // We hoisted this out of the main generation function. Technically,
+    // this means that using this distribution will be slower than Lemire's
+    // algorithm if this distribution instance will be used only few times,
+    // but it will be faster if it is used many times. Since Catch2 uses
+    // distributions only to implement random generators, we assume that each
+    // distribution will be reused many times and this is an optimization.
+    UnsignedIntegerType m_rejection_threshold = 0;
+
+    static constexpr UnsignedIntegerType computeDistance(IntegerType a, IntegerType b) {
+        // This overflows and returns 0 if a == 0 and b == TYPE_MAX.
+        // We handle that later when generating the number.
+        return transposeTo(b) - transposeTo(a) + 1;
+    }
+
+    static constexpr UnsignedIntegerType computeRejectionThreshold(UnsignedIntegerType ab_distance) {
+        // distance == 0 means that we will return all possible values from
+        // the type's range, and that we shouldn't reject anything.
+        if ( ab_distance == 0 ) { return 0; }
+        return ( ~ab_distance + 1 ) % ab_distance;
+    }
+
+    static constexpr UnsignedIntegerType transposeTo(IntegerType in) {
+        return Detail::transposeToNaturalOrder<IntegerType>(
+            static_cast<UnsignedIntegerType>( in ) );
+    }
+    static constexpr IntegerType transposeBack(UnsignedIntegerType in) {
+        return static_cast<IntegerType>(
+            Detail::transposeToNaturalOrder<IntegerType>(in) );
+    }
+
+public:
+    using result_type = IntegerType;
+
+    constexpr uniform_integer_distribution( IntegerType a, IntegerType b ):
+        m_a( transposeTo(a) ),
+        m_ab_distance( computeDistance(a, b) ),
+        m_rejection_threshold( computeRejectionThreshold(m_ab_distance) ) {
+        assert( a <= b );
+    }
+
+    template <typename Generator>
+    constexpr result_type operator()( Generator& g ) {
+        // All possible values of result_type are valid.
+        if ( m_ab_distance == 0 ) {
+            return transposeBack( Detail::fillBitsFrom<UnsignedIntegerType>( g ) );
+        }
+
+        auto random_number = Detail::fillBitsFrom<UnsignedIntegerType>( g );
+        auto emul = Detail::extendedMult( random_number, m_ab_distance );
+        // Unlike Lemire's algorithm we skip the ab_distance check, since
+        // we precomputed the rejection threshold, which is always tighter.
+        while (emul.lower < m_rejection_threshold) {
+            random_number = Detail::fillBitsFrom<UnsignedIntegerType>( g );
+            emul = Detail::extendedMult( random_number, m_ab_distance );
+        }
+
+        return transposeBack(m_a + emul.upper);
+    }
+
+    constexpr result_type a() const { return transposeBack(m_a); }
+    constexpr result_type b() const { return transposeBack(m_ab_distance + m_a - 1); }
+};
+
+} // end namespace Catch
+
+#endif // CATCH_UNIFORM_INTEGER_DISTRIBUTION_HPP_INCLUDED
+
+
+
+#ifndef CATCH_UNIFORM_FLOATING_POINT_DISTRIBUTION_HPP_INCLUDED
+#define CATCH_UNIFORM_FLOATING_POINT_DISTRIBUTION_HPP_INCLUDED
+
+
+
+
+#ifndef CATCH_RANDOM_FLOATING_POINT_HELPERS_HPP_INCLUDED
+#define CATCH_RANDOM_FLOATING_POINT_HELPERS_HPP_INCLUDED
+
+
+
+#ifndef CATCH_POLYFILLS_HPP_INCLUDED
+#define CATCH_POLYFILLS_HPP_INCLUDED
+
+namespace Catch {
+
+    bool isnan(float f);
+    bool isnan(double d);
+
+    float nextafter(float x, float y);
+    double nextafter(double x, double y);
+
+}
+
+#endif // CATCH_POLYFILLS_HPP_INCLUDED
+
+#include <cassert>
+#include <cmath>
+#include <cstdint>
+#include <limits>
+#include <type_traits>
+
+namespace Catch {
+
+    namespace Detail {
+        /**
+         * Returns the largest magnitude of 1-ULP distance inside the [a, b] range.
+         *
+         * Assumes `a < b`.
+         */
+        template <typename FloatType>
+        FloatType gamma(FloatType a, FloatType b) {
+            static_assert( std::is_floating_point<FloatType>::value,
+                           "gamma returns the largest ULP magnitude within "
+                           "floating point range [a, b]. This only makes sense "
+                           "for floating point types" );
+            assert( a <= b );
+
+            const auto gamma_up = Catch::nextafter( a, std::numeric_limits<FloatType>::infinity() ) - a;
+            const auto gamma_down = b - Catch::nextafter( b, -std::numeric_limits<FloatType>::infinity() );
+
+            return gamma_up < gamma_down ? gamma_down : gamma_up;
+        }
+
+        template <typename FloatingPoint>
+        struct DistanceTypePicker;
+        template <>
+        struct DistanceTypePicker<float> {
+            using type = std::uint32_t;
+        };
+        template <>
+        struct DistanceTypePicker<double> {
+            using type = std::uint64_t;
+        };
+
+        template <typename T>
+        using DistanceType = typename DistanceTypePicker<T>::type;
+
+#if defined( __GNUC__ ) || defined( __clang__ )
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+        /**
+         * Computes the number of equi-distant floats in [a, b]
+         *
+         * Since not every range can be split into equidistant floats
+         * exactly, we actually compute ceil(b/distance - a/distance),
+         * because in those cases we want to overcount.
+         *
+         * Uses modified Dekker's FastTwoSum algorithm to handle rounding.
+         */
+        template <typename FloatType>
+        DistanceType<FloatType>
+        count_equidistant_floats( FloatType a, FloatType b, FloatType distance ) {
+            assert( a <= b );
+            // We get distance as gamma for our uniform float distribution,
+            // so this will round perfectly.
+            const auto ag = a / distance;
+            const auto bg = b / distance;
+
+            const auto s = bg - ag;
+            const auto err = ( std::fabs( a ) <= std::fabs( b ) )
+                                 ? -ag - ( s - bg )
+                                 : bg - ( s + ag );
+            const auto ceil_s = static_cast<DistanceType<FloatType>>( std::ceil( s ) );
+
+            return ( ceil_s != s ) ? ceil_s : ceil_s + ( err > 0 );
+        }
+#if defined( __GNUC__ ) || defined( __clang__ )
+#    pragma GCC diagnostic pop
+#endif
+
+    }
+
+} // end namespace Catch
+
+#endif // CATCH_RANDOM_FLOATING_POINT_HELPERS_HPP_INCLUDED
+
+#include <cmath>
+#include <type_traits>
+
+namespace Catch {
+
+    namespace Detail {
+#if defined( __GNUC__ ) || defined( __clang__ )
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+        // The issue with overflow only happens with maximal ULP and HUGE
+        // distance, e.g. when generating numbers in [-inf, inf] for given
+        // type. So we only check for the largest possible ULP in the
+        // type, and return something that does not overflow to inf in 1 mult.
+        constexpr std::uint64_t calculate_max_steps_in_one_go(double gamma) {
+            if ( gamma == 1.99584030953472e+292 ) { return 9007199254740991; }
+            return static_cast<std::uint64_t>( -1 );
+        }
+        constexpr std::uint32_t calculate_max_steps_in_one_go(float gamma) {
+            if ( gamma == 2.028241e+31f ) { return 16777215; }
+            return static_cast<std::uint32_t>( -1 );
+        }
+#if defined( __GNUC__ ) || defined( __clang__ )
+#    pragma GCC diagnostic pop
+#endif
+    }
+
+/**
+ * Implementation of uniform distribution on floating point numbers.
+ *
+ * Note that we support only `float` and `double` types, because these
+ * usually mean the same thing across different platform. `long double`
+ * varies wildly by platform and thus we cannot provide reproducible
+ * implementation. Also note that we don't implement all parts of
+ * distribution per standard: this distribution is not serializable, nor
+ * can the range be arbitrarily reset.
+ *
+ * The implementation also uses different approach than the one taken by
+ * `std::uniform_real_distribution`, where instead of generating a number
+ * between [0, 1) and then multiplying the range bounds with it, we first
+ * split the [a, b] range into a set of equidistributed floating point
+ * numbers, and then use uniform int distribution to pick which one to
+ * return.
+ *
+ * This has the advantage of guaranteeing uniformity (the multiplication
+ * method loses uniformity due to rounding when multiplying floats), except
+ * for small non-uniformity at one side of the interval, where we have
+ * to deal with the fact that not every interval is splittable into
+ * equidistributed floats.
+ *
+ * Based on "Drawing random floating-point numbers from an interval" by
+ * Frederic Goualard.
+ */
+template <typename FloatType>
+class uniform_floating_point_distribution {
+    static_assert(std::is_floating_point<FloatType>::value, "...");
+    static_assert(!std::is_same<FloatType, long double>::value,
+                  "We do not support long double due to inconsistent behaviour between platforms");
+
+    using WidthType = Detail::DistanceType<FloatType>;
+
+    FloatType m_a, m_b;
+    FloatType m_ulp_magnitude;
+    WidthType m_floats_in_range;
+    uniform_integer_distribution<WidthType> m_int_dist;
+
+    // In specific cases, we can overflow into `inf` when computing the
+    // `steps * g` offset. To avoid this, we don't offset by more than this
+    // in one multiply + addition.
+    WidthType m_max_steps_in_one_go;
+    // We don't want to do the magnitude check every call to `operator()`
+    bool m_a_has_leq_magnitude;
+
+public:
+    using result_type = FloatType;
+
+    uniform_floating_point_distribution( FloatType a, FloatType b ):
+        m_a( a ),
+        m_b( b ),
+        m_ulp_magnitude( Detail::gamma( m_a, m_b ) ),
+        m_floats_in_range( Detail::count_equidistant_floats( m_a, m_b, m_ulp_magnitude ) ),
+        m_int_dist(0, m_floats_in_range),
+        m_max_steps_in_one_go( Detail::calculate_max_steps_in_one_go(m_ulp_magnitude)),
+        m_a_has_leq_magnitude(std::fabs(m_a) <= std::fabs(m_b))
+    {
+        assert( a <= b );
+    }
+
+    template <typename Generator>
+    result_type operator()( Generator& g ) {
+        WidthType steps = m_int_dist( g );
+        if ( m_a_has_leq_magnitude ) {
+            if ( steps == m_floats_in_range ) { return m_a; }
+            auto b = m_b;
+            while (steps > m_max_steps_in_one_go) {
+                b -= m_max_steps_in_one_go * m_ulp_magnitude;
+                steps -= m_max_steps_in_one_go;
+            }
+            return b - steps * m_ulp_magnitude;
+        } else {
+            if ( steps == m_floats_in_range ) { return m_b; }
+            auto a = m_a;
+            while (steps > m_max_steps_in_one_go) {
+                a += m_max_steps_in_one_go * m_ulp_magnitude;
+                steps -= m_max_steps_in_one_go;
+            }
+            return a + steps * m_ulp_magnitude;
+        }
+    }
+
+    result_type a() const { return m_a; }
+    result_type b() const { return m_b; }
+};
+
+} // end namespace Catch
+
+#endif // CATCH_UNIFORM_FLOATING_POINT_DISTRIBUTION_HPP_INCLUDED
+
+namespace Catch {
+namespace Generators {
+namespace Detail {
+    // Returns a suitable seed for a random floating generator based off
+    // the primary internal rng. It does so by taking current value from
+    // the rng and returning it as the seed.
+    std::uint32_t getSeed();
+}
+
+template <typename Float>
+class RandomFloatingGenerator final : public IGenerator<Float> {
+    Catch::SimplePcg32 m_rng;
+    Catch::uniform_floating_point_distribution<Float> m_dist;
+    Float m_current_number;
+public:
+    RandomFloatingGenerator( Float a, Float b, std::uint32_t seed ):
+        m_rng(seed),
+        m_dist(a, b) {
+        static_cast<void>(next());
+    }
+
+    Float const& get() const override {
+        return m_current_number;
+    }
+    bool next() override {
+        m_current_number = m_dist(m_rng);
+        return true;
+    }
+};
+
+template <>
+class RandomFloatingGenerator<long double> final : public IGenerator<long double> {
+    // We still rely on <random> for this specialization, but we don't
+    // want to drag it into the header.
+    struct PImpl;
+    Catch::Detail::unique_ptr<PImpl> m_pimpl;
+    long double m_current_number;
+
+public:
+    RandomFloatingGenerator( long double a, long double b, std::uint32_t seed );
+
+    long double const& get() const override { return m_current_number; }
+    bool next() override;
+
+    ~RandomFloatingGenerator() override; // = default
+};
+
+template <typename Integer>
+class RandomIntegerGenerator final : public IGenerator<Integer> {
+    Catch::SimplePcg32 m_rng;
+    Catch::uniform_integer_distribution<Integer> m_dist;
+    Integer m_current_number;
+public:
+    RandomIntegerGenerator( Integer a, Integer b, std::uint32_t seed ):
+        m_rng(seed),
+        m_dist(a, b) {
+        static_cast<void>(next());
+    }
+
+    Integer const& get() const override {
+        return m_current_number;
+    }
+    bool next() override {
+        m_current_number = m_dist(m_rng);
+        return true;
+    }
+};
+
+template <typename T>
+std::enable_if_t<std::is_integral<T>::value, GeneratorWrapper<T>>
+random(T a, T b) {
+    return GeneratorWrapper<T>(
+        Catch::Detail::make_unique<RandomIntegerGenerator<T>>(a, b, Detail::getSeed())
+    );
+}
+
+template <typename T>
+std::enable_if_t<std::is_floating_point<T>::value,
+GeneratorWrapper<T>>
+random(T a, T b) {
+    return GeneratorWrapper<T>(
+        Catch::Detail::make_unique<RandomFloatingGenerator<T>>(a, b, Detail::getSeed())
+    );
+}
+
+
+} // namespace Generators
+} // namespace Catch
+
+
+#endif // CATCH_GENERATORS_RANDOM_HPP_INCLUDED
+
+
+#ifndef CATCH_GENERATORS_RANGE_HPP_INCLUDED
+#define CATCH_GENERATORS_RANGE_HPP_INCLUDED
+
+
+#include <iterator>
+#include <type_traits>
+
+namespace Catch {
+namespace Generators {
+
+
+template <typename T>
+class RangeGenerator final : public IGenerator<T> {
+    T m_current;
+    T m_end;
+    T m_step;
+    bool m_positive;
+
+public:
+    RangeGenerator(T const& start, T const& end, T const& step):
+        m_current(start),
+        m_end(end),
+        m_step(step),
+        m_positive(m_step > T(0))
+    {
+        assert(m_current != m_end && "Range start and end cannot be equal");
+        assert(m_step != T(0) && "Step size cannot be zero");
+        assert(((m_positive && m_current <= m_end) || (!m_positive && m_current >= m_end)) && "Step moves away from end");
+    }
+
+    RangeGenerator(T const& start, T const& end):
+        RangeGenerator(start, end, (start < end) ? T(1) : T(-1))
+    {}
+
+    T const& get() const override {
+        return m_current;
+    }
+
+    bool next() override {
+        m_current += m_step;
+        return (m_positive) ? (m_current < m_end) : (m_current > m_end);
+    }
+};
+
+template <typename T>
+GeneratorWrapper<T> range(T const& start, T const& end, T const& step) {
+    static_assert(std::is_arithmetic<T>::value && !std::is_same<T, bool>::value, "Type must be numeric");
+    return GeneratorWrapper<T>(Catch::Detail::make_unique<RangeGenerator<T>>(start, end, step));
+}
+
+template <typename T>
+GeneratorWrapper<T> range(T const& start, T const& end) {
+    static_assert(std::is_integral<T>::value && !std::is_same<T, bool>::value, "Type must be an integer");
+    return GeneratorWrapper<T>(Catch::Detail::make_unique<RangeGenerator<T>>(start, end));
+}
+
+
+template <typename T>
+class IteratorGenerator final : public IGenerator<T> {
+    static_assert(!std::is_same<T, bool>::value,
+        "IteratorGenerator currently does not support bools"
+        "because of std::vector<bool> specialization");
+
+    std::vector<T> m_elems;
+    size_t m_current = 0;
+public:
+    template <typename InputIterator, typename InputSentinel>
+    IteratorGenerator(InputIterator first, InputSentinel last):m_elems(first, last) {
+        if (m_elems.empty()) {
+            Detail::throw_generator_exception("IteratorGenerator received no valid values");
+        }
+    }
+
+    T const& get() const override {
+        return m_elems[m_current];
+    }
+
+    bool next() override {
+        ++m_current;
+        return m_current != m_elems.size();
+    }
+};
+
+template <typename InputIterator,
+          typename InputSentinel,
+          typename ResultType = typename std::iterator_traits<InputIterator>::value_type>
+GeneratorWrapper<ResultType> from_range(InputIterator from, InputSentinel to) {
+    return GeneratorWrapper<ResultType>(Catch::Detail::make_unique<IteratorGenerator<ResultType>>(from, to));
+}
+
+template <typename Container>
+auto from_range(Container const& cnt) {
+    using std::begin;
+    using std::end;
+    return from_range( begin( cnt ), end( cnt ) );
+}
+
+
+} // namespace Generators
+} // namespace Catch
+
+
+#endif // CATCH_GENERATORS_RANGE_HPP_INCLUDED
+
+#endif // CATCH_GENERATORS_ALL_HPP_INCLUDED
+
+
+/** \file
+ * This is a convenience header for Catch2's interfaces. It includes
+ * **all** of Catch2 headers related to interfaces.
+ *
+ * Generally the Catch2 users should use specific includes they need,
+ * but this header can be used instead for ease-of-experimentation, or
+ * just plain convenience, at the cost of somewhat increased compilation
+ * times.
+ *
+ * When a new header is added to either the `interfaces` folder, or to
+ * the corresponding internal subfolder, it should be added here.
+ */
+
+
+#ifndef CATCH_INTERFACES_ALL_HPP_INCLUDED
+#define CATCH_INTERFACES_ALL_HPP_INCLUDED
+
+
+
+#ifndef CATCH_INTERFACES_REPORTER_HPP_INCLUDED
+#define CATCH_INTERFACES_REPORTER_HPP_INCLUDED
+
+
+
+#ifndef CATCH_TEST_RUN_INFO_HPP_INCLUDED
+#define CATCH_TEST_RUN_INFO_HPP_INCLUDED
+
+
+namespace Catch {
+
+    struct TestRunInfo {
+        constexpr TestRunInfo(StringRef _name) : name(_name) {}
+        StringRef name;
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_TEST_RUN_INFO_HPP_INCLUDED
+
+#include <map>
+#include <string>
+#include <vector>
+#include <iosfwd>
+
+namespace Catch {
+
+    struct ReporterDescription;
+    struct ListenerDescription;
+    struct TagInfo;
+    struct TestCaseInfo;
+    class TestCaseHandle;
+    class IConfig;
+    class IStream;
+    enum class ColourMode : std::uint8_t;
+
+    struct ReporterConfig {
+        ReporterConfig( IConfig const* _fullConfig,
+                        Detail::unique_ptr<IStream> _stream,
+                        ColourMode colourMode,
+                        std::map<std::string, std::string> customOptions );
+
+        ReporterConfig( ReporterConfig&& ) = default;
+        ReporterConfig& operator=( ReporterConfig&& ) = default;
+        ~ReporterConfig(); // = default
+
+        Detail::unique_ptr<IStream> takeStream() &&;
+        IConfig const* fullConfig() const;
+        ColourMode colourMode() const;
+        std::map<std::string, std::string> const& customOptions() const;
+
+    private:
+        Detail::unique_ptr<IStream> m_stream;
+        IConfig const* m_fullConfig;
+        ColourMode m_colourMode;
+        std::map<std::string, std::string> m_customOptions;
+    };
+
+    struct AssertionStats {
+        AssertionStats( AssertionResult const& _assertionResult,
+                        std::vector<MessageInfo> const& _infoMessages,
+                        Totals const& _totals );
+
+        AssertionStats( AssertionStats const& )              = default;
+        AssertionStats( AssertionStats && )                  = default;
+        AssertionStats& operator = ( AssertionStats const& ) = delete;
+        AssertionStats& operator = ( AssertionStats && )     = delete;
+
+        AssertionResult assertionResult;
+        std::vector<MessageInfo> infoMessages;
+        Totals totals;
+    };
+
+    struct SectionStats {
+        SectionStats(   SectionInfo&& _sectionInfo,
+                        Counts const& _assertions,
+                        double _durationInSeconds,
+                        bool _missingAssertions );
+
+        SectionInfo sectionInfo;
+        Counts assertions;
+        double durationInSeconds;
+        bool missingAssertions;
+    };
+
+    struct TestCaseStats {
+        TestCaseStats(  TestCaseInfo const& _testInfo,
+                        Totals const& _totals,
+                        std::string&& _stdOut,
+                        std::string&& _stdErr,
+                        bool _aborting );
+
+        TestCaseInfo const * testInfo;
+        Totals totals;
+        std::string stdOut;
+        std::string stdErr;
+        bool aborting;
+    };
+
+    struct TestRunStats {
+        TestRunStats(   TestRunInfo const& _runInfo,
+                        Totals const& _totals,
+                        bool _aborting );
+
+        TestRunInfo runInfo;
+        Totals totals;
+        bool aborting;
+    };
+
+    //! By setting up its preferences, a reporter can modify Catch2's behaviour
+    //! in some regards, e.g. it can request Catch2 to capture writes to
+    //! stdout/stderr during test execution, and pass them to the reporter.
+    struct ReporterPreferences {
+        //! Catch2 should redirect writes to stdout and pass them to the
+        //! reporter
+        bool shouldRedirectStdOut = false;
+        //! Catch2 should call `Reporter::assertionEnded` even for passing
+        //! assertions
+        bool shouldReportAllAssertions = false;
+    };
+
+    /**
+     * The common base for all reporters and event listeners
+     *
+     * Implementing classes must also implement:
+     *
+     *     //! User-friendly description of the reporter/listener type
+     *     static std::string getDescription()
+     *
+     * Generally shouldn't be derived from by users of Catch2 directly,
+     * instead they should derive from one of the utility bases that
+     * derive from this class.
+     */
+    class IEventListener {
+    protected:
+        //! Derived classes can set up their preferences here
+        ReporterPreferences m_preferences;
+        //! The test run's config as filled in from CLI and defaults
+        IConfig const* m_config;
+
+    public:
+        IEventListener( IConfig const* config ): m_config( config ) {}
+
+        virtual ~IEventListener(); // = default;
+
+        // Implementing class must also provide the following static methods:
+        // static std::string getDescription();
+
+        ReporterPreferences const& getPreferences() const {
+            return m_preferences;
+        }
+
+        //! Called when no test cases match provided test spec
+        virtual void noMatchingTestCases( StringRef unmatchedSpec ) = 0;
+        //! Called for all invalid test specs from the cli
+        virtual void reportInvalidTestSpec( StringRef invalidArgument ) = 0;
+
+        /**
+         * Called once in a testing run before tests are started
+         *
+         * Not called if tests won't be run (e.g. only listing will happen)
+         */
+        virtual void testRunStarting( TestRunInfo const& testRunInfo ) = 0;
+
+        //! Called _once_ for each TEST_CASE, no matter how many times it is entered
+        virtual void testCaseStarting( TestCaseInfo const& testInfo ) = 0;
+        //! Called _every time_ a TEST_CASE is entered, including repeats (due to sections)
+        virtual void testCasePartialStarting( TestCaseInfo const& testInfo, uint64_t partNumber ) = 0;
+        //! Called when a `SECTION` is being entered. Not called for skipped sections
+        virtual void sectionStarting( SectionInfo const& sectionInfo ) = 0;
+
+        //! Called when user-code is being probed before the actual benchmark runs
+        virtual void benchmarkPreparing( StringRef benchmarkName ) = 0;
+        //! Called after probe but before the user-code is being benchmarked
+        virtual void benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) = 0;
+        //! Called with the benchmark results if benchmark successfully finishes
+        virtual void benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) = 0;
+        //! Called if running the benchmarks fails for any reason
+        virtual void benchmarkFailed( StringRef benchmarkName ) = 0;
+
+        //! Called before assertion success/failure is evaluated
+        virtual void assertionStarting( AssertionInfo const& assertionInfo ) = 0;
+
+        //! Called after assertion was fully evaluated
+        virtual void assertionEnded( AssertionStats const& assertionStats ) = 0;
+
+        //! Called after a `SECTION` has finished running
+        virtual void sectionEnded( SectionStats const& sectionStats ) = 0;
+        //! Called _every time_ a TEST_CASE is entered, including repeats (due to sections)
+        virtual void testCasePartialEnded(TestCaseStats const& testCaseStats, uint64_t partNumber ) = 0;
+        //! Called _once_ for each TEST_CASE, no matter how many times it is entered
+        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) = 0;
+        /**
+         * Called once after all tests in a testing run are finished
+         *
+         * Not called if tests weren't run (e.g. only listings happened)
+         */
+        virtual void testRunEnded( TestRunStats const& testRunStats ) = 0;
+
+        /**
+         * Called with test cases that are skipped due to the test run aborting.
+         * NOT called for test cases that are explicitly skipped using the `SKIP` macro.
+         *
+         * Deprecated - will be removed in the next major release.
+         */
+        virtual void skipTest( TestCaseInfo const& testInfo ) = 0;
+
+        //! Called if a fatal error (signal/structured exception) occurred
+        virtual void fatalErrorEncountered( StringRef error ) = 0;
+
+        //! Writes out information about provided reporters using reporter-specific format
+        virtual void listReporters(std::vector<ReporterDescription> const& descriptions) = 0;
+        //! Writes out the provided listeners descriptions using reporter-specific format
+        virtual void listListeners(std::vector<ListenerDescription> const& descriptions) = 0;
+        //! Writes out information about provided tests using reporter-specific format
+        virtual void listTests(std::vector<TestCaseHandle> const& tests) = 0;
+        //! Writes out information about the provided tags using reporter-specific format
+        virtual void listTags(std::vector<TagInfo> const& tags) = 0;
+    };
+    using IEventListenerPtr = Detail::unique_ptr<IEventListener>;
+
+} // end namespace Catch
+
+#endif // CATCH_INTERFACES_REPORTER_HPP_INCLUDED
+
+
+#ifndef CATCH_INTERFACES_REPORTER_FACTORY_HPP_INCLUDED
+#define CATCH_INTERFACES_REPORTER_FACTORY_HPP_INCLUDED
+
+
+#include <string>
+
+namespace Catch {
+
+    struct ReporterConfig;
+    class IConfig;
+    class IEventListener;
+    using IEventListenerPtr = Detail::unique_ptr<IEventListener>;
+
+
+    class IReporterFactory {
+    public:
+        virtual ~IReporterFactory(); // = default
+
+        virtual IEventListenerPtr
+        create( ReporterConfig&& config ) const = 0;
+        virtual std::string getDescription() const = 0;
+    };
+    using IReporterFactoryPtr = Detail::unique_ptr<IReporterFactory>;
+
+    class EventListenerFactory {
+    public:
+        virtual ~EventListenerFactory(); // = default
+        virtual IEventListenerPtr create( IConfig const* config ) const = 0;
+        //! Return a meaningful name for the listener, e.g. its type name
+        virtual StringRef getName() const = 0;
+        //! Return listener's description if available
+        virtual std::string getDescription() const = 0;
+    };
+} // namespace Catch
+
+#endif // CATCH_INTERFACES_REPORTER_FACTORY_HPP_INCLUDED
+
+
+#ifndef CATCH_INTERFACES_TAG_ALIAS_REGISTRY_HPP_INCLUDED
+#define CATCH_INTERFACES_TAG_ALIAS_REGISTRY_HPP_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+    struct TagAlias;
+
+    class ITagAliasRegistry {
+    public:
+        virtual ~ITagAliasRegistry(); // = default
+        // Nullptr if not present
+        virtual TagAlias const* find( std::string const& alias ) const = 0;
+        virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const = 0;
+
+        static ITagAliasRegistry const& get();
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_INTERFACES_TAG_ALIAS_REGISTRY_HPP_INCLUDED
+
+
+#ifndef CATCH_INTERFACES_TESTCASE_HPP_INCLUDED
+#define CATCH_INTERFACES_TESTCASE_HPP_INCLUDED
+
+#include <vector>
+
+namespace Catch {
+
+    struct TestCaseInfo;
+    class TestCaseHandle;
+    class IConfig;
+
+    class ITestCaseRegistry {
+    public:
+        virtual ~ITestCaseRegistry(); // = default
+        // TODO: this exists only for adding filenames to test cases -- let's expose this in a saner way later
+        virtual std::vector<TestCaseInfo* > const& getAllInfos() const = 0;
+        virtual std::vector<TestCaseHandle> const& getAllTests() const = 0;
+        virtual std::vector<TestCaseHandle> const& getAllTestsSorted( IConfig const& config ) const = 0;
+    };
+
+}
+
+#endif // CATCH_INTERFACES_TESTCASE_HPP_INCLUDED
+
+#endif // CATCH_INTERFACES_ALL_HPP_INCLUDED
+
+
+#ifndef CATCH_CASE_INSENSITIVE_COMPARISONS_HPP_INCLUDED
+#define CATCH_CASE_INSENSITIVE_COMPARISONS_HPP_INCLUDED
+
+
+namespace Catch {
+    namespace Detail {
+        //! Provides case-insensitive `op<` semantics when called
+        struct CaseInsensitiveLess {
+            bool operator()( StringRef lhs,
+                             StringRef rhs ) const;
+        };
+
+        //! Provides case-insensitive `op==` semantics when called
+        struct CaseInsensitiveEqualTo {
+            bool operator()( StringRef lhs,
+                             StringRef rhs ) const;
+        };
+
+    } // namespace Detail
+} // namespace Catch
+
+#endif // CATCH_CASE_INSENSITIVE_COMPARISONS_HPP_INCLUDED
+
+
+
+/** \file
+ * Wrapper for ANDROID_LOGWRITE configuration option
+ *
+ * We want to default to enabling it when compiled for android, but
+ * users of the library should also be able to disable it if they want
+ * to.
+ */
+
+#ifndef CATCH_CONFIG_ANDROID_LOGWRITE_HPP_INCLUDED
+#define CATCH_CONFIG_ANDROID_LOGWRITE_HPP_INCLUDED
+
+
+#if defined(__ANDROID__)
+#    define CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE
+#endif
+
+
+#if defined( CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE ) && \
+    !defined( CATCH_CONFIG_NO_ANDROID_LOGWRITE ) &&      \
+    !defined( CATCH_CONFIG_ANDROID_LOGWRITE )
+#    define CATCH_CONFIG_ANDROID_LOGWRITE
+#endif
+
+#endif // CATCH_CONFIG_ANDROID_LOGWRITE_HPP_INCLUDED
+
+
+
+/** \file
+ * Wrapper for UNCAUGHT_EXCEPTIONS configuration option
+ *
+ * For some functionality, Catch2 requires to know whether there is
+ * an active exception. Because `std::uncaught_exception` is deprecated
+ * in C++17, we want to use `std::uncaught_exceptions` if possible.
+ */
+
+#ifndef CATCH_CONFIG_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED
+#define CATCH_CONFIG_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED
+
+
+#if defined(_MSC_VER)
+#  if _MSC_VER >= 1900 // Visual Studio 2015 or newer
+#    define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
+#  endif
+#endif
+
+
+#include <exception>
+
+#if defined(__cpp_lib_uncaught_exceptions) \
+    && !defined(CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
+
+#  define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
+#endif // __cpp_lib_uncaught_exceptions
+
+
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS) \
+    && !defined(CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS) \
+    && !defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
+
+#  define CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
+#endif
+
+
+#endif // CATCH_CONFIG_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED
+
+
+#ifndef CATCH_CONSOLE_COLOUR_HPP_INCLUDED
+#define CATCH_CONSOLE_COLOUR_HPP_INCLUDED
+
+
+#include <iosfwd>
+#include <cstdint>
+
+namespace Catch {
+
+    enum class ColourMode : std::uint8_t;
+    class IStream;
+
+    struct Colour {
+        enum Code {
+            None = 0,
+
+            White,
+            Red,
+            Green,
+            Blue,
+            Cyan,
+            Yellow,
+            Grey,
+
+            Bright = 0x10,
+
+            BrightRed = Bright | Red,
+            BrightGreen = Bright | Green,
+            LightGrey = Bright | Grey,
+            BrightWhite = Bright | White,
+            BrightYellow = Bright | Yellow,
+
+            // By intention
+            FileName = LightGrey,
+            Warning = BrightYellow,
+            ResultError = BrightRed,
+            ResultSuccess = BrightGreen,
+            ResultExpectedFailure = Warning,
+
+            Error = BrightRed,
+            Success = Green,
+            Skip = LightGrey,
+
+            OriginalExpression = Cyan,
+            ReconstructedExpression = BrightYellow,
+
+            SecondaryText = LightGrey,
+            Headers = White
+        };
+    };
+
+    class ColourImpl {
+    protected:
+        //! The associated stream of this ColourImpl instance
+        IStream* m_stream;
+    public:
+        ColourImpl( IStream* stream ): m_stream( stream ) {}
+
+        //! RAII wrapper around writing specific colour of text using specific
+        //! colour impl into a stream.
+        class ColourGuard {
+            ColourImpl const* m_colourImpl;
+            Colour::Code m_code;
+            bool m_engaged = false;
+
+        public:
+            //! Does **not** engage the guard/start the colour
+            ColourGuard( Colour::Code code,
+                         ColourImpl const* colour );
+
+            ColourGuard( ColourGuard const& rhs ) = delete;
+            ColourGuard& operator=( ColourGuard const& rhs ) = delete;
+
+            ColourGuard( ColourGuard&& rhs ) noexcept;
+            ColourGuard& operator=( ColourGuard&& rhs ) noexcept;
+
+            //! Removes colour _if_ the guard was engaged
+            ~ColourGuard();
+
+            /**
+             * Explicitly engages colour for given stream.
+             *
+             * The API based on operator<< should be preferred.
+             */
+            ColourGuard& engage( std::ostream& stream ) &;
+            /**
+             * Explicitly engages colour for given stream.
+             *
+             * The API based on operator<< should be preferred.
+             */
+            ColourGuard&& engage( std::ostream& stream ) &&;
+
+        private:
+            //! Engages the guard and starts using colour
+            friend std::ostream& operator<<( std::ostream& lhs,
+                                             ColourGuard& guard ) {
+                guard.engageImpl( lhs );
+                return lhs;
+            }
+            //! Engages the guard and starts using colour
+            friend std::ostream& operator<<( std::ostream& lhs,
+                                            ColourGuard&& guard) {
+                guard.engageImpl( lhs );
+                return lhs;
+            }
+
+            void engageImpl( std::ostream& stream );
+
+        };
+
+        virtual ~ColourImpl(); // = default
+        /**
+         * Creates a guard object for given colour and this colour impl
+         *
+         * **Important:**
+         * the guard starts disengaged, and has to be engaged explicitly.
+         */
+        ColourGuard guardColour( Colour::Code colourCode );
+
+    private:
+        virtual void use( Colour::Code colourCode ) const = 0;
+    };
+
+    //! Provides ColourImpl based on global config and target compilation platform
+    Detail::unique_ptr<ColourImpl> makeColourImpl( ColourMode colourSelection,
+                                                   IStream* stream );
+
+    //! Checks if specific colour impl has been compiled into the binary
+    bool isColourImplAvailable( ColourMode colourSelection );
+
+} // end namespace Catch
+
+#endif // CATCH_CONSOLE_COLOUR_HPP_INCLUDED
+
+
+#ifndef CATCH_CONSOLE_WIDTH_HPP_INCLUDED
+#define CATCH_CONSOLE_WIDTH_HPP_INCLUDED
+
+// This include must be kept so that user's configured value for CONSOLE_WIDTH
+// is used before we attempt to provide a default value
+
+#ifndef CATCH_CONFIG_CONSOLE_WIDTH
+#define CATCH_CONFIG_CONSOLE_WIDTH 80
+#endif
+
+#endif // CATCH_CONSOLE_WIDTH_HPP_INCLUDED
+
+
+#ifndef CATCH_CONTAINER_NONMEMBERS_HPP_INCLUDED
+#define CATCH_CONTAINER_NONMEMBERS_HPP_INCLUDED
+
+
+#include <cstddef>
+#include <initializer_list>
+
+// We want a simple polyfill over `std::empty`, `std::size` and so on
+// for C++14 or C++ libraries with incomplete support.
+// We also have to handle that MSVC std lib will happily provide these
+// under older standards.
+#if defined(CATCH_CPP17_OR_GREATER) || defined(_MSC_VER)
+
+// We are already using this header either way, so there shouldn't
+// be much additional overhead in including it to get the feature
+// test macros
+#include <string>
+
+#  if !defined(__cpp_lib_nonmember_container_access)
+#      define CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS
+#  endif
+
+#else
+#define CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS
+#endif
+
+
+
+namespace Catch {
+namespace Detail {
+
+#if defined(CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS)
+    template <typename Container>
+    constexpr auto empty(Container const& cont) -> decltype(cont.empty()) {
+        return cont.empty();
+    }
+    template <typename T, std::size_t N>
+    constexpr bool empty(const T (&)[N]) noexcept {
+        // GCC < 7 does not support the const T(&)[] parameter syntax
+        // so we have to ignore the length explicitly
+        (void)N;
+        return false;
+    }
+    template <typename T>
+    constexpr bool empty(std::initializer_list<T> list) noexcept {
+        return list.size() > 0;
+    }
+
+
+    template <typename Container>
+    constexpr auto size(Container const& cont) -> decltype(cont.size()) {
+        return cont.size();
+    }
+    template <typename T, std::size_t N>
+    constexpr std::size_t size(const T(&)[N]) noexcept {
+        return N;
+    }
+#endif // CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS
+
+} // end namespace Detail
+} // end namespace Catch
+
+
+
+#endif // CATCH_CONTAINER_NONMEMBERS_HPP_INCLUDED
+
+
+#ifndef CATCH_DEBUG_CONSOLE_HPP_INCLUDED
+#define CATCH_DEBUG_CONSOLE_HPP_INCLUDED
+
+#include <string>
+
+namespace Catch {
+    void writeToDebugConsole( std::string const& text );
+}
+
+#endif // CATCH_DEBUG_CONSOLE_HPP_INCLUDED
+
+
+#ifndef CATCH_DEBUGGER_HPP_INCLUDED
+#define CATCH_DEBUGGER_HPP_INCLUDED
+
+
+namespace Catch {
+    bool isDebuggerActive();
+}
+
+#ifdef CATCH_PLATFORM_MAC
+
+    #if defined(__i386__) || defined(__x86_64__)
+        #define CATCH_TRAP() __asm__("int $3\n" : : ) /* NOLINT */
+    #elif defined(__aarch64__)
+        #define CATCH_TRAP() __asm__(".inst 0xd43e0000")
+    #elif defined(__POWERPC__)
+        #define CATCH_TRAP() __asm__("li r0, 20\nsc\nnop\nli r0, 37\nli r4, 2\nsc\nnop\n" \
+        : : : "memory","r0","r3","r4" ) /* NOLINT */
+    #endif
+
+#elif defined(CATCH_PLATFORM_IPHONE)
+
+    // use inline assembler
+    #if defined(__i386__) || defined(__x86_64__)
+        #define CATCH_TRAP()  __asm__("int $3")
+    #elif defined(__aarch64__)
+        #define CATCH_TRAP()  __asm__(".inst 0xd4200000")
+    #elif defined(__arm__) && !defined(__thumb__)
+        #define CATCH_TRAP()  __asm__(".inst 0xe7f001f0")
+    #elif defined(__arm__) &&  defined(__thumb__)
+        #define CATCH_TRAP()  __asm__(".inst 0xde01")
+    #endif
+
+#elif defined(CATCH_PLATFORM_LINUX)
+    // If we can use inline assembler, do it because this allows us to break
+    // directly at the location of the failing check instead of breaking inside
+    // raise() called from it, i.e. one stack frame below.
+    #if defined(__GNUC__) && (defined(__i386) || defined(__x86_64))
+        #define CATCH_TRAP() asm volatile ("int $3") /* NOLINT */
+    #else // Fall back to the generic way.
+        #include <signal.h>
+
+        #define CATCH_TRAP() raise(SIGTRAP)
+    #endif
+#elif defined(_MSC_VER)
+    #define CATCH_TRAP() __debugbreak()
+#elif defined(__MINGW32__)
+    extern "C" __declspec(dllimport) void __stdcall DebugBreak();
+    #define CATCH_TRAP() DebugBreak()
+#endif
+
+#ifndef CATCH_BREAK_INTO_DEBUGGER
+    #ifdef CATCH_TRAP
+        #define CATCH_BREAK_INTO_DEBUGGER() []{ if( Catch::isDebuggerActive() ) { CATCH_TRAP(); } }()
+    #else
+        #define CATCH_BREAK_INTO_DEBUGGER() []{}()
+    #endif
+#endif
+
+#endif // CATCH_DEBUGGER_HPP_INCLUDED
+
+
+#ifndef CATCH_ENFORCE_HPP_INCLUDED
+#define CATCH_ENFORCE_HPP_INCLUDED
+
+
+#include <exception>
+
+namespace Catch {
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+    template <typename Ex>
+    [[noreturn]]
+    void throw_exception(Ex const& e) {
+        throw e;
+    }
+#else // ^^ Exceptions are enabled //  Exceptions are disabled vv
+    [[noreturn]]
+    void throw_exception(std::exception const& e);
+#endif
+
+    [[noreturn]]
+    void throw_logic_error(std::string const& msg);
+    [[noreturn]]
+    void throw_domain_error(std::string const& msg);
+    [[noreturn]]
+    void throw_runtime_error(std::string const& msg);
+
+} // namespace Catch;
+
+#define CATCH_MAKE_MSG(...) \
+    (Catch::ReusableStringStream() << __VA_ARGS__).str()
+
+#define CATCH_INTERNAL_ERROR(...) \
+    Catch::throw_logic_error(CATCH_MAKE_MSG( CATCH_INTERNAL_LINEINFO << ": Internal Catch2 error: " << __VA_ARGS__))
+
+#define CATCH_ERROR(...) \
+    Catch::throw_domain_error(CATCH_MAKE_MSG( __VA_ARGS__ ))
+
+#define CATCH_RUNTIME_ERROR(...) \
+    Catch::throw_runtime_error(CATCH_MAKE_MSG( __VA_ARGS__ ))
+
+#define CATCH_ENFORCE( condition, ... ) \
+    do{ if( !(condition) ) CATCH_ERROR( __VA_ARGS__ ); } while(false)
+
+
+#endif // CATCH_ENFORCE_HPP_INCLUDED
+
+
+#ifndef CATCH_ENUM_VALUES_REGISTRY_HPP_INCLUDED
+#define CATCH_ENUM_VALUES_REGISTRY_HPP_INCLUDED
+
+
+#include <vector>
+
+namespace Catch {
+
+    namespace Detail {
+
+        Catch::Detail::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values );
+
+        class EnumValuesRegistry : public IMutableEnumValuesRegistry {
+
+            std::vector<Catch::Detail::unique_ptr<EnumInfo>> m_enumInfos;
+
+            EnumInfo const& registerEnum( StringRef enumName, StringRef allValueNames, std::vector<int> const& values) override;
+        };
+
+        std::vector<StringRef> parseEnums( StringRef enums );
+
+    } // Detail
+
+} // Catch
+
+#endif // CATCH_ENUM_VALUES_REGISTRY_HPP_INCLUDED
+
+
+#ifndef CATCH_ERRNO_GUARD_HPP_INCLUDED
+#define CATCH_ERRNO_GUARD_HPP_INCLUDED
+
+namespace Catch {
+
+    //! Simple RAII class that stores the value of `errno`
+    //! at construction and restores it at destruction.
+    class ErrnoGuard {
+    public:
+        // Keep these outlined to avoid dragging in macros from <cerrno>
+
+        ErrnoGuard();
+        ~ErrnoGuard();
+    private:
+        int m_oldErrno;
+    };
+
+}
+
+#endif // CATCH_ERRNO_GUARD_HPP_INCLUDED
+
+
+#ifndef CATCH_EXCEPTION_TRANSLATOR_REGISTRY_HPP_INCLUDED
+#define CATCH_EXCEPTION_TRANSLATOR_REGISTRY_HPP_INCLUDED
+
+
+#include <vector>
+#include <string>
+
+namespace Catch {
+
+    class ExceptionTranslatorRegistry : public IExceptionTranslatorRegistry {
+    public:
+        ~ExceptionTranslatorRegistry() override;
+        void registerTranslator( Detail::unique_ptr<IExceptionTranslator>&& translator );
+        std::string translateActiveException() const override;
+
+    private:
+        ExceptionTranslators m_translators;
+    };
+}
+
+#endif // CATCH_EXCEPTION_TRANSLATOR_REGISTRY_HPP_INCLUDED
+
+
+#ifndef CATCH_FATAL_CONDITION_HANDLER_HPP_INCLUDED
+#define CATCH_FATAL_CONDITION_HANDLER_HPP_INCLUDED
+
+#include <cassert>
+
+namespace Catch {
+
+    /**
+     * Wrapper for platform-specific fatal error (signals/SEH) handlers
+     *
+     * Tries to be cooperative with other handlers, and not step over
+     * other handlers. This means that unknown structured exceptions
+     * are passed on, previous signal handlers are called, and so on.
+     *
+     * Can only be instantiated once, and assumes that once a signal
+     * is caught, the binary will end up terminating. Thus, there
+     */
+    class FatalConditionHandler {
+        bool m_started = false;
+
+        // Install/disengage implementation for specific platform.
+        // Should be if-defed to work on current platform, can assume
+        // engage-disengage 1:1 pairing.
+        void engage_platform();
+        void disengage_platform() noexcept;
+    public:
+        // Should also have platform-specific implementations as needed
+        FatalConditionHandler();
+        ~FatalConditionHandler();
+
+        void engage() {
+            assert(!m_started && "Handler cannot be installed twice.");
+            m_started = true;
+            engage_platform();
+        }
+
+        void disengage() noexcept {
+            assert(m_started && "Handler cannot be uninstalled without being installed first");
+            m_started = false;
+            disengage_platform();
+        }
+    };
+
+    //! Simple RAII guard for (dis)engaging the FatalConditionHandler
+    class FatalConditionHandlerGuard {
+        FatalConditionHandler* m_handler;
+    public:
+        FatalConditionHandlerGuard(FatalConditionHandler* handler):
+            m_handler(handler) {
+            m_handler->engage();
+        }
+        ~FatalConditionHandlerGuard() {
+            m_handler->disengage();
+        }
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_FATAL_CONDITION_HANDLER_HPP_INCLUDED
+
+
+#ifndef CATCH_FLOATING_POINT_HELPERS_HPP_INCLUDED
+#define CATCH_FLOATING_POINT_HELPERS_HPP_INCLUDED
+
+
+#include <cassert>
+#include <cmath>
+#include <cstdint>
+#include <utility>
+#include <limits>
+
+namespace Catch {
+    namespace Detail {
+
+        uint32_t convertToBits(float f);
+        uint64_t convertToBits(double d);
+
+        // Used when we know we want == comparison of two doubles
+        // to centralize warning suppression
+        bool directCompare( float lhs, float rhs );
+        bool directCompare( double lhs, double rhs );
+
+    } // end namespace Detail
+
+
+
+#if defined( __GNUC__ ) || defined( __clang__ )
+#    pragma GCC diagnostic push
+    // We do a bunch of direct compensations of floating point numbers,
+    // because we know what we are doing and actually do want the direct
+    // comparison behaviour.
+#    pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+
+    /**
+     * Calculates the ULP distance between two floating point numbers
+     *
+     * The ULP distance of two floating point numbers is the count of
+     * valid floating point numbers representable between them.
+     *
+     * There are some exceptions between how this function counts the
+     * distance, and the interpretation of the standard as implemented.
+     * by e.g. `nextafter`. For this function it always holds that:
+     * * `(x == y) => ulpDistance(x, y) == 0` (so `ulpDistance(-0, 0) == 0`)
+     * * `ulpDistance(maxFinite, INF) == 1`
+     * * `ulpDistance(x, -x) == 2 * ulpDistance(x, 0)`
+     *
+     * \pre `!isnan( lhs )`
+     * \pre `!isnan( rhs )`
+     * \pre floating point numbers are represented in IEEE-754 format
+     */
+    template <typename FP>
+    uint64_t ulpDistance( FP lhs, FP rhs ) {
+        assert( std::numeric_limits<FP>::is_iec559 &&
+            "ulpDistance assumes IEEE-754 format for floating point types" );
+        assert( !Catch::isnan( lhs ) &&
+                "Distance between NaN and number is not meaningful" );
+        assert( !Catch::isnan( rhs ) &&
+                "Distance between NaN and number is not meaningful" );
+
+        // We want X == Y to imply 0 ULP distance even if X and Y aren't
+        // bit-equal (-0 and 0), or X - Y != 0 (same sign infinities).
+        if ( lhs == rhs ) { return 0; }
+
+        // We need a properly typed positive zero for type inference.
+        static constexpr FP positive_zero{};
+
+        // We want to ensure that +/- 0 is always represented as positive zero
+        if ( lhs == positive_zero ) { lhs = positive_zero; }
+        if ( rhs == positive_zero ) { rhs = positive_zero; }
+
+        // If arguments have different signs, we can handle them by summing
+        // how far are they from 0 each.
+        if ( std::signbit( lhs ) != std::signbit( rhs ) ) {
+            return ulpDistance( std::abs( lhs ), positive_zero ) +
+                   ulpDistance( std::abs( rhs ), positive_zero );
+        }
+
+        // When both lhs and rhs are of the same sign, we can just
+        // read the numbers bitwise as integers, and then subtract them
+        // (assuming IEEE).
+        uint64_t lc = Detail::convertToBits( lhs );
+        uint64_t rc = Detail::convertToBits( rhs );
+
+        // The ulp distance between two numbers is symmetric, so to avoid
+        // dealing with overflows we want the bigger converted number on the lhs
+        if ( lc < rc ) {
+            std::swap( lc, rc );
+        }
+
+        return lc - rc;
+    }
+
+#if defined( __GNUC__ ) || defined( __clang__ )
+#    pragma GCC diagnostic pop
+#endif
+
+
+} // end namespace Catch
+
+#endif // CATCH_FLOATING_POINT_HELPERS_HPP_INCLUDED
+
+
+#ifndef CATCH_GETENV_HPP_INCLUDED
+#define CATCH_GETENV_HPP_INCLUDED
+
+namespace Catch {
+namespace Detail {
+
+    //! Wrapper over `std::getenv` that compiles on UWP (and always returns nullptr there)
+    char const* getEnv(char const* varName);
+
+}
+}
+
+#endif // CATCH_GETENV_HPP_INCLUDED
+
+
+#ifndef CATCH_IS_PERMUTATION_HPP_INCLUDED
+#define CATCH_IS_PERMUTATION_HPP_INCLUDED
+
+#include <algorithm>
+#include <iterator>
+
+namespace Catch {
+    namespace Detail {
+
+        template <typename ForwardIter,
+                  typename Sentinel,
+                  typename T,
+                  typename Comparator>
+        constexpr
+        ForwardIter find_sentinel( ForwardIter start,
+                                   Sentinel sentinel,
+                                   T const& value,
+                                   Comparator cmp ) {
+            while ( start != sentinel ) {
+                if ( cmp( *start, value ) ) { break; }
+                ++start;
+            }
+            return start;
+        }
+
+        template <typename ForwardIter,
+                  typename Sentinel,
+                  typename T,
+                  typename Comparator>
+        constexpr
+        std::ptrdiff_t count_sentinel( ForwardIter start,
+                                       Sentinel sentinel,
+                                       T const& value,
+                                       Comparator cmp ) {
+            std::ptrdiff_t count = 0;
+            while ( start != sentinel ) {
+                if ( cmp( *start, value ) ) { ++count; }
+                ++start;
+            }
+            return count;
+        }
+
+        template <typename ForwardIter, typename Sentinel>
+        constexpr
+        std::enable_if_t<!std::is_same<ForwardIter, Sentinel>::value,
+                         std::ptrdiff_t>
+        sentinel_distance( ForwardIter iter, const Sentinel sentinel ) {
+            std::ptrdiff_t dist = 0;
+            while ( iter != sentinel ) {
+                ++iter;
+                ++dist;
+            }
+            return dist;
+        }
+
+        template <typename ForwardIter>
+        constexpr std::ptrdiff_t sentinel_distance( ForwardIter first,
+                                                    ForwardIter last ) {
+            return std::distance( first, last );
+        }
+
+        template <typename ForwardIter1,
+                  typename Sentinel1,
+                  typename ForwardIter2,
+                  typename Sentinel2,
+                  typename Comparator>
+        constexpr bool check_element_counts( ForwardIter1 first_1,
+                                             const Sentinel1 end_1,
+                                             ForwardIter2 first_2,
+                                             const Sentinel2 end_2,
+                                             Comparator cmp ) {
+            auto cursor = first_1;
+            while ( cursor != end_1 ) {
+                if ( find_sentinel( first_1, cursor, *cursor, cmp ) ==
+                     cursor ) {
+                    // we haven't checked this element yet
+                    const auto count_in_range_2 =
+                        count_sentinel( first_2, end_2, *cursor, cmp );
+                    // Not a single instance in 2nd range, so it cannot be a
+                    // permutation of 1st range
+                    if ( count_in_range_2 == 0 ) { return false; }
+
+                    const auto count_in_range_1 =
+                        count_sentinel( cursor, end_1, *cursor, cmp );
+                    if ( count_in_range_1 != count_in_range_2 ) {
+                        return false;
+                    }
+                }
+
+                ++cursor;
+            }
+
+            return true;
+        }
+
+        template <typename ForwardIter1,
+                  typename Sentinel1,
+                  typename ForwardIter2,
+                  typename Sentinel2,
+                  typename Comparator>
+        constexpr bool is_permutation( ForwardIter1 first_1,
+                                       const Sentinel1 end_1,
+                                       ForwardIter2 first_2,
+                                       const Sentinel2 end_2,
+                                       Comparator cmp ) {
+            // TODO: no optimization for stronger iterators, because we would also have to constrain on sentinel vs not sentinel types
+            // TODO: Comparator has to be "both sides", e.g. a == b => b == a
+            // This skips shared prefix of the two ranges
+            while (first_1 != end_1 && first_2 != end_2 && cmp(*first_1, *first_2)) {
+                ++first_1;
+                ++first_2;
+            }
+
+            // We need to handle case where at least one of the ranges has no more elements
+            if (first_1 == end_1 || first_2 == end_2) {
+                return first_1 == end_1 && first_2 == end_2;
+            }
+
+            // pair counting is n**2, so we pay linear walk to compare the sizes first
+            auto dist_1 = sentinel_distance( first_1, end_1 );
+            auto dist_2 = sentinel_distance( first_2, end_2 );
+
+            if (dist_1 != dist_2) { return false; }
+
+            // Since we do not try to handle stronger iterators pair (e.g.
+            // bidir) optimally, the only thing left to do is to check counts in
+            // the remaining ranges.
+            return check_element_counts( first_1, end_1, first_2, end_2, cmp );
+        }
+
+    } // namespace Detail
+} // namespace Catch
+
+#endif // CATCH_IS_PERMUTATION_HPP_INCLUDED
+
+
+#ifndef CATCH_ISTREAM_HPP_INCLUDED
+#define CATCH_ISTREAM_HPP_INCLUDED
+
+
+#include <iosfwd>
+#include <cstddef>
+#include <ostream>
+#include <string>
+
+namespace Catch {
+
+    class IStream {
+    public:
+        virtual ~IStream(); // = default
+        virtual std::ostream& stream() = 0;
+        /**
+         * Best guess on whether the instance is writing to a console (e.g. via stdout/stderr)
+         *
+         * This is useful for e.g. Win32 colour support, because the Win32
+         * API manipulates console directly, unlike POSIX escape codes,
+         * that can be written anywhere.
+         *
+         * Due to variety of ways to change where the stdout/stderr is
+         * _actually_ being written, users should always assume that
+         * the answer might be wrong.
+         */
+        virtual bool isConsole() const { return false; }
+    };
+
+    /**
+     * Creates a stream wrapper that writes to specific file.
+     *
+     * Also recognizes 4 special filenames
+     * * `-` for stdout
+     * * `%stdout` for stdout
+     * * `%stderr` for stderr
+     * * `%debug` for platform specific debugging output
+     *
+     * \throws if passed an unrecognized %-prefixed stream
+     */
+    auto makeStream( std::string const& filename ) -> Detail::unique_ptr<IStream>;
+
+}
+
+#endif // CATCH_STREAM_HPP_INCLUDED
+
+
+#ifndef CATCH_JSONWRITER_HPP_INCLUDED
+#define CATCH_JSONWRITER_HPP_INCLUDED
+
+
+#include <cstdint>
+#include <sstream>
+
+namespace Catch {
+    class JsonObjectWriter;
+    class JsonArrayWriter;
+
+    struct JsonUtils {
+        static void indent( std::ostream& os, std::uint64_t level );
+        static void appendCommaNewline( std::ostream& os,
+                                        bool& should_comma,
+                                        std::uint64_t level );
+    };
+
+    class JsonValueWriter {
+    public:
+        JsonValueWriter( std::ostream& os );
+        JsonValueWriter( std::ostream& os, std::uint64_t indent_level );
+
+        JsonObjectWriter writeObject() &&;
+        JsonArrayWriter writeArray() &&;
+
+        template <typename T>
+        void write( T const& value ) && {
+            writeImpl( value, !std::is_arithmetic<T>::value );
+        }
+        void write( StringRef value ) &&;
+        void write( bool value ) &&;
+
+    private:
+        void writeImpl( StringRef value, bool quote );
+
+        // Without this SFINAE, this overload is a better match
+        // for `std::string`, `char const*`, `char const[N]` args.
+        // While it would still work, it would cause code bloat
+        // and multiple iteration over the strings
+        template <typename T,
+                  typename = typename std::enable_if_t<
+                      !std::is_convertible<T, StringRef>::value>>
+        void writeImpl( T const& value, bool quote_value ) {
+            m_sstream << value;
+            writeImpl( m_sstream.str(), quote_value );
+        }
+
+        std::ostream& m_os;
+        std::stringstream m_sstream;
+        std::uint64_t m_indent_level;
+    };
+
+    class JsonObjectWriter {
+    public:
+        JsonObjectWriter( std::ostream& os );
+        JsonObjectWriter( std::ostream& os, std::uint64_t indent_level );
+
+        JsonObjectWriter( JsonObjectWriter&& source ) noexcept;
+        JsonObjectWriter& operator=( JsonObjectWriter&& source ) = delete;
+
+        ~JsonObjectWriter();
+
+        JsonValueWriter write( StringRef key );
+
+    private:
+        std::ostream& m_os;
+        std::uint64_t m_indent_level;
+        bool m_should_comma = false;
+        bool m_active = true;
+    };
+
+    class JsonArrayWriter {
+    public:
+        JsonArrayWriter( std::ostream& os );
+        JsonArrayWriter( std::ostream& os, std::uint64_t indent_level );
+
+        JsonArrayWriter( JsonArrayWriter&& source ) noexcept;
+        JsonArrayWriter& operator=( JsonArrayWriter&& source ) = delete;
+
+        ~JsonArrayWriter();
+
+        JsonObjectWriter writeObject();
+        JsonArrayWriter writeArray();
+
+        template <typename T>
+        JsonArrayWriter& write( T const& value ) {
+            return writeImpl( value );
+        }
+
+        JsonArrayWriter& write( bool value );
+
+    private:
+        template <typename T>
+        JsonArrayWriter& writeImpl( T const& value ) {
+            JsonUtils::appendCommaNewline(
+                m_os, m_should_comma, m_indent_level + 1 );
+            JsonValueWriter{ m_os }.write( value );
+
+            return *this;
+        }
+
+        std::ostream& m_os;
+        std::uint64_t m_indent_level;
+        bool m_should_comma = false;
+        bool m_active = true;
+    };
+
+} // namespace Catch
+
+#endif // CATCH_JSONWRITER_HPP_INCLUDED
+
+
+#ifndef CATCH_LEAK_DETECTOR_HPP_INCLUDED
+#define CATCH_LEAK_DETECTOR_HPP_INCLUDED
+
+namespace Catch {
+
+    struct LeakDetector {
+        LeakDetector();
+        ~LeakDetector();
+    };
+
+}
+#endif // CATCH_LEAK_DETECTOR_HPP_INCLUDED
+
+
+#ifndef CATCH_LIST_HPP_INCLUDED
+#define CATCH_LIST_HPP_INCLUDED
+
+
+#include <set>
+#include <string>
+
+
+namespace Catch {
+
+    class IEventListener;
+    class Config;
+
+
+    struct ReporterDescription {
+        std::string name, description;
+    };
+    struct ListenerDescription {
+        StringRef name;
+        std::string description;
+    };
+
+    struct TagInfo {
+        void add(StringRef spelling);
+        std::string all() const;
+
+        std::set<StringRef> spellings;
+        std::size_t count = 0;
+    };
+
+    bool list( IEventListener& reporter, Config const& config );
+
+} // end namespace Catch
+
+#endif // CATCH_LIST_HPP_INCLUDED
+
+
+#ifndef CATCH_OUTPUT_REDIRECT_HPP_INCLUDED
+#define CATCH_OUTPUT_REDIRECT_HPP_INCLUDED
+
+
+#include <cassert>
+#include <string>
+
+namespace Catch {
+
+    class OutputRedirect {
+        bool m_redirectActive = false;
+        virtual void activateImpl() = 0;
+        virtual void deactivateImpl() = 0;
+    public:
+        enum Kind {
+            //! No redirect (noop implementation)
+            None,
+            //! Redirect std::cout/std::cerr/std::clog streams internally
+            Streams,
+            //! Redirect the stdout/stderr file descriptors into files
+            FileDescriptors,
+        };
+
+        virtual ~OutputRedirect(); // = default;
+
+        // TODO: Do we want to check that redirect is not active before retrieving the output?
+        virtual std::string getStdout() = 0;
+        virtual std::string getStderr() = 0;
+        virtual void clearBuffers() = 0;
+        bool isActive() const { return m_redirectActive; }
+        void activate() {
+            assert( !m_redirectActive && "redirect is already active" );
+            activateImpl();
+            m_redirectActive = true;
+        }
+        void deactivate() {
+            assert( m_redirectActive && "redirect is not active" );
+            deactivateImpl();
+            m_redirectActive = false;
+        }
+    };
+
+    bool isRedirectAvailable( OutputRedirect::Kind kind);
+    Detail::unique_ptr<OutputRedirect> makeOutputRedirect( bool actual );
+
+    class RedirectGuard {
+        OutputRedirect* m_redirect;
+        bool m_activate;
+        bool m_previouslyActive;
+        bool m_moved = false;
+
+    public:
+        RedirectGuard( bool activate, OutputRedirect& redirectImpl );
+        ~RedirectGuard() noexcept( false );
+
+        RedirectGuard( RedirectGuard const& ) = delete;
+        RedirectGuard& operator=( RedirectGuard const& ) = delete;
+
+        // C++14 needs move-able guards to return them from functions
+        RedirectGuard( RedirectGuard&& rhs ) noexcept;
+        RedirectGuard& operator=( RedirectGuard&& rhs ) noexcept;
+    };
+
+    RedirectGuard scopedActivate( OutputRedirect& redirectImpl );
+    RedirectGuard scopedDeactivate( OutputRedirect& redirectImpl );
+
+} // end namespace Catch
+
+#endif // CATCH_OUTPUT_REDIRECT_HPP_INCLUDED
+
+
+#ifndef CATCH_PARSE_NUMBERS_HPP_INCLUDED
+#define CATCH_PARSE_NUMBERS_HPP_INCLUDED
+
+
+#include <string>
+
+namespace Catch {
+
+    /**
+     * Parses unsigned int from the input, using provided base
+     *
+     * Effectively a wrapper around std::stoul but with better error checking
+     * e.g. "-1" is rejected, instead of being parsed as UINT_MAX.
+     */
+    Optional<unsigned int> parseUInt(std::string const& input, int base = 10);
+}
+
+#endif // CATCH_PARSE_NUMBERS_HPP_INCLUDED
+
+
+#ifndef CATCH_REPORTER_REGISTRY_HPP_INCLUDED
+#define CATCH_REPORTER_REGISTRY_HPP_INCLUDED
+
+
+#include <map>
+#include <string>
+#include <vector>
+
+namespace Catch {
+
+    class IEventListener;
+    using IEventListenerPtr = Detail::unique_ptr<IEventListener>;
+    class IReporterFactory;
+    using IReporterFactoryPtr = Detail::unique_ptr<IReporterFactory>;
+    struct ReporterConfig;
+    class EventListenerFactory;
+
+    class ReporterRegistry {
+        struct ReporterRegistryImpl;
+        Detail::unique_ptr<ReporterRegistryImpl> m_impl;
+
+    public:
+        ReporterRegistry();
+        ~ReporterRegistry(); // = default;
+
+        IEventListenerPtr create( std::string const& name,
+                                  ReporterConfig&& config ) const;
+
+        void registerReporter( std::string const& name,
+                               IReporterFactoryPtr factory );
+
+        void
+        registerListener( Detail::unique_ptr<EventListenerFactory> factory );
+
+        std::map<std::string,
+                 IReporterFactoryPtr,
+                 Detail::CaseInsensitiveLess> const&
+        getFactories() const;
+
+        std::vector<Detail::unique_ptr<EventListenerFactory>> const&
+        getListeners() const;
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_REPORTER_REGISTRY_HPP_INCLUDED
+
+
+#ifndef CATCH_RUN_CONTEXT_HPP_INCLUDED
+#define CATCH_RUN_CONTEXT_HPP_INCLUDED
+
+
+
+#ifndef CATCH_TEST_CASE_TRACKER_HPP_INCLUDED
+#define CATCH_TEST_CASE_TRACKER_HPP_INCLUDED
+
+
+#include <string>
+#include <vector>
+
+namespace Catch {
+namespace TestCaseTracking {
+
+    struct NameAndLocation {
+        std::string name;
+        SourceLineInfo location;
+
+        NameAndLocation( std::string&& _name, SourceLineInfo const& _location );
+        friend bool operator==(NameAndLocation const& lhs, NameAndLocation const& rhs) {
+            // This is a very cheap check that should have a very high hit rate.
+            // If we get to SourceLineInfo::operator==, we will redo it, but the
+            // cost of repeating is trivial at that point (we will be paying
+            // multiple strcmp/memcmps at that point).
+            if ( lhs.location.line != rhs.location.line ) { return false; }
+            return lhs.name == rhs.name && lhs.location == rhs.location;
+        }
+        friend bool operator!=(NameAndLocation const& lhs,
+                               NameAndLocation const& rhs) {
+            return !( lhs == rhs );
+        }
+    };
+
+    /**
+     * This is a variant of `NameAndLocation` that does not own the name string
+     *
+     * This avoids extra allocations when trying to locate a tracker by its
+     * name and location, as long as we make sure that trackers only keep
+     * around the owning variant.
+     */
+    struct NameAndLocationRef {
+        StringRef name;
+        SourceLineInfo location;
+
+        constexpr NameAndLocationRef( StringRef name_,
+                                      SourceLineInfo location_ ):
+            name( name_ ), location( location_ ) {}
+
+        friend bool operator==( NameAndLocation const& lhs,
+                                NameAndLocationRef const& rhs ) {
+            // This is a very cheap check that should have a very high hit rate.
+            // If we get to SourceLineInfo::operator==, we will redo it, but the
+            // cost of repeating is trivial at that point (we will be paying
+            // multiple strcmp/memcmps at that point).
+            if ( lhs.location.line != rhs.location.line ) { return false; }
+            return StringRef( lhs.name ) == rhs.name &&
+                   lhs.location == rhs.location;
+        }
+        friend bool operator==( NameAndLocationRef const& lhs,
+                                NameAndLocation const& rhs ) {
+            return rhs == lhs;
+        }
+    };
+
+    class ITracker;
+
+    using ITrackerPtr = Catch::Detail::unique_ptr<ITracker>;
+
+    class ITracker {
+        NameAndLocation m_nameAndLocation;
+
+        using Children = std::vector<ITrackerPtr>;
+
+    protected:
+        enum CycleState {
+            NotStarted,
+            Executing,
+            ExecutingChildren,
+            NeedsAnotherRun,
+            CompletedSuccessfully,
+            Failed
+        };
+
+        ITracker* m_parent = nullptr;
+        Children m_children;
+        CycleState m_runState = NotStarted;
+
+    public:
+        ITracker( NameAndLocation&& nameAndLoc, ITracker* parent ):
+            m_nameAndLocation( CATCH_MOVE(nameAndLoc) ),
+            m_parent( parent )
+        {}
+
+
+        // static queries
+        NameAndLocation const& nameAndLocation() const {
+            return m_nameAndLocation;
+        }
+        ITracker* parent() const {
+            return m_parent;
+        }
+
+        virtual ~ITracker(); // = default
+
+
+        // dynamic queries
+
+        //! Returns true if tracker run to completion (successfully or not)
+        virtual bool isComplete() const = 0;
+        //! Returns true if tracker run to completion successfully
+        bool isSuccessfullyCompleted() const {
+            return m_runState == CompletedSuccessfully;
+        }
+        //! Returns true if tracker has started but hasn't been completed
+        bool isOpen() const;
+        //! Returns true iff tracker has started
+        bool hasStarted() const;
+
+        // actions
+        virtual void close() = 0; // Successfully complete
+        virtual void fail() = 0;
+        void markAsNeedingAnotherRun();
+
+        //! Register a nested ITracker
+        void addChild( ITrackerPtr&& child );
+        /**
+         * Returns ptr to specific child if register with this tracker.
+         *
+         * Returns nullptr if not found.
+         */
+        ITracker* findChild( NameAndLocationRef const& nameAndLocation );
+        //! Have any children been added?
+        bool hasChildren() const {
+            return !m_children.empty();
+        }
+
+
+        //! Marks tracker as executing a child, doing se recursively up the tree
+        void openChild();
+
+        /**
+         * Returns true if the instance is a section tracker
+         *
+         * Subclasses should override to true if they are, replaces RTTI
+         * for internal debug checks.
+         */
+        virtual bool isSectionTracker() const;
+        /**
+         * Returns true if the instance is a generator tracker
+         *
+         * Subclasses should override to true if they are, replaces RTTI
+         * for internal debug checks.
+         */
+        virtual bool isGeneratorTracker() const;
+    };
+
+    class TrackerContext {
+
+        enum RunState {
+            NotStarted,
+            Executing,
+            CompletedCycle
+        };
+
+        ITrackerPtr m_rootTracker;
+        ITracker* m_currentTracker = nullptr;
+        RunState m_runState = NotStarted;
+
+    public:
+
+        ITracker& startRun();
+
+        void startCycle() {
+            m_currentTracker = m_rootTracker.get();
+            m_runState = Executing;
+        }
+        void completeCycle();
+
+        bool completedCycle() const;
+        ITracker& currentTracker() { return *m_currentTracker; }
+        void setCurrentTracker( ITracker* tracker );
+    };
+
+    class TrackerBase : public ITracker {
+    protected:
+
+        TrackerContext& m_ctx;
+
+    public:
+        TrackerBase( NameAndLocation&& nameAndLocation, TrackerContext& ctx, ITracker* parent );
+
+        bool isComplete() const override;
+
+        void open();
+
+        void close() override;
+        void fail() override;
+
+    private:
+        void moveToParent();
+        void moveToThis();
+    };
+
+    class SectionTracker : public TrackerBase {
+        std::vector<StringRef> m_filters;
+        // Note that lifetime-wise we piggy back off the name stored in the `ITracker` parent`.
+        // Currently it allocates owns the name, so this is safe. If it is later refactored
+        // to not own the name, the name still has to outlive the `ITracker` parent, so
+        // this should still be safe.
+        StringRef m_trimmed_name;
+    public:
+        SectionTracker( NameAndLocation&& nameAndLocation, TrackerContext& ctx, ITracker* parent );
+
+        bool isSectionTracker() const override;
+
+        bool isComplete() const override;
+
+        static SectionTracker& acquire( TrackerContext& ctx, NameAndLocationRef const& nameAndLocation );
+
+        void tryOpen();
+
+        void addInitialFilters( std::vector<std::string> const& filters );
+        void addNextFilters( std::vector<StringRef> const& filters );
+        //! Returns filters active in this tracker
+        std::vector<StringRef> const& getFilters() const { return m_filters; }
+        //! Returns whitespace-trimmed name of the tracked section
+        StringRef trimmedName() const;
+    };
+
+} // namespace TestCaseTracking
+
+using TestCaseTracking::ITracker;
+using TestCaseTracking::TrackerContext;
+using TestCaseTracking::SectionTracker;
+
+} // namespace Catch
+
+#endif // CATCH_TEST_CASE_TRACKER_HPP_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+    class IGeneratorTracker;
+    class IConfig;
+    class IEventListener;
+    using IEventListenerPtr = Detail::unique_ptr<IEventListener>;
+    class OutputRedirect;
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    class RunContext final : public IResultCapture {
+
+    public:
+        RunContext( RunContext const& ) = delete;
+        RunContext& operator =( RunContext const& ) = delete;
+
+        explicit RunContext( IConfig const* _config, IEventListenerPtr&& reporter );
+
+        ~RunContext() override;
+
+        Totals runTest(TestCaseHandle const& testCase);
+
+    public: // IResultCapture
+
+        // Assertion handlers
+        void handleExpr
+                (   AssertionInfo const& info,
+                    ITransientExpression const& expr,
+                    AssertionReaction& reaction ) override;
+        void handleMessage
+                (   AssertionInfo const& info,
+                    ResultWas::OfType resultType,
+                    std::string&& message,
+                    AssertionReaction& reaction ) override;
+        void handleUnexpectedExceptionNotThrown
+                (   AssertionInfo const& info,
+                    AssertionReaction& reaction ) override;
+        void handleUnexpectedInflightException
+                (   AssertionInfo const& info,
+                    std::string&& message,
+                    AssertionReaction& reaction ) override;
+        void handleIncomplete
+                (   AssertionInfo const& info ) override;
+        void handleNonExpr
+                (   AssertionInfo const &info,
+                    ResultWas::OfType resultType,
+                    AssertionReaction &reaction ) override;
+
+        void notifyAssertionStarted( AssertionInfo const& info ) override;
+        bool sectionStarted( StringRef sectionName,
+                             SourceLineInfo const& sectionLineInfo,
+                             Counts& assertions ) override;
+
+        void sectionEnded( SectionEndInfo&& endInfo ) override;
+        void sectionEndedEarly( SectionEndInfo&& endInfo ) override;
+
+        IGeneratorTracker*
+        acquireGeneratorTracker( StringRef generatorName,
+                                 SourceLineInfo const& lineInfo ) override;
+        IGeneratorTracker* createGeneratorTracker(
+            StringRef generatorName,
+            SourceLineInfo lineInfo,
+            Generators::GeneratorBasePtr&& generator ) override;
+
+
+        void benchmarkPreparing( StringRef name ) override;
+        void benchmarkStarting( BenchmarkInfo const& info ) override;
+        void benchmarkEnded( BenchmarkStats<> const& stats ) override;
+        void benchmarkFailed( StringRef error ) override;
+
+        void pushScopedMessage( MessageInfo const& message ) override;
+        void popScopedMessage( MessageInfo const& message ) override;
+
+        void emplaceUnscopedMessage( MessageBuilder&& builder ) override;
+
+        std::string getCurrentTestName() const override;
+
+        const AssertionResult* getLastResult() const override;
+
+        void exceptionEarlyReported() override;
+
+        void handleFatalErrorCondition( StringRef message ) override;
+
+        bool lastAssertionPassed() override;
+
+        void assertionPassed() override;
+
+    public:
+        // !TBD We need to do this another way!
+        bool aborting() const;
+
+    private:
+
+        void runCurrentTest();
+        void invokeActiveTestCase();
+
+        void resetAssertionInfo();
+        bool testForMissingAssertions( Counts& assertions );
+
+        void assertionEnded( AssertionResult&& result );
+        void reportExpr
+                (   AssertionInfo const &info,
+                    ResultWas::OfType resultType,
+                    ITransientExpression const *expr,
+                    bool negated );
+
+        void populateReaction( AssertionReaction& reaction );
+
+    private:
+
+        void handleUnfinishedSections();
+
+        TestRunInfo m_runInfo;
+        TestCaseHandle const* m_activeTestCase = nullptr;
+        ITracker* m_testCaseTracker = nullptr;
+        Optional<AssertionResult> m_lastResult;
+
+        IConfig const* m_config;
+        Totals m_totals;
+        IEventListenerPtr m_reporter;
+        std::vector<MessageInfo> m_messages;
+        std::vector<ScopedMessage> m_messageScopes; /* Keeps owners of so-called unscoped messages. */
+        AssertionInfo m_lastAssertionInfo;
+        std::vector<SectionEndInfo> m_unfinishedSections;
+        std::vector<ITracker*> m_activeSections;
+        TrackerContext m_trackerContext;
+        Detail::unique_ptr<OutputRedirect> m_outputRedirect;
+        FatalConditionHandler m_fatalConditionhandler;
+        bool m_lastAssertionPassed = false;
+        bool m_shouldReportUnexpected = true;
+        bool m_includeSuccessfulResults;
+    };
+
+    void seedRng(IConfig const& config);
+    unsigned int rngSeed();
+} // end namespace Catch
+
+#endif // CATCH_RUN_CONTEXT_HPP_INCLUDED
+
+
+#ifndef CATCH_SHARDING_HPP_INCLUDED
+#define CATCH_SHARDING_HPP_INCLUDED
+
+#include <cassert>
+#include <cmath>
+#include <algorithm>
+
+namespace Catch {
+
+    template<typename Container>
+    Container createShard(Container const& container, std::size_t const shardCount, std::size_t const shardIndex) {
+        assert(shardCount > shardIndex);
+
+        if (shardCount == 1) {
+            return container;
+        }
+
+        const std::size_t totalTestCount = container.size();
+
+        const std::size_t shardSize = totalTestCount / shardCount;
+        const std::size_t leftoverTests = totalTestCount % shardCount;
+
+        const std::size_t startIndex = shardIndex * shardSize + (std::min)(shardIndex, leftoverTests);
+        const std::size_t endIndex = (shardIndex + 1) * shardSize + (std::min)(shardIndex + 1, leftoverTests);
+
+        auto startIterator = std::next(container.begin(), static_cast<std::ptrdiff_t>(startIndex));
+        auto endIterator = std::next(container.begin(), static_cast<std::ptrdiff_t>(endIndex));
+
+        return Container(startIterator, endIterator);
+    }
+
+}
+
+#endif // CATCH_SHARDING_HPP_INCLUDED
+
+
+#ifndef CATCH_SINGLETONS_HPP_INCLUDED
+#define CATCH_SINGLETONS_HPP_INCLUDED
+
+namespace Catch {
+
+    struct ISingleton {
+        virtual ~ISingleton(); // = default
+    };
+
+
+    void addSingleton( ISingleton* singleton );
+    void cleanupSingletons();
+
+
+    template<typename SingletonImplT, typename InterfaceT = SingletonImplT, typename MutableInterfaceT = InterfaceT>
+    class Singleton : SingletonImplT, public ISingleton {
+
+        static auto getInternal() -> Singleton* {
+            static Singleton* s_instance = nullptr;
+            if( !s_instance ) {
+                s_instance = new Singleton;
+                addSingleton( s_instance );
+            }
+            return s_instance;
+        }
+
+    public:
+        static auto get() -> InterfaceT const& {
+            return *getInternal();
+        }
+        static auto getMutable() -> MutableInterfaceT& {
+            return *getInternal();
+        }
+    };
+
+} // namespace Catch
+
+#endif // CATCH_SINGLETONS_HPP_INCLUDED
+
+
+#ifndef CATCH_STARTUP_EXCEPTION_REGISTRY_HPP_INCLUDED
+#define CATCH_STARTUP_EXCEPTION_REGISTRY_HPP_INCLUDED
+
+
+#include <vector>
+#include <exception>
+
+namespace Catch {
+
+    class StartupExceptionRegistry {
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+    public:
+        void add(std::exception_ptr const& exception) noexcept;
+        std::vector<std::exception_ptr> const& getExceptions() const noexcept;
+    private:
+        std::vector<std::exception_ptr> m_exceptions;
+#endif
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_STARTUP_EXCEPTION_REGISTRY_HPP_INCLUDED
+
+
+
+#ifndef CATCH_STDSTREAMS_HPP_INCLUDED
+#define CATCH_STDSTREAMS_HPP_INCLUDED
+
+#include <iosfwd>
+
+namespace Catch {
+
+    std::ostream& cout();
+    std::ostream& cerr();
+    std::ostream& clog();
+
+} // namespace Catch
+
+#endif
+
+
+#ifndef CATCH_STRING_MANIP_HPP_INCLUDED
+#define CATCH_STRING_MANIP_HPP_INCLUDED
+
+
+#include <cstdint>
+#include <string>
+#include <iosfwd>
+#include <vector>
+
+namespace Catch {
+
+    bool startsWith( std::string const& s, std::string const& prefix );
+    bool startsWith( StringRef s, char prefix );
+    bool endsWith( std::string const& s, std::string const& suffix );
+    bool endsWith( std::string const& s, char suffix );
+    bool contains( std::string const& s, std::string const& infix );
+    void toLowerInPlace( std::string& s );
+    std::string toLower( std::string const& s );
+    char toLower( char c );
+    //! Returns a new string without whitespace at the start/end
+    std::string trim( std::string const& str );
+    //! Returns a substring of the original ref without whitespace. Beware lifetimes!
+    StringRef trim(StringRef ref);
+
+    // !!! Be aware, returns refs into original string - make sure original string outlives them
+    std::vector<StringRef> splitStringRef( StringRef str, char delimiter );
+    bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis );
+
+    /**
+     * Helper for streaming a "count [maybe-plural-of-label]" human-friendly string
+     *
+     * Usage example:
+     * ```cpp
+     * std::cout << "Found " << pluralise(count, "error") << '\n';
+     * ```
+     *
+     * **Important:** The provided string must outlive the instance
+     */
+    class pluralise {
+        std::uint64_t m_count;
+        StringRef m_label;
+
+    public:
+        constexpr pluralise(std::uint64_t count, StringRef label):
+            m_count(count),
+            m_label(label)
+        {}
+
+        friend std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser );
+    };
+}
+
+#endif // CATCH_STRING_MANIP_HPP_INCLUDED
+
+
+#ifndef CATCH_TAG_ALIAS_REGISTRY_HPP_INCLUDED
+#define CATCH_TAG_ALIAS_REGISTRY_HPP_INCLUDED
+
+
+#include <map>
+#include <string>
+
+namespace Catch {
+    struct SourceLineInfo;
+
+    class TagAliasRegistry : public ITagAliasRegistry {
+    public:
+        ~TagAliasRegistry() override;
+        TagAlias const* find( std::string const& alias ) const override;
+        std::string expandAliases( std::string const& unexpandedTestSpec ) const override;
+        void add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo );
+
+    private:
+        std::map<std::string, TagAlias> m_registry;
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_TAG_ALIAS_REGISTRY_HPP_INCLUDED
+
+
+#ifndef CATCH_TEST_CASE_INFO_HASHER_HPP_INCLUDED
+#define CATCH_TEST_CASE_INFO_HASHER_HPP_INCLUDED
+
+#include <cstdint>
+
+namespace Catch {
+
+    struct TestCaseInfo;
+
+    class TestCaseInfoHasher {
+    public:
+        using hash_t = std::uint64_t;
+        TestCaseInfoHasher( hash_t seed );
+        uint32_t operator()( TestCaseInfo const& t ) const;
+
+    private:
+        hash_t m_seed;
+    };
+
+} // namespace Catch
+
+#endif /* CATCH_TEST_CASE_INFO_HASHER_HPP_INCLUDED */
+
+
+#ifndef CATCH_TEST_CASE_REGISTRY_IMPL_HPP_INCLUDED
+#define CATCH_TEST_CASE_REGISTRY_IMPL_HPP_INCLUDED
+
+
+#include <vector>
+
+namespace Catch {
+
+    class IConfig;
+    class ITestInvoker;
+    class TestCaseHandle;
+    class TestSpec;
+
+    std::vector<TestCaseHandle> sortTests( IConfig const& config, std::vector<TestCaseHandle> const& unsortedTestCases );
+
+    bool isThrowSafe( TestCaseHandle const& testCase, IConfig const& config );
+
+    std::vector<TestCaseHandle> filterTests( std::vector<TestCaseHandle> const& testCases, TestSpec const& testSpec, IConfig const& config );
+    std::vector<TestCaseHandle> const& getAllTestCasesSorted( IConfig const& config );
+
+    class TestRegistry : public ITestCaseRegistry {
+    public:
+        void registerTest( Detail::unique_ptr<TestCaseInfo> testInfo, Detail::unique_ptr<ITestInvoker> testInvoker );
+
+        std::vector<TestCaseInfo*> const& getAllInfos() const override;
+        std::vector<TestCaseHandle> const& getAllTests() const override;
+        std::vector<TestCaseHandle> const& getAllTestsSorted( IConfig const& config ) const override;
+
+        ~TestRegistry() override; // = default
+
+    private:
+        std::vector<Detail::unique_ptr<TestCaseInfo>> m_owned_test_infos;
+        // Keeps a materialized vector for `getAllInfos`.
+        // We should get rid of that eventually (see interface note)
+        std::vector<TestCaseInfo*> m_viewed_test_infos;
+
+        std::vector<Detail::unique_ptr<ITestInvoker>> m_invokers;
+        std::vector<TestCaseHandle> m_handles;
+        mutable TestRunOrder m_currentSortOrder = TestRunOrder::Declared;
+        mutable std::vector<TestCaseHandle> m_sortedFunctions;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+
+
+} // end namespace Catch
+
+
+#endif // CATCH_TEST_CASE_REGISTRY_IMPL_HPP_INCLUDED
+
+
+#ifndef CATCH_TEST_SPEC_PARSER_HPP_INCLUDED
+#define CATCH_TEST_SPEC_PARSER_HPP_INCLUDED
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+
+#include <vector>
+#include <string>
+
+namespace Catch {
+
+    class ITagAliasRegistry;
+
+    class TestSpecParser {
+        enum Mode{ None, Name, QuotedName, Tag, EscapedName };
+        Mode m_mode = None;
+        Mode lastMode = None;
+        bool m_exclusion = false;
+        std::size_t m_pos = 0;
+        std::size_t m_realPatternPos = 0;
+        std::string m_arg;
+        std::string m_substring;
+        std::string m_patternName;
+        std::vector<std::size_t> m_escapeChars;
+        TestSpec::Filter m_currentFilter;
+        TestSpec m_testSpec;
+        ITagAliasRegistry const* m_tagAliases = nullptr;
+
+    public:
+        TestSpecParser( ITagAliasRegistry const& tagAliases );
+
+        TestSpecParser& parse( std::string const& arg );
+        TestSpec testSpec();
+
+    private:
+        bool visitChar( char c );
+        void startNewMode( Mode mode );
+        bool processNoneChar( char c );
+        void processNameChar( char c );
+        bool processOtherChar( char c );
+        void endMode();
+        void escape();
+        bool isControlChar( char c ) const;
+        void saveLastMode();
+        void revertBackToLastMode();
+        void addFilter();
+        bool separate();
+
+        // Handles common preprocessing of the pattern for name/tag patterns
+        std::string preprocessPattern();
+        // Adds the current pattern as a test name
+        void addNamePattern();
+        // Adds the current pattern as a tag
+        void addTagPattern();
+
+        inline void addCharToPattern(char c) {
+            m_substring += c;
+            m_patternName += c;
+            m_realPatternPos++;
+        }
+
+    };
+
+} // namespace Catch
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+#endif // CATCH_TEST_SPEC_PARSER_HPP_INCLUDED
+
+
+#ifndef CATCH_TEXTFLOW_HPP_INCLUDED
+#define CATCH_TEXTFLOW_HPP_INCLUDED
+
+
+#include <cassert>
+#include <string>
+#include <vector>
+
+namespace Catch {
+    namespace TextFlow {
+
+        class Columns;
+
+        /**
+         * Abstraction for a string with ansi escape sequences that
+         * automatically skips over escapes when iterating. Only graphical
+         * escape sequences are considered.
+         *
+         * Internal representation:
+         * An escape sequence looks like \033[39;49m
+         * We need bidirectional iteration and the unbound length of escape
+         * sequences poses a problem for operator-- To make this work we'll
+         * replace the last `m` with a 0xff (this is a codepoint that won't have
+         * any utf-8 meaning).
+         */
+        class AnsiSkippingString {
+            std::string m_string;
+            std::size_t m_size = 0;
+
+            // perform 0xff replacement and calculate m_size
+            void preprocessString();
+
+        public:
+            class const_iterator;
+            using iterator = const_iterator;
+            // note: must be u-suffixed or this will cause a "truncation of
+            // constant value" warning on MSVC
+            static constexpr char sentinel = static_cast<char>( 0xffu );
+
+            explicit AnsiSkippingString( std::string const& text );
+            explicit AnsiSkippingString( std::string&& text );
+
+            const_iterator begin() const;
+            const_iterator end() const;
+
+            size_t size() const { return m_size; }
+
+            std::string substring( const_iterator begin,
+                                   const_iterator end ) const;
+        };
+
+        class AnsiSkippingString::const_iterator {
+            friend AnsiSkippingString;
+            struct EndTag {};
+
+            const std::string* m_string;
+            std::string::const_iterator m_it;
+
+            explicit const_iterator( const std::string& string, EndTag ):
+                m_string( &string ), m_it( string.end() ) {}
+
+            void tryParseAnsiEscapes();
+            void advance();
+            void unadvance();
+
+        public:
+            using difference_type = std::ptrdiff_t;
+            using value_type = char;
+            using pointer = value_type*;
+            using reference = value_type&;
+            using iterator_category = std::bidirectional_iterator_tag;
+
+            explicit const_iterator( const std::string& string ):
+                m_string( &string ), m_it( string.begin() ) {
+                tryParseAnsiEscapes();
+            }
+
+            char operator*() const { return *m_it; }
+
+            const_iterator& operator++() {
+                advance();
+                return *this;
+            }
+            const_iterator operator++( int ) {
+                iterator prev( *this );
+                operator++();
+                return prev;
+            }
+            const_iterator& operator--() {
+                unadvance();
+                return *this;
+            }
+            const_iterator operator--( int ) {
+                iterator prev( *this );
+                operator--();
+                return prev;
+            }
+
+            bool operator==( const_iterator const& other ) const {
+                return m_it == other.m_it;
+            }
+            bool operator!=( const_iterator const& other ) const {
+                return !operator==( other );
+            }
+            bool operator<=( const_iterator const& other ) const {
+                return m_it <= other.m_it;
+            }
+
+            const_iterator oneBefore() const {
+                auto it = *this;
+                return --it;
+            }
+        };
+
+        /**
+         * Represents a column of text with specific width and indentation
+         *
+         * When written out to a stream, it will perform linebreaking
+         * of the provided text so that the written lines fit within
+         * target width.
+         */
+        class Column {
+            // String to be written out
+            AnsiSkippingString m_string;
+            // Width of the column for linebreaking
+            size_t m_width = CATCH_CONFIG_CONSOLE_WIDTH - 1;
+            // Indentation of other lines (including first if initial indent is
+            // unset)
+            size_t m_indent = 0;
+            // Indentation of the first line
+            size_t m_initialIndent = std::string::npos;
+
+        public:
+            /**
+             * Iterates "lines" in `Column` and returns them
+             */
+            class const_iterator {
+                friend Column;
+                struct EndTag {};
+
+                Column const& m_column;
+                // Where does the current line start?
+                AnsiSkippingString::const_iterator m_lineStart;
+                // How long should the current line be?
+                AnsiSkippingString::const_iterator m_lineEnd;
+                // How far have we checked the string to iterate?
+                AnsiSkippingString::const_iterator m_parsedTo;
+                // Should a '-' be appended to the line?
+                bool m_addHyphen = false;
+
+                const_iterator( Column const& column, EndTag ):
+                    m_column( column ),
+                    m_lineStart( m_column.m_string.end() ),
+                    m_lineEnd( column.m_string.end() ),
+                    m_parsedTo( column.m_string.end() ) {}
+
+                // Calculates the length of the current line
+                void calcLength();
+
+                // Returns current indentation width
+                size_t indentSize() const;
+
+                // Creates an indented and (optionally) suffixed string from
+                // current iterator position, indentation and length.
+                std::string addIndentAndSuffix(
+                    AnsiSkippingString::const_iterator start,
+                    AnsiSkippingString::const_iterator end ) const;
+
+            public:
+                using difference_type = std::ptrdiff_t;
+                using value_type = std::string;
+                using pointer = value_type*;
+                using reference = value_type&;
+                using iterator_category = std::forward_iterator_tag;
+
+                explicit const_iterator( Column const& column );
+
+                std::string operator*() const;
+
+                const_iterator& operator++();
+                const_iterator operator++( int );
+
+                bool operator==( const_iterator const& other ) const {
+                    return m_lineStart == other.m_lineStart &&
+                           &m_column == &other.m_column;
+                }
+                bool operator!=( const_iterator const& other ) const {
+                    return !operator==( other );
+                }
+            };
+            using iterator = const_iterator;
+
+            explicit Column( std::string const& text ): m_string( text ) {}
+            explicit Column( std::string&& text ):
+                m_string( CATCH_MOVE( text ) ) {}
+
+            Column& width( size_t newWidth ) & {
+                assert( newWidth > 0 );
+                m_width = newWidth;
+                return *this;
+            }
+            Column&& width( size_t newWidth ) && {
+                assert( newWidth > 0 );
+                m_width = newWidth;
+                return CATCH_MOVE( *this );
+            }
+            Column& indent( size_t newIndent ) & {
+                m_indent = newIndent;
+                return *this;
+            }
+            Column&& indent( size_t newIndent ) && {
+                m_indent = newIndent;
+                return CATCH_MOVE( *this );
+            }
+            Column& initialIndent( size_t newIndent ) & {
+                m_initialIndent = newIndent;
+                return *this;
+            }
+            Column&& initialIndent( size_t newIndent ) && {
+                m_initialIndent = newIndent;
+                return CATCH_MOVE( *this );
+            }
+
+            size_t width() const { return m_width; }
+            const_iterator begin() const { return const_iterator( *this ); }
+            const_iterator end() const {
+                return { *this, const_iterator::EndTag{} };
+            }
+
+            friend std::ostream& operator<<( std::ostream& os,
+                                             Column const& col );
+
+            friend Columns operator+( Column const& lhs, Column const& rhs );
+            friend Columns operator+( Column&& lhs, Column&& rhs );
+        };
+
+        //! Creates a column that serves as an empty space of specific width
+        Column Spacer( size_t spaceWidth );
+
+        class Columns {
+            std::vector<Column> m_columns;
+
+        public:
+            class iterator {
+                friend Columns;
+                struct EndTag {};
+
+                std::vector<Column> const& m_columns;
+                std::vector<Column::const_iterator> m_iterators;
+                size_t m_activeIterators;
+
+                iterator( Columns const& columns, EndTag );
+
+            public:
+                using difference_type = std::ptrdiff_t;
+                using value_type = std::string;
+                using pointer = value_type*;
+                using reference = value_type&;
+                using iterator_category = std::forward_iterator_tag;
+
+                explicit iterator( Columns const& columns );
+
+                auto operator==( iterator const& other ) const -> bool {
+                    return m_iterators == other.m_iterators;
+                }
+                auto operator!=( iterator const& other ) const -> bool {
+                    return m_iterators != other.m_iterators;
+                }
+                std::string operator*() const;
+                iterator& operator++();
+                iterator operator++( int );
+            };
+            using const_iterator = iterator;
+
+            iterator begin() const { return iterator( *this ); }
+            iterator end() const { return { *this, iterator::EndTag() }; }
+
+            friend Columns& operator+=( Columns& lhs, Column const& rhs );
+            friend Columns& operator+=( Columns& lhs, Column&& rhs );
+            friend Columns operator+( Columns const& lhs, Column const& rhs );
+            friend Columns operator+( Columns&& lhs, Column&& rhs );
+
+            friend std::ostream& operator<<( std::ostream& os,
+                                             Columns const& cols );
+        };
+
+    } // namespace TextFlow
+} // namespace Catch
+#endif // CATCH_TEXTFLOW_HPP_INCLUDED
+
+
+#ifndef CATCH_TO_STRING_HPP_INCLUDED
+#define CATCH_TO_STRING_HPP_INCLUDED
+
+#include <string>
+
+
+namespace Catch {
+    template <typename T>
+    std::string to_string(T const& t) {
+#if defined(CATCH_CONFIG_CPP11_TO_STRING)
+        return std::to_string(t);
+#else
+        ReusableStringStream rss;
+        rss << t;
+        return rss.str();
+#endif
+    }
+} // end namespace Catch
+
+#endif // CATCH_TO_STRING_HPP_INCLUDED
+
+
+#ifndef CATCH_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED
+#define CATCH_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED
+
+namespace Catch {
+    bool uncaught_exceptions();
+} // end namespace Catch
+
+#endif // CATCH_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED
+
+
+#ifndef CATCH_XMLWRITER_HPP_INCLUDED
+#define CATCH_XMLWRITER_HPP_INCLUDED
+
+
+#include <iosfwd>
+#include <vector>
+#include <cstdint>
+
+namespace Catch {
+    enum class XmlFormatting : std::uint8_t {
+        None = 0x00,
+        Indent = 0x01,
+        Newline = 0x02,
+    };
+
+    constexpr XmlFormatting operator|( XmlFormatting lhs, XmlFormatting rhs ) {
+        return static_cast<XmlFormatting>( static_cast<std::uint8_t>( lhs ) |
+                                           static_cast<std::uint8_t>( rhs ) );
+    }
+
+    constexpr XmlFormatting operator&( XmlFormatting lhs, XmlFormatting rhs ) {
+        return static_cast<XmlFormatting>( static_cast<std::uint8_t>( lhs ) &
+                                           static_cast<std::uint8_t>( rhs ) );
+    }
+
+
+    /**
+     * Helper for XML-encoding text (escaping angle brackets, quotes, etc)
+     *
+     * Note: doesn't take ownership of passed strings, and thus the
+     *       encoded string must outlive the encoding instance.
+     */
+    class XmlEncode {
+    public:
+        enum ForWhat { ForTextNodes, ForAttributes };
+
+        constexpr XmlEncode( StringRef str, ForWhat forWhat = ForTextNodes ):
+            m_str( str ), m_forWhat( forWhat ) {}
+
+
+        void encodeTo( std::ostream& os ) const;
+
+        friend std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode );
+
+    private:
+        StringRef m_str;
+        ForWhat m_forWhat;
+    };
+
+    class XmlWriter {
+    public:
+
+        class ScopedElement {
+        public:
+            ScopedElement( XmlWriter* writer, XmlFormatting fmt );
+
+            ScopedElement( ScopedElement&& other ) noexcept;
+            ScopedElement& operator=( ScopedElement&& other ) noexcept;
+
+            ~ScopedElement();
+
+            ScopedElement&
+            writeText( StringRef text,
+                       XmlFormatting fmt = XmlFormatting::Newline |
+                                           XmlFormatting::Indent );
+
+            ScopedElement& writeAttribute( StringRef name,
+                                           StringRef attribute );
+            template <typename T,
+                      // Without this SFINAE, this overload is a better match
+                      // for `std::string`, `char const*`, `char const[N]` args.
+                      // While it would still work, it would cause code bloat
+                      // and multiple iteration over the strings
+                      typename = typename std::enable_if_t<
+                          !std::is_convertible<T, StringRef>::value>>
+            ScopedElement& writeAttribute( StringRef name,
+                                           T const& attribute ) {
+                m_writer->writeAttribute( name, attribute );
+                return *this;
+            }
+
+        private:
+            XmlWriter* m_writer = nullptr;
+            XmlFormatting m_fmt;
+        };
+
+        XmlWriter( std::ostream& os );
+        ~XmlWriter();
+
+        XmlWriter( XmlWriter const& ) = delete;
+        XmlWriter& operator=( XmlWriter const& ) = delete;
+
+        XmlWriter& startElement( std::string const& name, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
+
+        ScopedElement scopedElement( std::string const& name, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
+
+        XmlWriter& endElement(XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
+
+        //! The attribute content is XML-encoded
+        XmlWriter& writeAttribute( StringRef name, StringRef attribute );
+
+        //! Writes the attribute as "true/false"
+        XmlWriter& writeAttribute( StringRef name, bool attribute );
+
+        //! The attribute content is XML-encoded
+        XmlWriter& writeAttribute( StringRef name, char const* attribute );
+
+        //! The attribute value must provide op<<(ostream&, T). The resulting
+        //! serialization is XML-encoded
+        template <typename T,
+                  // Without this SFINAE, this overload is a better match
+                  // for `std::string`, `char const*`, `char const[N]` args.
+                  // While it would still work, it would cause code bloat
+                  // and multiple iteration over the strings
+                  typename = typename std::enable_if_t<
+                      !std::is_convertible<T, StringRef>::value>>
+        XmlWriter& writeAttribute( StringRef name, T const& attribute ) {
+            ReusableStringStream rss;
+            rss << attribute;
+            return writeAttribute( name, rss.str() );
+        }
+
+        //! Writes escaped `text` in a element
+        XmlWriter& writeText( StringRef text,
+                              XmlFormatting fmt = XmlFormatting::Newline |
+                                                  XmlFormatting::Indent );
+
+        //! Writes XML comment as "<!-- text -->"
+        XmlWriter& writeComment( StringRef text,
+                                 XmlFormatting fmt = XmlFormatting::Newline |
+                                                     XmlFormatting::Indent );
+
+        void writeStylesheetRef( StringRef url );
+
+        void ensureTagClosed();
+
+    private:
+
+        void applyFormatting(XmlFormatting fmt);
+
+        void writeDeclaration();
+
+        void newlineIfNecessary();
+
+        bool m_tagIsOpen = false;
+        bool m_needsNewline = false;
+        std::vector<std::string> m_tags;
+        std::string m_indent;
+        std::ostream& m_os;
+    };
+
+}
+
+#endif // CATCH_XMLWRITER_HPP_INCLUDED
+
+
+/** \file
+ * This is a convenience header for Catch2's Matcher support. It includes
+ * **all** of Catch2 headers related to matchers.
+ *
+ * Generally the Catch2 users should use specific includes they need,
+ * but this header can be used instead for ease-of-experimentation, or
+ * just plain convenience, at the cost of increased compilation times.
+ *
+ * When a new header is added to either the `matchers` folder, or to
+ * the corresponding internal subfolder, it should be added here.
+ */
+
+#ifndef CATCH_MATCHERS_ALL_HPP_INCLUDED
+#define CATCH_MATCHERS_ALL_HPP_INCLUDED
+
+
+
+#ifndef CATCH_MATCHERS_HPP_INCLUDED
+#define CATCH_MATCHERS_HPP_INCLUDED
+
+
+
+#ifndef CATCH_MATCHERS_IMPL_HPP_INCLUDED
+#define CATCH_MATCHERS_IMPL_HPP_INCLUDED
+
+
+#include <string>
+
+namespace Catch {
+
+#ifdef __clang__
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wsign-compare"
+#    pragma clang diagnostic ignored "-Wnon-virtual-dtor"
+#elif defined __GNUC__
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wsign-compare"
+#    pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
+#endif
+
+    template<typename ArgT, typename MatcherT>
+    class MatchExpr : public ITransientExpression {
+        ArgT && m_arg;
+        MatcherT const& m_matcher;
+    public:
+        constexpr MatchExpr( ArgT && arg, MatcherT const& matcher )
+        :   ITransientExpression{ true, matcher.match( arg ) }, // not forwarding arg here on purpose
+            m_arg( CATCH_FORWARD(arg) ),
+            m_matcher( matcher )
+        {}
+
+        void streamReconstructedExpression( std::ostream& os ) const override {
+            os << Catch::Detail::stringify( m_arg )
+               << ' '
+               << m_matcher.toString();
+        }
+    };
+
+#ifdef __clang__
+#    pragma clang diagnostic pop
+#elif defined __GNUC__
+#    pragma GCC diagnostic pop
+#endif
+
+
+    namespace Matchers {
+        template <typename ArgT>
+        class MatcherBase;
+    }
+
+    using StringMatcher = Matchers::MatcherBase<std::string>;
+
+    void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher );
+
+    template<typename ArgT, typename MatcherT>
+    constexpr MatchExpr<ArgT, MatcherT>
+    makeMatchExpr( ArgT&& arg, MatcherT const& matcher ) {
+        return MatchExpr<ArgT, MatcherT>( CATCH_FORWARD(arg), matcher );
+    }
+
+} // namespace Catch
+
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CHECK_THAT( macroName, matcher, resultDisposition, arg ) \
+    do { \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(arg) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
+        INTERNAL_CATCH_TRY { \
+            catchAssertionHandler.handleExpr( Catch::makeMatchExpr( arg, matcher ) ); \
+        } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
+        catchAssertionHandler.complete(); \
+    } while( false )
+
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_THROWS_MATCHES( macroName, exceptionType, resultDisposition, matcher, ... ) \
+    do { \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(exceptionType) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
+        if( catchAssertionHandler.allowThrows() ) \
+            try { \
+                CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+                CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
+                static_cast<void>(__VA_ARGS__ ); \
+                CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
+            } \
+            catch( exceptionType const& ex ) { \
+                catchAssertionHandler.handleExpr( Catch::makeMatchExpr( ex, matcher ) ); \
+            } \
+            catch( ... ) { \
+                catchAssertionHandler.handleUnexpectedInflightException(); \
+            } \
+        else \
+            catchAssertionHandler.handleThrowingCallSkipped(); \
+        catchAssertionHandler.complete(); \
+    } while( false )
+
+
+#endif // CATCH_MATCHERS_IMPL_HPP_INCLUDED
+
+#include <string>
+#include <vector>
+
+namespace Catch {
+namespace Matchers {
+
+    class MatcherUntypedBase {
+    public:
+        MatcherUntypedBase() = default;
+
+        MatcherUntypedBase(MatcherUntypedBase const&) = default;
+        MatcherUntypedBase(MatcherUntypedBase&&) = default;
+
+        MatcherUntypedBase& operator = (MatcherUntypedBase const&) = delete;
+        MatcherUntypedBase& operator = (MatcherUntypedBase&&) = delete;
+
+        std::string toString() const;
+
+    protected:
+        virtual ~MatcherUntypedBase(); // = default;
+        virtual std::string describe() const = 0;
+        mutable std::string m_cachedToString;
+    };
+
+
+    template<typename T>
+    class MatcherBase : public MatcherUntypedBase {
+    public:
+        virtual bool match( T const& arg ) const = 0;
+    };
+
+    namespace Detail {
+
+        template<typename ArgT>
+        class MatchAllOf final : public MatcherBase<ArgT> {
+            std::vector<MatcherBase<ArgT> const*> m_matchers;
+
+        public:
+            MatchAllOf() = default;
+            MatchAllOf(MatchAllOf const&) = delete;
+            MatchAllOf& operator=(MatchAllOf const&) = delete;
+            MatchAllOf(MatchAllOf&&) = default;
+            MatchAllOf& operator=(MatchAllOf&&) = default;
+
+
+            bool match( ArgT const& arg ) const override {
+                for( auto matcher : m_matchers ) {
+                    if (!matcher->match(arg))
+                        return false;
+                }
+                return true;
+            }
+            std::string describe() const override {
+                std::string description;
+                description.reserve( 4 + m_matchers.size()*32 );
+                description += "( ";
+                bool first = true;
+                for( auto matcher : m_matchers ) {
+                    if( first )
+                        first = false;
+                    else
+                        description += " and ";
+                    description += matcher->toString();
+                }
+                description += " )";
+                return description;
+            }
+
+            friend MatchAllOf operator&& (MatchAllOf&& lhs, MatcherBase<ArgT> const& rhs) {
+                lhs.m_matchers.push_back(&rhs);
+                return CATCH_MOVE(lhs);
+            }
+            friend MatchAllOf operator&& (MatcherBase<ArgT> const& lhs, MatchAllOf&& rhs) {
+                rhs.m_matchers.insert(rhs.m_matchers.begin(), &lhs);
+                return CATCH_MOVE(rhs);
+            }
+        };
+
+        //! lvalue overload is intentionally deleted, users should
+        //! not be trying to compose stored composition matchers
+        template<typename ArgT>
+        MatchAllOf<ArgT> operator&& (MatchAllOf<ArgT> const& lhs, MatcherBase<ArgT> const& rhs) = delete;
+        //! lvalue overload is intentionally deleted, users should
+        //! not be trying to compose stored composition matchers
+        template<typename ArgT>
+        MatchAllOf<ArgT> operator&& (MatcherBase<ArgT> const& lhs, MatchAllOf<ArgT> const& rhs) = delete;
+
+        template<typename ArgT>
+        class MatchAnyOf final : public MatcherBase<ArgT> {
+            std::vector<MatcherBase<ArgT> const*> m_matchers;
+        public:
+            MatchAnyOf() = default;
+            MatchAnyOf(MatchAnyOf const&) = delete;
+            MatchAnyOf& operator=(MatchAnyOf const&) = delete;
+            MatchAnyOf(MatchAnyOf&&) = default;
+            MatchAnyOf& operator=(MatchAnyOf&&) = default;
+
+            bool match( ArgT const& arg ) const override {
+                for( auto matcher : m_matchers ) {
+                    if (matcher->match(arg))
+                        return true;
+                }
+                return false;
+            }
+            std::string describe() const override {
+                std::string description;
+                description.reserve( 4 + m_matchers.size()*32 );
+                description += "( ";
+                bool first = true;
+                for( auto matcher : m_matchers ) {
+                    if( first )
+                        first = false;
+                    else
+                        description += " or ";
+                    description += matcher->toString();
+                }
+                description += " )";
+                return description;
+            }
+
+            friend MatchAnyOf operator|| (MatchAnyOf&& lhs, MatcherBase<ArgT> const& rhs) {
+                lhs.m_matchers.push_back(&rhs);
+                return CATCH_MOVE(lhs);
+            }
+            friend MatchAnyOf operator|| (MatcherBase<ArgT> const& lhs, MatchAnyOf&& rhs) {
+                rhs.m_matchers.insert(rhs.m_matchers.begin(), &lhs);
+                return CATCH_MOVE(rhs);
+            }
+        };
+
+        //! lvalue overload is intentionally deleted, users should
+        //! not be trying to compose stored composition matchers
+        template<typename ArgT>
+        MatchAnyOf<ArgT> operator|| (MatchAnyOf<ArgT> const& lhs, MatcherBase<ArgT> const& rhs) = delete;
+        //! lvalue overload is intentionally deleted, users should
+        //! not be trying to compose stored composition matchers
+        template<typename ArgT>
+        MatchAnyOf<ArgT> operator|| (MatcherBase<ArgT> const& lhs, MatchAnyOf<ArgT> const& rhs) = delete;
+
+        template<typename ArgT>
+        class MatchNotOf final : public MatcherBase<ArgT> {
+            MatcherBase<ArgT> const& m_underlyingMatcher;
+
+        public:
+            explicit MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ):
+                m_underlyingMatcher( underlyingMatcher )
+            {}
+
+            bool match( ArgT const& arg ) const override {
+                return !m_underlyingMatcher.match( arg );
+            }
+
+            std::string describe() const override {
+                return "not " + m_underlyingMatcher.toString();
+            }
+        };
+
+    } // namespace Detail
+
+    template <typename T>
+    Detail::MatchAllOf<T> operator&& (MatcherBase<T> const& lhs, MatcherBase<T> const& rhs) {
+        return Detail::MatchAllOf<T>{} && lhs && rhs;
+    }
+    template <typename T>
+    Detail::MatchAnyOf<T> operator|| (MatcherBase<T> const& lhs, MatcherBase<T> const& rhs) {
+        return Detail::MatchAnyOf<T>{} || lhs || rhs;
+    }
+
+    template <typename T>
+    Detail::MatchNotOf<T> operator! (MatcherBase<T> const& matcher) {
+        return Detail::MatchNotOf<T>{ matcher };
+    }
+
+
+} // namespace Matchers
+} // namespace Catch
+
+
+#if defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_DISABLE)
+  #define CATCH_REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
+  #define CATCH_REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CATCH_REQUIRE_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::Normal, matcher, expr )
+
+  #define CATCH_CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+  #define CATCH_CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CATCH_CHECK_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+
+  #define CATCH_CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
+  #define CATCH_REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
+
+#elif defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE)
+
+  #define CATCH_REQUIRE_THROWS_WITH( expr, matcher )                   (void)(0)
+  #define CATCH_REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
+
+  #define CATCH_CHECK_THROWS_WITH( expr, matcher )                     (void)(0)
+  #define CATCH_CHECK_THROWS_MATCHES( expr, exceptionType, matcher )   (void)(0)
+
+  #define CATCH_CHECK_THAT( arg, matcher )                             (void)(0)
+  #define CATCH_REQUIRE_THAT( arg, matcher )                           (void)(0)
+
+#elif !defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_DISABLE)
+
+  #define REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
+  #define REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "REQUIRE_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::Normal, matcher, expr )
+
+  #define CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+  #define CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CHECK_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+
+  #define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
+  #define REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
+
+#elif !defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE)
+
+  #define REQUIRE_THROWS_WITH( expr, matcher )                   (void)(0)
+  #define REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
+
+  #define CHECK_THROWS_WITH( expr, matcher )                     (void)(0)
+  #define CHECK_THROWS_MATCHES( expr, exceptionType, matcher )   (void)(0)
+
+  #define CHECK_THAT( arg, matcher )                             (void)(0)
+  #define REQUIRE_THAT( arg, matcher )                           (void)(0)
+
+#endif // end of user facing macro declarations
+
+#endif // CATCH_MATCHERS_HPP_INCLUDED
+
+
+#ifndef CATCH_MATCHERS_CONTAINER_PROPERTIES_HPP_INCLUDED
+#define CATCH_MATCHERS_CONTAINER_PROPERTIES_HPP_INCLUDED
+
+
+
+#ifndef CATCH_MATCHERS_TEMPLATED_HPP_INCLUDED
+#define CATCH_MATCHERS_TEMPLATED_HPP_INCLUDED
+
+
+#include <array>
+#include <algorithm>
+#include <string>
+#include <type_traits>
+
+namespace Catch {
+namespace Matchers {
+    class MatcherGenericBase : public MatcherUntypedBase {
+    public:
+        MatcherGenericBase() = default;
+        ~MatcherGenericBase() override; // = default;
+
+        MatcherGenericBase(MatcherGenericBase const&) = default;
+        MatcherGenericBase(MatcherGenericBase&&) = default;
+
+        MatcherGenericBase& operator=(MatcherGenericBase const&) = delete;
+        MatcherGenericBase& operator=(MatcherGenericBase&&) = delete;
+    };
+
+
+    namespace Detail {
+        template<std::size_t N, std::size_t M>
+        std::array<void const*, N + M> array_cat(std::array<void const*, N> && lhs, std::array<void const*, M> && rhs) {
+            std::array<void const*, N + M> arr{};
+            std::copy_n(lhs.begin(), N, arr.begin());
+            std::copy_n(rhs.begin(), M, arr.begin() + N);
+            return arr;
+        }
+
+        template<std::size_t N>
+        std::array<void const*, N+1> array_cat(std::array<void const*, N> && lhs, void const* rhs) {
+            std::array<void const*, N+1> arr{};
+            std::copy_n(lhs.begin(), N, arr.begin());
+            arr[N] = rhs;
+            return arr;
+        }
+
+        template<std::size_t N>
+        std::array<void const*, N+1> array_cat(void const* lhs, std::array<void const*, N> && rhs) {
+            std::array<void const*, N + 1> arr{ {lhs} };
+            std::copy_n(rhs.begin(), N, arr.begin() + 1);
+            return arr;
+        }
+
+        template<typename T>
+        using is_generic_matcher = std::is_base_of<
+            Catch::Matchers::MatcherGenericBase,
+            std::remove_cv_t<std::remove_reference_t<T>>
+        >;
+
+        template<typename... Ts>
+        using are_generic_matchers = Catch::Detail::conjunction<is_generic_matcher<Ts>...>;
+
+        template<typename T>
+        using is_matcher = std::is_base_of<
+            Catch::Matchers::MatcherUntypedBase,
+            std::remove_cv_t<std::remove_reference_t<T>>
+        >;
+
+
+        template<std::size_t N, typename Arg>
+        bool match_all_of(Arg&&, std::array<void const*, N> const&, std::index_sequence<>) {
+            return true;
+        }
+
+        template<typename T, typename... MatcherTs, std::size_t N, typename Arg, std::size_t Idx, std::size_t... Indices>
+        bool match_all_of(Arg&& arg, std::array<void const*, N> const& matchers, std::index_sequence<Idx, Indices...>) {
+            return static_cast<T const*>(matchers[Idx])->match(arg) && match_all_of<MatcherTs...>(arg, matchers, std::index_sequence<Indices...>{});
+        }
+
+
+        template<std::size_t N, typename Arg>
+        bool match_any_of(Arg&&, std::array<void const*, N> const&, std::index_sequence<>) {
+            return false;
+        }
+
+        template<typename T, typename... MatcherTs, std::size_t N, typename Arg, std::size_t Idx, std::size_t... Indices>
+        bool match_any_of(Arg&& arg, std::array<void const*, N> const& matchers, std::index_sequence<Idx, Indices...>) {
+            return static_cast<T const*>(matchers[Idx])->match(arg) || match_any_of<MatcherTs...>(arg, matchers, std::index_sequence<Indices...>{});
+        }
+
+        std::string describe_multi_matcher(StringRef combine, std::string const* descriptions_begin, std::string const* descriptions_end);
+
+        template<typename... MatcherTs, std::size_t... Idx>
+        std::string describe_multi_matcher(StringRef combine, std::array<void const*, sizeof...(MatcherTs)> const& matchers, std::index_sequence<Idx...>) {
+            std::array<std::string, sizeof...(MatcherTs)> descriptions {{
+                static_cast<MatcherTs const*>(matchers[Idx])->toString()...
+            }};
+
+            return describe_multi_matcher(combine, descriptions.data(), descriptions.data() + descriptions.size());
+        }
+
+
+        template<typename... MatcherTs>
+        class MatchAllOfGeneric final : public MatcherGenericBase {
+        public:
+            MatchAllOfGeneric(MatchAllOfGeneric const&) = delete;
+            MatchAllOfGeneric& operator=(MatchAllOfGeneric const&) = delete;
+            MatchAllOfGeneric(MatchAllOfGeneric&&) = default;
+            MatchAllOfGeneric& operator=(MatchAllOfGeneric&&) = default;
+
+            MatchAllOfGeneric(MatcherTs const&... matchers) : m_matchers{ {std::addressof(matchers)...} } {}
+            explicit MatchAllOfGeneric(std::array<void const*, sizeof...(MatcherTs)> matchers) : m_matchers{matchers} {}
+
+            template<typename Arg>
+            bool match(Arg&& arg) const {
+                return match_all_of<MatcherTs...>(arg, m_matchers, std::index_sequence_for<MatcherTs...>{});
+            }
+
+            std::string describe() const override {
+                return describe_multi_matcher<MatcherTs...>(" and "_sr, m_matchers, std::index_sequence_for<MatcherTs...>{});
+            }
+
+            // Has to be public to enable the concatenating operators
+            // below, because they are not friend of the RHS, only LHS,
+            // and thus cannot access private fields of RHS
+            std::array<void const*, sizeof...( MatcherTs )> m_matchers;
+
+
+            //! Avoids type nesting for `GenericAllOf && GenericAllOf` case
+            template<typename... MatchersRHS>
+            friend
+            MatchAllOfGeneric<MatcherTs..., MatchersRHS...> operator && (
+                    MatchAllOfGeneric<MatcherTs...>&& lhs,
+                    MatchAllOfGeneric<MatchersRHS...>&& rhs) {
+                return MatchAllOfGeneric<MatcherTs..., MatchersRHS...>{array_cat(CATCH_MOVE(lhs.m_matchers), CATCH_MOVE(rhs.m_matchers))};
+            }
+
+            //! Avoids type nesting for `GenericAllOf && some matcher` case
+            template<typename MatcherRHS>
+            friend std::enable_if_t<is_matcher<MatcherRHS>::value,
+            MatchAllOfGeneric<MatcherTs..., MatcherRHS>> operator && (
+                    MatchAllOfGeneric<MatcherTs...>&& lhs,
+                    MatcherRHS const& rhs) {
+                return MatchAllOfGeneric<MatcherTs..., MatcherRHS>{array_cat(CATCH_MOVE(lhs.m_matchers), static_cast<void const*>(&rhs))};
+            }
+
+            //! Avoids type nesting for `some matcher && GenericAllOf` case
+            template<typename MatcherLHS>
+            friend std::enable_if_t<is_matcher<MatcherLHS>::value,
+            MatchAllOfGeneric<MatcherLHS, MatcherTs...>> operator && (
+                    MatcherLHS const& lhs,
+                    MatchAllOfGeneric<MatcherTs...>&& rhs) {
+                return MatchAllOfGeneric<MatcherLHS, MatcherTs...>{array_cat(static_cast<void const*>(std::addressof(lhs)), CATCH_MOVE(rhs.m_matchers))};
+            }
+        };
+
+
+        template<typename... MatcherTs>
+        class MatchAnyOfGeneric final : public MatcherGenericBase {
+        public:
+            MatchAnyOfGeneric(MatchAnyOfGeneric const&) = delete;
+            MatchAnyOfGeneric& operator=(MatchAnyOfGeneric const&) = delete;
+            MatchAnyOfGeneric(MatchAnyOfGeneric&&) = default;
+            MatchAnyOfGeneric& operator=(MatchAnyOfGeneric&&) = default;
+
+            MatchAnyOfGeneric(MatcherTs const&... matchers) : m_matchers{ {std::addressof(matchers)...} } {}
+            explicit MatchAnyOfGeneric(std::array<void const*, sizeof...(MatcherTs)> matchers) : m_matchers{matchers} {}
+
+            template<typename Arg>
+            bool match(Arg&& arg) const {
+                return match_any_of<MatcherTs...>(arg, m_matchers, std::index_sequence_for<MatcherTs...>{});
+            }
+
+            std::string describe() const override {
+                return describe_multi_matcher<MatcherTs...>(" or "_sr, m_matchers, std::index_sequence_for<MatcherTs...>{});
+            }
+
+
+            // Has to be public to enable the concatenating operators
+            // below, because they are not friend of the RHS, only LHS,
+            // and thus cannot access private fields of RHS
+            std::array<void const*, sizeof...( MatcherTs )> m_matchers;
+
+            //! Avoids type nesting for `GenericAnyOf || GenericAnyOf` case
+            template<typename... MatchersRHS>
+            friend MatchAnyOfGeneric<MatcherTs..., MatchersRHS...> operator || (
+                    MatchAnyOfGeneric<MatcherTs...>&& lhs,
+                    MatchAnyOfGeneric<MatchersRHS...>&& rhs) {
+                return MatchAnyOfGeneric<MatcherTs..., MatchersRHS...>{array_cat(CATCH_MOVE(lhs.m_matchers), CATCH_MOVE(rhs.m_matchers))};
+            }
+
+            //! Avoids type nesting for `GenericAnyOf || some matcher` case
+            template<typename MatcherRHS>
+            friend std::enable_if_t<is_matcher<MatcherRHS>::value,
+            MatchAnyOfGeneric<MatcherTs..., MatcherRHS>> operator || (
+                    MatchAnyOfGeneric<MatcherTs...>&& lhs,
+                    MatcherRHS const& rhs) {
+                return MatchAnyOfGeneric<MatcherTs..., MatcherRHS>{array_cat(CATCH_MOVE(lhs.m_matchers), static_cast<void const*>(std::addressof(rhs)))};
+            }
+
+            //! Avoids type nesting for `some matcher || GenericAnyOf` case
+            template<typename MatcherLHS>
+            friend std::enable_if_t<is_matcher<MatcherLHS>::value,
+            MatchAnyOfGeneric<MatcherLHS, MatcherTs...>> operator || (
+                MatcherLHS const& lhs,
+                MatchAnyOfGeneric<MatcherTs...>&& rhs) {
+                return MatchAnyOfGeneric<MatcherLHS, MatcherTs...>{array_cat(static_cast<void const*>(std::addressof(lhs)), CATCH_MOVE(rhs.m_matchers))};
+            }
+        };
+
+
+        template<typename MatcherT>
+        class MatchNotOfGeneric final : public MatcherGenericBase {
+            MatcherT const& m_matcher;
+
+        public:
+            MatchNotOfGeneric(MatchNotOfGeneric const&) = delete;
+            MatchNotOfGeneric& operator=(MatchNotOfGeneric const&) = delete;
+            MatchNotOfGeneric(MatchNotOfGeneric&&) = default;
+            MatchNotOfGeneric& operator=(MatchNotOfGeneric&&) = default;
+
+            explicit MatchNotOfGeneric(MatcherT const& matcher) : m_matcher{matcher} {}
+
+            template<typename Arg>
+            bool match(Arg&& arg) const {
+                return !m_matcher.match(arg);
+            }
+
+            std::string describe() const override {
+                return "not " + m_matcher.toString();
+            }
+
+            //! Negating negation can just unwrap and return underlying matcher
+            friend MatcherT const& operator ! (MatchNotOfGeneric<MatcherT> const& matcher) {
+                return matcher.m_matcher;
+            }
+        };
+    } // namespace Detail
+
+
+    // compose only generic matchers
+    template<typename MatcherLHS, typename MatcherRHS>
+    std::enable_if_t<Detail::are_generic_matchers<MatcherLHS, MatcherRHS>::value, Detail::MatchAllOfGeneric<MatcherLHS, MatcherRHS>>
+        operator && (MatcherLHS const& lhs, MatcherRHS const& rhs) {
+        return { lhs, rhs };
+    }
+
+    template<typename MatcherLHS, typename MatcherRHS>
+    std::enable_if_t<Detail::are_generic_matchers<MatcherLHS, MatcherRHS>::value, Detail::MatchAnyOfGeneric<MatcherLHS, MatcherRHS>>
+        operator || (MatcherLHS const& lhs, MatcherRHS const& rhs) {
+        return { lhs, rhs };
+    }
+
+    //! Wrap provided generic matcher in generic negator
+    template<typename MatcherT>
+    std::enable_if_t<Detail::is_generic_matcher<MatcherT>::value, Detail::MatchNotOfGeneric<MatcherT>>
+        operator ! (MatcherT const& matcher) {
+        return Detail::MatchNotOfGeneric<MatcherT>{matcher};
+    }
+
+
+    // compose mixed generic and non-generic matchers
+    template<typename MatcherLHS, typename ArgRHS>
+    std::enable_if_t<Detail::is_generic_matcher<MatcherLHS>::value, Detail::MatchAllOfGeneric<MatcherLHS, MatcherBase<ArgRHS>>>
+        operator && (MatcherLHS const& lhs, MatcherBase<ArgRHS> const& rhs) {
+        return { lhs, rhs };
+    }
+
+    template<typename ArgLHS, typename MatcherRHS>
+    std::enable_if_t<Detail::is_generic_matcher<MatcherRHS>::value, Detail::MatchAllOfGeneric<MatcherBase<ArgLHS>, MatcherRHS>>
+        operator && (MatcherBase<ArgLHS> const& lhs, MatcherRHS const& rhs) {
+        return { lhs, rhs };
+    }
+
+    template<typename MatcherLHS, typename ArgRHS>
+    std::enable_if_t<Detail::is_generic_matcher<MatcherLHS>::value, Detail::MatchAnyOfGeneric<MatcherLHS, MatcherBase<ArgRHS>>>
+        operator || (MatcherLHS const& lhs, MatcherBase<ArgRHS> const& rhs) {
+        return { lhs, rhs };
+    }
+
+    template<typename ArgLHS, typename MatcherRHS>
+    std::enable_if_t<Detail::is_generic_matcher<MatcherRHS>::value, Detail::MatchAnyOfGeneric<MatcherBase<ArgLHS>, MatcherRHS>>
+        operator || (MatcherBase<ArgLHS> const& lhs, MatcherRHS const& rhs) {
+        return { lhs, rhs };
+    }
+
+} // namespace Matchers
+} // namespace Catch
+
+#endif // CATCH_MATCHERS_TEMPLATED_HPP_INCLUDED
+
+namespace Catch {
+    namespace Matchers {
+
+        class IsEmptyMatcher final : public MatcherGenericBase {
+        public:
+            template <typename RangeLike>
+            bool match(RangeLike&& rng) const {
+#if defined(CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS)
+                using Catch::Detail::empty;
+#else
+                using std::empty;
+#endif
+                return empty(rng);
+            }
+
+            std::string describe() const override;
+        };
+
+        class HasSizeMatcher final : public MatcherGenericBase {
+            std::size_t m_target_size;
+        public:
+            explicit HasSizeMatcher(std::size_t target_size):
+                m_target_size(target_size)
+            {}
+
+            template <typename RangeLike>
+            bool match(RangeLike&& rng) const {
+#if defined(CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS)
+                using Catch::Detail::size;
+#else
+                using std::size;
+#endif
+                return size(rng) == m_target_size;
+            }
+
+            std::string describe() const override;
+        };
+
+        template <typename Matcher>
+        class SizeMatchesMatcher final : public MatcherGenericBase {
+            Matcher m_matcher;
+        public:
+            explicit SizeMatchesMatcher(Matcher m):
+                m_matcher(CATCH_MOVE(m))
+            {}
+
+            template <typename RangeLike>
+            bool match(RangeLike&& rng) const {
+#if defined(CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS)
+                using Catch::Detail::size;
+#else
+                using std::size;
+#endif
+                return m_matcher.match(size(rng));
+            }
+
+            std::string describe() const override {
+                return "size matches " + m_matcher.describe();
+            }
+        };
+
+
+        //! Creates a matcher that accepts empty ranges/containers
+        IsEmptyMatcher IsEmpty();
+        //! Creates a matcher that accepts ranges/containers with specific size
+        HasSizeMatcher SizeIs(std::size_t sz);
+        template <typename Matcher>
+        std::enable_if_t<Detail::is_matcher<Matcher>::value,
+        SizeMatchesMatcher<Matcher>> SizeIs(Matcher&& m) {
+            return SizeMatchesMatcher<Matcher>{CATCH_FORWARD(m)};
+        }
+
+    } // end namespace Matchers
+} // end namespace Catch
+
+#endif // CATCH_MATCHERS_CONTAINER_PROPERTIES_HPP_INCLUDED
+
+
+#ifndef CATCH_MATCHERS_CONTAINS_HPP_INCLUDED
+#define CATCH_MATCHERS_CONTAINS_HPP_INCLUDED
+
+
+#include <algorithm>
+#include <functional>
+
+namespace Catch {
+    namespace Matchers {
+        //! Matcher for checking that an element in range is equal to specific element
+        template <typename T, typename Equality>
+        class ContainsElementMatcher final : public MatcherGenericBase {
+            T m_desired;
+            Equality m_eq;
+        public:
+            template <typename T2, typename Equality2>
+            ContainsElementMatcher(T2&& target, Equality2&& predicate):
+                m_desired(CATCH_FORWARD(target)),
+                m_eq(CATCH_FORWARD(predicate))
+            {}
+
+            std::string describe() const override {
+                return "contains element " + Catch::Detail::stringify(m_desired);
+            }
+
+            template <typename RangeLike>
+            bool match( RangeLike&& rng ) const {
+                for ( auto&& elem : rng ) {
+                    if ( m_eq( elem, m_desired ) ) { return true; }
+                }
+                return false;
+            }
+        };
+
+        //! Meta-matcher for checking that an element in a range matches a specific matcher
+        template <typename Matcher>
+        class ContainsMatcherMatcher final : public MatcherGenericBase {
+            Matcher m_matcher;
+        public:
+            // Note that we do a copy+move to avoid having to SFINAE this
+            // constructor (and also avoid some perfect forwarding failure
+            // cases)
+            ContainsMatcherMatcher(Matcher matcher):
+                m_matcher(CATCH_MOVE(matcher))
+            {}
+
+            template <typename RangeLike>
+            bool match(RangeLike&& rng) const {
+                for (auto&& elem : rng) {
+                    if (m_matcher.match(elem)) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+
+            std::string describe() const override {
+                return "contains element matching " + m_matcher.describe();
+            }
+        };
+
+        /**
+         * Creates a matcher that checks whether a range contains a specific element.
+         *
+         * Uses `std::equal_to` to do the comparison
+         */
+        template <typename T>
+        std::enable_if_t<!Detail::is_matcher<T>::value,
+        ContainsElementMatcher<T, std::equal_to<>>> Contains(T&& elem) {
+            return { CATCH_FORWARD(elem), std::equal_to<>{} };
+        }
+
+        //! Creates a matcher that checks whether a range contains element matching a matcher
+        template <typename Matcher>
+        std::enable_if_t<Detail::is_matcher<Matcher>::value,
+        ContainsMatcherMatcher<Matcher>> Contains(Matcher&& matcher) {
+            return { CATCH_FORWARD(matcher) };
+        }
+
+        /**
+         * Creates a matcher that checks whether a range contains a specific element.
+         *
+         * Uses `eq` to do the comparisons, the element is provided on the rhs
+         */
+        template <typename T, typename Equality>
+        ContainsElementMatcher<T, Equality> Contains(T&& elem, Equality&& eq) {
+            return { CATCH_FORWARD(elem), CATCH_FORWARD(eq) };
+        }
+
+    }
+}
+
+#endif // CATCH_MATCHERS_CONTAINS_HPP_INCLUDED
+
+
+#ifndef CATCH_MATCHERS_EXCEPTION_HPP_INCLUDED
+#define CATCH_MATCHERS_EXCEPTION_HPP_INCLUDED
+
+
+namespace Catch {
+namespace Matchers {
+
+class ExceptionMessageMatcher final : public MatcherBase<std::exception> {
+    std::string m_message;
+public:
+
+    ExceptionMessageMatcher(std::string const& message):
+        m_message(message)
+    {}
+
+    bool match(std::exception const& ex) const override;
+
+    std::string describe() const override;
+};
+
+//! Creates a matcher that checks whether a std derived exception has the provided message
+ExceptionMessageMatcher Message(std::string const& message);
+
+template <typename StringMatcherType>
+class ExceptionMessageMatchesMatcher final
+    : public MatcherBase<std::exception> {
+    StringMatcherType m_matcher;
+
+public:
+    ExceptionMessageMatchesMatcher( StringMatcherType matcher ):
+        m_matcher( CATCH_MOVE( matcher ) ) {}
+
+    bool match( std::exception const& ex ) const override {
+        return m_matcher.match( ex.what() );
+    }
+
+    std::string describe() const override {
+        return " matches \"" + m_matcher.describe() + '"';
+    }
+};
+
+//! Creates a matcher that checks whether a message from an std derived
+//! exception matches a provided matcher
+template <typename StringMatcherType>
+ExceptionMessageMatchesMatcher<StringMatcherType>
+MessageMatches( StringMatcherType&& matcher ) {
+    return { CATCH_FORWARD( matcher ) };
+}
+
+} // namespace Matchers
+} // namespace Catch
+
+#endif // CATCH_MATCHERS_EXCEPTION_HPP_INCLUDED
+
+
+#ifndef CATCH_MATCHERS_FLOATING_POINT_HPP_INCLUDED
+#define CATCH_MATCHERS_FLOATING_POINT_HPP_INCLUDED
+
+
+namespace Catch {
+namespace Matchers {
+
+    namespace Detail {
+        enum class FloatingPointKind : uint8_t;
+    }
+
+    class  WithinAbsMatcher final : public MatcherBase<double> {
+    public:
+        WithinAbsMatcher(double target, double margin);
+        bool match(double const& matchee) const override;
+        std::string describe() const override;
+    private:
+        double m_target;
+        double m_margin;
+    };
+
+    //! Creates a matcher that accepts numbers within certain range of target
+    WithinAbsMatcher WithinAbs( double target, double margin );
+
+
+
+    class WithinUlpsMatcher final : public MatcherBase<double> {
+    public:
+        WithinUlpsMatcher( double target,
+                           uint64_t ulps,
+                           Detail::FloatingPointKind baseType );
+        bool match(double const& matchee) const override;
+        std::string describe() const override;
+    private:
+        double m_target;
+        uint64_t m_ulps;
+        Detail::FloatingPointKind m_type;
+    };
+
+    //! Creates a matcher that accepts doubles within certain ULP range of target
+    WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff);
+    //! Creates a matcher that accepts floats within certain ULP range of target
+    WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff);
+
+
+
+    // Given IEEE-754 format for floats and doubles, we can assume
+    // that float -> double promotion is lossless. Given this, we can
+    // assume that if we do the standard relative comparison of
+    // |lhs - rhs| <= epsilon * max(fabs(lhs), fabs(rhs)), then we get
+    // the same result if we do this for floats, as if we do this for
+    // doubles that were promoted from floats.
+    class WithinRelMatcher final : public MatcherBase<double> {
+    public:
+        WithinRelMatcher( double target, double epsilon );
+        bool match(double const& matchee) const override;
+        std::string describe() const override;
+    private:
+        double m_target;
+        double m_epsilon;
+    };
+
+    //! Creates a matcher that accepts doubles within certain relative range of target
+    WithinRelMatcher WithinRel(double target, double eps);
+    //! Creates a matcher that accepts doubles within 100*DBL_EPS relative range of target
+    WithinRelMatcher WithinRel(double target);
+    //! Creates a matcher that accepts doubles within certain relative range of target
+    WithinRelMatcher WithinRel(float target, float eps);
+    //! Creates a matcher that accepts floats within 100*FLT_EPS relative range of target
+    WithinRelMatcher WithinRel(float target);
+
+
+
+    class IsNaNMatcher final : public MatcherBase<double> {
+    public:
+        IsNaNMatcher() = default;
+        bool match( double const& matchee ) const override;
+        std::string describe() const override;
+    };
+
+    IsNaNMatcher IsNaN();
+
+} // namespace Matchers
+} // namespace Catch
+
+#endif // CATCH_MATCHERS_FLOATING_POINT_HPP_INCLUDED
+
+
+#ifndef CATCH_MATCHERS_PREDICATE_HPP_INCLUDED
+#define CATCH_MATCHERS_PREDICATE_HPP_INCLUDED
+
+
+#include <string>
+
+namespace Catch {
+namespace Matchers {
+
+namespace Detail {
+    std::string finalizeDescription(const std::string& desc);
+} // namespace Detail
+
+template <typename T, typename Predicate>
+class PredicateMatcher final : public MatcherBase<T> {
+    Predicate m_predicate;
+    std::string m_description;
+public:
+
+    PredicateMatcher(Predicate&& elem, std::string const& descr)
+        :m_predicate(CATCH_FORWARD(elem)),
+        m_description(Detail::finalizeDescription(descr))
+    {}
+
+    bool match( T const& item ) const override {
+        return m_predicate(item);
+    }
+
+    std::string describe() const override {
+        return m_description;
+    }
+};
+
+    /**
+     * Creates a matcher that calls delegates `match` to the provided predicate.
+     *
+     * The user has to explicitly specify the argument type to the matcher
+     */
+    template<typename T, typename Pred>
+    PredicateMatcher<T, Pred> Predicate(Pred&& predicate, std::string const& description = "") {
+        static_assert(is_callable<Pred(T)>::value, "Predicate not callable with argument T");
+        static_assert(std::is_same<bool, FunctionReturnType<Pred, T>>::value, "Predicate does not return bool");
+        return PredicateMatcher<T, Pred>(CATCH_FORWARD(predicate), description);
+    }
+
+} // namespace Matchers
+} // namespace Catch
+
+#endif // CATCH_MATCHERS_PREDICATE_HPP_INCLUDED
+
+
+#ifndef CATCH_MATCHERS_QUANTIFIERS_HPP_INCLUDED
+#define CATCH_MATCHERS_QUANTIFIERS_HPP_INCLUDED
+
+
+namespace Catch {
+    namespace Matchers {
+        // Matcher for checking that all elements in range matches a given matcher.
+        template <typename Matcher>
+        class AllMatchMatcher final : public MatcherGenericBase {
+            Matcher m_matcher;
+        public:
+            AllMatchMatcher(Matcher matcher):
+                m_matcher(CATCH_MOVE(matcher))
+            {}
+
+            std::string describe() const override {
+                return "all match " + m_matcher.describe();
+            }
+
+            template <typename RangeLike>
+            bool match(RangeLike&& rng) const {
+                for (auto&& elem : rng) {
+                    if (!m_matcher.match(elem)) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+        };
+
+        // Matcher for checking that no element in range matches a given matcher.
+        template <typename Matcher>
+        class NoneMatchMatcher final : public MatcherGenericBase {
+            Matcher m_matcher;
+        public:
+            NoneMatchMatcher(Matcher matcher):
+                m_matcher(CATCH_MOVE(matcher))
+            {}
+
+            std::string describe() const override {
+                return "none match " + m_matcher.describe();
+            }
+
+            template <typename RangeLike>
+            bool match(RangeLike&& rng) const {
+                for (auto&& elem : rng) {
+                    if (m_matcher.match(elem)) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+        };
+
+        // Matcher for checking that at least one element in range matches a given matcher.
+        template <typename Matcher>
+        class AnyMatchMatcher final : public MatcherGenericBase {
+            Matcher m_matcher;
+        public:
+            AnyMatchMatcher(Matcher matcher):
+                m_matcher(CATCH_MOVE(matcher))
+            {}
+
+            std::string describe() const override {
+                return "any match " + m_matcher.describe();
+            }
+
+            template <typename RangeLike>
+            bool match(RangeLike&& rng) const {
+                for (auto&& elem : rng) {
+                    if (m_matcher.match(elem)) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+        };
+
+        // Matcher for checking that all elements in range are true.
+        class AllTrueMatcher final : public MatcherGenericBase {
+        public:
+            std::string describe() const override;
+
+            template <typename RangeLike>
+            bool match(RangeLike&& rng) const {
+                for (auto&& elem : rng) {
+                    if (!elem) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+        };
+
+        // Matcher for checking that no element in range is true.
+        class NoneTrueMatcher final : public MatcherGenericBase {
+        public:
+            std::string describe() const override;
+
+            template <typename RangeLike>
+            bool match(RangeLike&& rng) const {
+                for (auto&& elem : rng) {
+                    if (elem) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+        };
+
+        // Matcher for checking that any element in range is true.
+        class AnyTrueMatcher final : public MatcherGenericBase {
+        public:
+            std::string describe() const override;
+
+            template <typename RangeLike>
+            bool match(RangeLike&& rng) const {
+                for (auto&& elem : rng) {
+                    if (elem) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+        };
+
+        // Creates a matcher that checks whether all elements in a range match a matcher
+        template <typename Matcher>
+        AllMatchMatcher<Matcher> AllMatch(Matcher&& matcher) {
+            return { CATCH_FORWARD(matcher) };
+        }
+
+        // Creates a matcher that checks whether no element in a range matches a matcher.
+        template <typename Matcher>
+        NoneMatchMatcher<Matcher> NoneMatch(Matcher&& matcher) {
+            return { CATCH_FORWARD(matcher) };
+        }
+
+        // Creates a matcher that checks whether any element in a range matches a matcher.
+        template <typename Matcher>
+        AnyMatchMatcher<Matcher> AnyMatch(Matcher&& matcher) {
+            return { CATCH_FORWARD(matcher) };
+        }
+
+        // Creates a matcher that checks whether all elements in a range are true
+        AllTrueMatcher AllTrue();
+
+        // Creates a matcher that checks whether no element in a range is true
+        NoneTrueMatcher NoneTrue();
+
+        // Creates a matcher that checks whether any element in a range is true
+        AnyTrueMatcher AnyTrue();
+    }
+}
+
+#endif // CATCH_MATCHERS_QUANTIFIERS_HPP_INCLUDED
+
+
+#ifndef CATCH_MATCHERS_RANGE_EQUALS_HPP_INCLUDED
+#define CATCH_MATCHERS_RANGE_EQUALS_HPP_INCLUDED
+
+
+#include <algorithm>
+#include <utility>
+
+namespace Catch {
+    namespace Matchers {
+
+        /**
+         * Matcher for checking that an element contains the same
+         * elements in the same order
+         */
+        template <typename TargetRangeLike, typename Equality>
+        class RangeEqualsMatcher final : public MatcherGenericBase {
+            TargetRangeLike m_desired;
+            Equality m_predicate;
+
+        public:
+            template <typename TargetRangeLike2, typename Equality2>
+            constexpr
+            RangeEqualsMatcher( TargetRangeLike2&& range,
+                                Equality2&& predicate ):
+                m_desired( CATCH_FORWARD( range ) ),
+                m_predicate( CATCH_FORWARD( predicate ) ) {}
+
+            template <typename RangeLike>
+            constexpr
+            bool match( RangeLike&& rng ) const {
+                auto rng_start = begin( rng );
+                const auto rng_end = end( rng );
+                auto target_start = begin( m_desired );
+                const auto target_end = end( m_desired );
+
+                while (rng_start != rng_end && target_start != target_end) {
+                    if (!m_predicate(*rng_start, *target_start)) {
+                        return false;
+                    }
+                    ++rng_start;
+                    ++target_start;
+                }
+                return rng_start == rng_end && target_start == target_end;
+            }
+
+            std::string describe() const override {
+                return "elements are " + Catch::Detail::stringify( m_desired );
+            }
+        };
+
+        /**
+         * Matcher for checking that an element contains the same
+         * elements (but not necessarily in the same order)
+         */
+        template <typename TargetRangeLike, typename Equality>
+        class UnorderedRangeEqualsMatcher final : public MatcherGenericBase {
+            TargetRangeLike m_desired;
+            Equality m_predicate;
+
+        public:
+            template <typename TargetRangeLike2, typename Equality2>
+            constexpr
+            UnorderedRangeEqualsMatcher( TargetRangeLike2&& range,
+                                         Equality2&& predicate ):
+                m_desired( CATCH_FORWARD( range ) ),
+                m_predicate( CATCH_FORWARD( predicate ) ) {}
+
+            template <typename RangeLike>
+            constexpr
+            bool match( RangeLike&& rng ) const {
+                using std::begin;
+                using std::end;
+                return Catch::Detail::is_permutation( begin( m_desired ),
+                                                      end( m_desired ),
+                                                      begin( rng ),
+                                                      end( rng ),
+                                                      m_predicate );
+            }
+
+            std::string describe() const override {
+                return "unordered elements are " +
+                       ::Catch::Detail::stringify( m_desired );
+            }
+        };
+
+        /**
+         * Creates a matcher that checks if all elements in a range are equal
+         * to all elements in another range.
+         *
+         * Uses `std::equal_to` to do the comparison
+         */
+        template <typename RangeLike>
+        constexpr
+        std::enable_if_t<!Detail::is_matcher<RangeLike>::value,
+                         RangeEqualsMatcher<RangeLike, std::equal_to<>>>
+        RangeEquals( RangeLike&& range ) {
+            return { CATCH_FORWARD( range ), std::equal_to<>{} };
+        }
+
+        /**
+         * Creates a matcher that checks if all elements in a range are equal
+         * to all elements in another range.
+         *
+         * Uses to provided predicate `predicate` to do the comparisons
+         */
+        template <typename RangeLike, typename Equality>
+        constexpr
+        RangeEqualsMatcher<RangeLike, Equality>
+        RangeEquals( RangeLike&& range, Equality&& predicate ) {
+            return { CATCH_FORWARD( range ), CATCH_FORWARD( predicate ) };
+        }
+
+        /**
+         * Creates a matcher that checks if all elements in a range are equal
+         * to all elements in another range, in some permutation
+         *
+         * Uses `std::equal_to` to do the comparison
+         */
+        template <typename RangeLike>
+        constexpr
+        std::enable_if_t<
+            !Detail::is_matcher<RangeLike>::value,
+            UnorderedRangeEqualsMatcher<RangeLike, std::equal_to<>>>
+        UnorderedRangeEquals( RangeLike&& range ) {
+            return { CATCH_FORWARD( range ), std::equal_to<>{} };
+        }
+
+        /**
+         * Creates a matcher that checks if all elements in a range are equal
+         * to all elements in another range, in some permutation.
+         *
+         * Uses to provided predicate `predicate` to do the comparisons
+         */
+        template <typename RangeLike, typename Equality>
+        constexpr
+        UnorderedRangeEqualsMatcher<RangeLike, Equality>
+        UnorderedRangeEquals( RangeLike&& range, Equality&& predicate ) {
+            return { CATCH_FORWARD( range ), CATCH_FORWARD( predicate ) };
+        }
+    } // namespace Matchers
+} // namespace Catch
+
+#endif // CATCH_MATCHERS_RANGE_EQUALS_HPP_INCLUDED
+
+
+#ifndef CATCH_MATCHERS_STRING_HPP_INCLUDED
+#define CATCH_MATCHERS_STRING_HPP_INCLUDED
+
+
+#include <string>
+
+namespace Catch {
+namespace Matchers {
+
+    struct CasedString {
+        CasedString( std::string const& str, CaseSensitive caseSensitivity );
+        std::string adjustString( std::string const& str ) const;
+        StringRef caseSensitivitySuffix() const;
+
+        CaseSensitive m_caseSensitivity;
+        std::string m_str;
+    };
+
+    class StringMatcherBase : public MatcherBase<std::string> {
+    protected:
+        CasedString m_comparator;
+        StringRef m_operation;
+
+    public:
+        StringMatcherBase( StringRef operation,
+                           CasedString const& comparator );
+        std::string describe() const override;
+    };
+
+    class StringEqualsMatcher final : public StringMatcherBase {
+    public:
+        StringEqualsMatcher( CasedString const& comparator );
+        bool match( std::string const& source ) const override;
+    };
+    class StringContainsMatcher final : public StringMatcherBase {
+    public:
+        StringContainsMatcher( CasedString const& comparator );
+        bool match( std::string const& source ) const override;
+    };
+    class StartsWithMatcher final : public StringMatcherBase {
+    public:
+        StartsWithMatcher( CasedString const& comparator );
+        bool match( std::string const& source ) const override;
+    };
+    class EndsWithMatcher final : public StringMatcherBase {
+    public:
+        EndsWithMatcher( CasedString const& comparator );
+        bool match( std::string const& source ) const override;
+    };
+
+    class RegexMatcher final : public MatcherBase<std::string> {
+        std::string m_regex;
+        CaseSensitive m_caseSensitivity;
+
+    public:
+        RegexMatcher( std::string regex, CaseSensitive caseSensitivity );
+        bool match( std::string const& matchee ) const override;
+        std::string describe() const override;
+    };
+
+    //! Creates matcher that accepts strings that are exactly equal to `str`
+    StringEqualsMatcher Equals( std::string const& str, CaseSensitive caseSensitivity = CaseSensitive::Yes );
+    //! Creates matcher that accepts strings that contain `str`
+    StringContainsMatcher ContainsSubstring( std::string const& str, CaseSensitive caseSensitivity = CaseSensitive::Yes );
+    //! Creates matcher that accepts strings that _end_ with `str`
+    EndsWithMatcher EndsWith( std::string const& str, CaseSensitive caseSensitivity = CaseSensitive::Yes );
+    //! Creates matcher that accepts strings that _start_ with `str`
+    StartsWithMatcher StartsWith( std::string const& str, CaseSensitive caseSensitivity = CaseSensitive::Yes );
+    //! Creates matcher that accepts strings matching `regex`
+    RegexMatcher Matches( std::string const& regex, CaseSensitive caseSensitivity = CaseSensitive::Yes );
+
+} // namespace Matchers
+} // namespace Catch
+
+#endif // CATCH_MATCHERS_STRING_HPP_INCLUDED
+
+
+#ifndef CATCH_MATCHERS_VECTOR_HPP_INCLUDED
+#define CATCH_MATCHERS_VECTOR_HPP_INCLUDED
+
+
+#include <algorithm>
+
+namespace Catch {
+namespace Matchers {
+
+    template<typename T, typename Alloc>
+    class VectorContainsElementMatcher final : public MatcherBase<std::vector<T, Alloc>> {
+        T const& m_comparator;
+
+    public:
+        VectorContainsElementMatcher(T const& comparator):
+            m_comparator(comparator)
+        {}
+
+        bool match(std::vector<T, Alloc> const& v) const override {
+            for (auto const& el : v) {
+                if (el == m_comparator) {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        std::string describe() const override {
+            return "Contains: " + ::Catch::Detail::stringify( m_comparator );
+        }
+    };
+
+    template<typename T, typename AllocComp, typename AllocMatch>
+    class ContainsMatcher final : public MatcherBase<std::vector<T, AllocMatch>> {
+        std::vector<T, AllocComp> const& m_comparator;
+
+    public:
+        ContainsMatcher(std::vector<T, AllocComp> const& comparator):
+            m_comparator( comparator )
+        {}
+
+        bool match(std::vector<T, AllocMatch> const& v) const override {
+            // !TBD: see note in EqualsMatcher
+            if (m_comparator.size() > v.size())
+                return false;
+            for (auto const& comparator : m_comparator) {
+                auto present = false;
+                for (const auto& el : v) {
+                    if (el == comparator) {
+                        present = true;
+                        break;
+                    }
+                }
+                if (!present) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        std::string describe() const override {
+            return "Contains: " + ::Catch::Detail::stringify( m_comparator );
+        }
+    };
+
+    template<typename T, typename AllocComp, typename AllocMatch>
+    class EqualsMatcher final : public MatcherBase<std::vector<T, AllocMatch>> {
+        std::vector<T, AllocComp> const& m_comparator;
+
+    public:
+        EqualsMatcher(std::vector<T, AllocComp> const& comparator):
+            m_comparator( comparator )
+        {}
+
+        bool match(std::vector<T, AllocMatch> const& v) const override {
+            // !TBD: This currently works if all elements can be compared using !=
+            // - a more general approach would be via a compare template that defaults
+            // to using !=. but could be specialised for, e.g. std::vector<T> etc
+            // - then just call that directly
+            if ( m_comparator.size() != v.size() ) { return false; }
+            for ( std::size_t i = 0; i < v.size(); ++i ) {
+                if ( !( m_comparator[i] == v[i] ) ) { return false; }
+            }
+            return true;
+        }
+        std::string describe() const override {
+            return "Equals: " + ::Catch::Detail::stringify( m_comparator );
+        }
+    };
+
+    template<typename T, typename AllocComp, typename AllocMatch>
+    class ApproxMatcher final : public MatcherBase<std::vector<T, AllocMatch>> {
+        std::vector<T, AllocComp> const& m_comparator;
+        mutable Catch::Approx approx = Catch::Approx::custom();
+
+    public:
+        ApproxMatcher(std::vector<T, AllocComp> const& comparator):
+            m_comparator( comparator )
+        {}
+
+        bool match(std::vector<T, AllocMatch> const& v) const override {
+            if (m_comparator.size() != v.size())
+                return false;
+            for (std::size_t i = 0; i < v.size(); ++i)
+                if (m_comparator[i] != approx(v[i]))
+                    return false;
+            return true;
+        }
+        std::string describe() const override {
+            return "is approx: " + ::Catch::Detail::stringify( m_comparator );
+        }
+        template <typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+        ApproxMatcher& epsilon( T const& newEpsilon ) {
+            approx.epsilon(static_cast<double>(newEpsilon));
+            return *this;
+        }
+        template <typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+        ApproxMatcher& margin( T const& newMargin ) {
+            approx.margin(static_cast<double>(newMargin));
+            return *this;
+        }
+        template <typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+        ApproxMatcher& scale( T const& newScale ) {
+            approx.scale(static_cast<double>(newScale));
+            return *this;
+        }
+    };
+
+    template<typename T, typename AllocComp, typename AllocMatch>
+    class UnorderedEqualsMatcher final : public MatcherBase<std::vector<T, AllocMatch>> {
+        std::vector<T, AllocComp> const& m_target;
+
+    public:
+        UnorderedEqualsMatcher(std::vector<T, AllocComp> const& target):
+            m_target(target)
+        {}
+        bool match(std::vector<T, AllocMatch> const& vec) const override {
+            if (m_target.size() != vec.size()) {
+                return false;
+            }
+            return std::is_permutation(m_target.begin(), m_target.end(), vec.begin());
+        }
+
+        std::string describe() const override {
+            return "UnorderedEquals: " + ::Catch::Detail::stringify(m_target);
+        }
+    };
+
+
+    // The following functions create the actual matcher objects.
+    // This allows the types to be inferred
+
+    //! Creates a matcher that matches vectors that contain all elements in `comparator`
+    template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
+    ContainsMatcher<T, AllocComp, AllocMatch> Contains( std::vector<T, AllocComp> const& comparator ) {
+        return ContainsMatcher<T, AllocComp, AllocMatch>(comparator);
+    }
+
+    //! Creates a matcher that matches vectors that contain `comparator` as an element
+    template<typename T, typename Alloc = std::allocator<T>>
+    VectorContainsElementMatcher<T, Alloc> VectorContains( T const& comparator ) {
+        return VectorContainsElementMatcher<T, Alloc>(comparator);
+    }
+
+    //! Creates a matcher that matches vectors that are exactly equal to `comparator`
+    template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
+    EqualsMatcher<T, AllocComp, AllocMatch> Equals( std::vector<T, AllocComp> const& comparator ) {
+        return EqualsMatcher<T, AllocComp, AllocMatch>(comparator);
+    }
+
+    //! Creates a matcher that matches vectors that `comparator` as an element
+    template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
+    ApproxMatcher<T, AllocComp, AllocMatch> Approx( std::vector<T, AllocComp> const& comparator ) {
+        return ApproxMatcher<T, AllocComp, AllocMatch>(comparator);
+    }
+
+    //! Creates a matcher that matches vectors that is equal to `target` modulo permutation
+    template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
+    UnorderedEqualsMatcher<T, AllocComp, AllocMatch> UnorderedEquals(std::vector<T, AllocComp> const& target) {
+        return UnorderedEqualsMatcher<T, AllocComp, AllocMatch>(target);
+    }
+
+} // namespace Matchers
+} // namespace Catch
+
+#endif // CATCH_MATCHERS_VECTOR_HPP_INCLUDED
+
+#endif // CATCH_MATCHERS_ALL_HPP_INCLUDED
+
+
+/** \file
+ * This is a convenience header for Catch2's Reporter support. It includes
+ * **all** of Catch2 headers related to reporters, including all reporters.
+ *
+ * Generally the Catch2 users should use specific includes they need,
+ * but this header can be used instead for ease-of-experimentation, or
+ * just plain convenience, at the cost of (significantly) increased
+ * compilation times.
+ *
+ * When a new header (reporter) is added to either the `reporter` folder,
+ * or to the corresponding internal subfolder, it should be added here.
+ */
+
+#ifndef CATCH_REPORTERS_ALL_HPP_INCLUDED
+#define CATCH_REPORTERS_ALL_HPP_INCLUDED
+
+
+
+#ifndef CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
+#define CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
+
+
+
+#ifndef CATCH_REPORTER_STREAMING_BASE_HPP_INCLUDED
+#define CATCH_REPORTER_STREAMING_BASE_HPP_INCLUDED
+
+
+
+#ifndef CATCH_REPORTER_COMMON_BASE_HPP_INCLUDED
+#define CATCH_REPORTER_COMMON_BASE_HPP_INCLUDED
+
+
+#include <map>
+#include <string>
+
+namespace Catch {
+    class ColourImpl;
+
+    /**
+     * This is the base class for all reporters.
+     *
+     * If are writing a reporter, you must derive from this type, or one
+     * of the helper reporter bases that are derived from this type.
+     *
+     * ReporterBase centralizes handling of various common tasks in reporters,
+     * like storing the right stream for the reporters to write to, and
+     * providing the default implementation of the different listing events.
+     */
+    class ReporterBase : public IEventListener {
+    protected:
+        //! The stream wrapper as passed to us by outside code
+        Detail::unique_ptr<IStream> m_wrapped_stream;
+        //! Cached output stream from `m_wrapped_stream` to reduce
+        //! number of indirect calls needed to write output.
+        std::ostream& m_stream;
+        //! Colour implementation this reporter was configured for
+        Detail::unique_ptr<ColourImpl> m_colour;
+        //! The custom reporter options user passed down to the reporter
+        std::map<std::string, std::string> m_customOptions;
+
+    public:
+        ReporterBase( ReporterConfig&& config );
+        ~ReporterBase() override; // = default;
+
+        /**
+         * Provides a simple default listing of reporters.
+         *
+         * Should look roughly like the reporter listing in v2 and earlier
+         * versions of Catch2.
+         */
+        void listReporters(
+            std::vector<ReporterDescription> const& descriptions ) override;
+        /**
+         * Provides a simple default listing of listeners
+         *
+         * Looks similarly to listing of reporters, but with listener type
+         * instead of reporter name.
+         */
+        void listListeners(
+            std::vector<ListenerDescription> const& descriptions ) override;
+        /**
+         * Provides a simple default listing of tests.
+         *
+         * Should look roughly like the test listing in v2 and earlier versions
+         * of Catch2. Especially supports low-verbosity listing that mimics the
+         * old `--list-test-names-only` output.
+         */
+        void listTests( std::vector<TestCaseHandle> const& tests ) override;
+        /**
+         * Provides a simple default listing of tags.
+         *
+         * Should look roughly like the tag listing in v2 and earlier versions
+         * of Catch2.
+         */
+        void listTags( std::vector<TagInfo> const& tags ) override;
+    };
+} // namespace Catch
+
+#endif // CATCH_REPORTER_COMMON_BASE_HPP_INCLUDED
+
+#include <vector>
+
+namespace Catch {
+
+    class StreamingReporterBase : public ReporterBase {
+    public:
+        // GCC5 compat: we cannot use inherited constructor, because it
+        //              doesn't implement backport of P0136
+        StreamingReporterBase(ReporterConfig&& _config):
+            ReporterBase(CATCH_MOVE(_config))
+        {}
+        ~StreamingReporterBase() override;
+
+        void benchmarkPreparing( StringRef ) override {}
+        void benchmarkStarting( BenchmarkInfo const& ) override {}
+        void benchmarkEnded( BenchmarkStats<> const& ) override {}
+        void benchmarkFailed( StringRef ) override {}
+
+        void fatalErrorEncountered( StringRef /*error*/ ) override {}
+        void noMatchingTestCases( StringRef /*unmatchedSpec*/ ) override {}
+        void reportInvalidTestSpec( StringRef /*invalidArgument*/ ) override {}
+
+        void testRunStarting( TestRunInfo const& _testRunInfo ) override;
+
+        void testCaseStarting(TestCaseInfo const& _testInfo) override  {
+            currentTestCaseInfo = &_testInfo;
+        }
+        void testCasePartialStarting( TestCaseInfo const&, uint64_t ) override {}
+        void sectionStarting(SectionInfo const& _sectionInfo) override {
+            m_sectionStack.push_back(_sectionInfo);
+        }
+
+        void assertionStarting( AssertionInfo const& ) override {}
+        void assertionEnded( AssertionStats const& ) override {}
+
+        void sectionEnded(SectionStats const& /* _sectionStats */) override {
+            m_sectionStack.pop_back();
+        }
+        void testCasePartialEnded( TestCaseStats const&, uint64_t ) override {}
+        void testCaseEnded(TestCaseStats const& /* _testCaseStats */) override {
+            currentTestCaseInfo = nullptr;
+        }
+        void testRunEnded( TestRunStats const& /* _testRunStats */ ) override;
+
+        void skipTest(TestCaseInfo const&) override {
+            // Don't do anything with this by default.
+            // It can optionally be overridden in the derived class.
+        }
+
+    protected:
+        TestRunInfo currentTestRunInfo{ "test run has not started yet"_sr };
+        TestCaseInfo const* currentTestCaseInfo = nullptr;
+
+        //! Stack of all _active_ sections in the _current_ test case
+        std::vector<SectionInfo> m_sectionStack;
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_REPORTER_STREAMING_BASE_HPP_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+    class AutomakeReporter final : public StreamingReporterBase {
+    public:
+        // GCC5 compat: we cannot use inherited constructor, because it
+        //              doesn't implement backport of P0136
+        AutomakeReporter(ReporterConfig&& _config):
+            StreamingReporterBase(CATCH_MOVE(_config))
+        {}
+        ~AutomakeReporter() override;
+
+        static std::string getDescription() {
+            using namespace std::string_literals;
+            return "Reports test results in the format of Automake .trs files"s;
+        }
+
+        void testCaseEnded(TestCaseStats const& _testCaseStats) override;
+        void skipTest(TestCaseInfo const& testInfo) override;
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
+
+
+#ifndef CATCH_REPORTER_COMPACT_HPP_INCLUDED
+#define CATCH_REPORTER_COMPACT_HPP_INCLUDED
+
+
+
+
+namespace Catch {
+
+    class CompactReporter final : public StreamingReporterBase {
+    public:
+        using StreamingReporterBase::StreamingReporterBase;
+
+        ~CompactReporter() override;
+
+        static std::string getDescription();
+
+        void noMatchingTestCases( StringRef unmatchedSpec ) override;
+
+        void testRunStarting( TestRunInfo const& _testInfo ) override;
+
+        void assertionEnded(AssertionStats const& _assertionStats) override;
+
+        void sectionEnded(SectionStats const& _sectionStats) override;
+
+        void testRunEnded(TestRunStats const& _testRunStats) override;
+
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_REPORTER_COMPACT_HPP_INCLUDED
+
+
+#ifndef CATCH_REPORTER_CONSOLE_HPP_INCLUDED
+#define CATCH_REPORTER_CONSOLE_HPP_INCLUDED
+
+
+namespace Catch {
+    // Fwd decls
+    class TablePrinter;
+
+    class ConsoleReporter final : public StreamingReporterBase {
+        Detail::unique_ptr<TablePrinter> m_tablePrinter;
+
+    public:
+        ConsoleReporter(ReporterConfig&& config);
+        ~ConsoleReporter() override;
+        static std::string getDescription();
+
+        void noMatchingTestCases( StringRef unmatchedSpec ) override;
+        void reportInvalidTestSpec( StringRef arg ) override;
+
+        void assertionStarting(AssertionInfo const&) override;
+
+        void assertionEnded(AssertionStats const& _assertionStats) override;
+
+        void sectionStarting(SectionInfo const& _sectionInfo) override;
+        void sectionEnded(SectionStats const& _sectionStats) override;
+
+        void benchmarkPreparing( StringRef name ) override;
+        void benchmarkStarting(BenchmarkInfo const& info) override;
+        void benchmarkEnded(BenchmarkStats<> const& stats) override;
+        void benchmarkFailed( StringRef error ) override;
+
+        void testCaseEnded(TestCaseStats const& _testCaseStats) override;
+        void testRunEnded(TestRunStats const& _testRunStats) override;
+        void testRunStarting(TestRunInfo const& _testRunInfo) override;
+
+    private:
+        void lazyPrint();
+
+        void lazyPrintWithoutClosingBenchmarkTable();
+        void lazyPrintRunInfo();
+        void printTestCaseAndSectionHeader();
+
+        void printClosedHeader(std::string const& _name);
+        void printOpenHeader(std::string const& _name);
+
+        // if string has a : in first line will set indent to follow it on
+        // subsequent lines
+        void printHeaderString(std::string const& _string, std::size_t indent = 0);
+
+        void printTotalsDivider(Totals const& totals);
+
+        bool m_headerPrinted = false;
+        bool m_testRunInfoPrinted = false;
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_REPORTER_CONSOLE_HPP_INCLUDED
+
+
+#ifndef CATCH_REPORTER_CUMULATIVE_BASE_HPP_INCLUDED
+#define CATCH_REPORTER_CUMULATIVE_BASE_HPP_INCLUDED
+
+
+#include <string>
+#include <vector>
+
+namespace Catch {
+
+    namespace Detail {
+
+        //! Represents either an assertion or a benchmark result to be handled by cumulative reporter later
+        class AssertionOrBenchmarkResult {
+            // This should really be a variant, but this is much faster
+            // to write and the data layout here is already terrible
+            // enough that we do not have to care about the object size.
+            Optional<AssertionStats> m_assertion;
+            Optional<BenchmarkStats<>> m_benchmark;
+        public:
+            AssertionOrBenchmarkResult(AssertionStats const& assertion);
+            AssertionOrBenchmarkResult(BenchmarkStats<> const& benchmark);
+
+            bool isAssertion() const;
+            bool isBenchmark() const;
+
+            AssertionStats const& asAssertion() const;
+            BenchmarkStats<> const& asBenchmark() const;
+        };
+    }
+
+    /**
+     * Utility base for reporters that need to handle all results at once
+     *
+     * It stores tree of all test cases, sections and assertions, and after the
+     * test run is finished, calls into `testRunEndedCumulative` to pass the
+     * control to the deriving class.
+     *
+     * If you are deriving from this class and override any testing related
+     * member functions, you should first call into the base's implementation to
+     * avoid breaking the tree construction.
+     *
+     * Due to the way this base functions, it has to expand assertions up-front,
+     * even if they are later unused (e.g. because the deriving reporter does
+     * not report successful assertions, or because the deriving reporter does
+     * not use assertion expansion at all). Derived classes can use two
+     * customization points, `m_shouldStoreSuccesfulAssertions` and
+     * `m_shouldStoreFailedAssertions`, to disable the expansion and gain extra
+     * performance. **Accessing the assertion expansions if it wasn't stored is
+     * UB.**
+     */
+    class CumulativeReporterBase : public ReporterBase {
+    public:
+        template<typename T, typename ChildNodeT>
+        struct Node {
+            explicit Node( T const& _value ) : value( _value ) {}
+
+            using ChildNodes = std::vector<Detail::unique_ptr<ChildNodeT>>;
+            T value;
+            ChildNodes children;
+        };
+        struct SectionNode {
+            explicit SectionNode(SectionStats const& _stats) : stats(_stats) {}
+
+            bool operator == (SectionNode const& other) const {
+                return stats.sectionInfo.lineInfo == other.stats.sectionInfo.lineInfo;
+            }
+
+            bool hasAnyAssertions() const;
+
+            SectionStats stats;
+            std::vector<Detail::unique_ptr<SectionNode>> childSections;
+            std::vector<Detail::AssertionOrBenchmarkResult> assertionsAndBenchmarks;
+            std::string stdOut;
+            std::string stdErr;
+        };
+
+
+        using TestCaseNode = Node<TestCaseStats, SectionNode>;
+        using TestRunNode = Node<TestRunStats, TestCaseNode>;
+
+        // GCC5 compat: we cannot use inherited constructor, because it
+        //              doesn't implement backport of P0136
+        CumulativeReporterBase(ReporterConfig&& _config):
+            ReporterBase(CATCH_MOVE(_config))
+        {}
+        ~CumulativeReporterBase() override;
+
+        void benchmarkPreparing( StringRef ) override {}
+        void benchmarkStarting( BenchmarkInfo const& ) override {}
+        void benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) override;
+        void benchmarkFailed( StringRef ) override {}
+
+        void noMatchingTestCases( StringRef ) override {}
+        void reportInvalidTestSpec( StringRef ) override {}
+        void fatalErrorEncountered( StringRef /*error*/ ) override {}
+
+        void testRunStarting( TestRunInfo const& ) override {}
+
+        void testCaseStarting( TestCaseInfo const& ) override {}
+        void testCasePartialStarting( TestCaseInfo const&, uint64_t ) override {}
+        void sectionStarting( SectionInfo const& sectionInfo ) override;
+
+        void assertionStarting( AssertionInfo const& ) override {}
+
+        void assertionEnded( AssertionStats const& assertionStats ) override;
+        void sectionEnded( SectionStats const& sectionStats ) override;
+        void testCasePartialEnded( TestCaseStats const&, uint64_t ) override {}
+        void testCaseEnded( TestCaseStats const& testCaseStats ) override;
+        void testRunEnded( TestRunStats const& testRunStats ) override;
+        //! Customization point: called after last test finishes (testRunEnded has been handled)
+        virtual void testRunEndedCumulative() = 0;
+
+        void skipTest(TestCaseInfo const&) override {}
+
+    protected:
+        //! Should the cumulative base store the assertion expansion for successful assertions?
+        bool m_shouldStoreSuccesfulAssertions = true;
+        //! Should the cumulative base store the assertion expansion for failed assertions?
+        bool m_shouldStoreFailedAssertions = true;
+
+        // We need lazy construction here. We should probably refactor it
+        // later, after the events are redone.
+        //! The root node of the test run tree.
+        Detail::unique_ptr<TestRunNode> m_testRun;
+
+    private:
+        // Note: We rely on pointer identity being stable, which is why
+        //       we store pointers to the nodes rather than the values.
+        std::vector<Detail::unique_ptr<TestCaseNode>> m_testCases;
+        // Root section of the _current_ test case
+        Detail::unique_ptr<SectionNode> m_rootSection;
+        // Deepest section of the _current_ test case
+        SectionNode* m_deepestSection = nullptr;
+        // Stack of _active_ sections in the _current_ test case
+        std::vector<SectionNode*> m_sectionStack;
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_REPORTER_CUMULATIVE_BASE_HPP_INCLUDED
+
+
+#ifndef CATCH_REPORTER_EVENT_LISTENER_HPP_INCLUDED
+#define CATCH_REPORTER_EVENT_LISTENER_HPP_INCLUDED
+
+
+namespace Catch {
+
+    /**
+     * Base class to simplify implementing listeners.
+     *
+     * Provides empty default implementation for all IEventListener member
+     * functions, so that a listener implementation can pick which
+     * member functions it actually cares about.
+     */
+    class EventListenerBase : public IEventListener {
+    public:
+        using IEventListener::IEventListener;
+
+        void reportInvalidTestSpec( StringRef unmatchedSpec ) override;
+        void fatalErrorEncountered( StringRef error ) override;
+
+        void benchmarkPreparing( StringRef name ) override;
+        void benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) override;
+        void benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) override;
+        void benchmarkFailed( StringRef error ) override;
+
+        void assertionStarting( AssertionInfo const& assertionInfo ) override;
+        void assertionEnded( AssertionStats const& assertionStats ) override;
+
+        void listReporters(
+            std::vector<ReporterDescription> const& descriptions ) override;
+        void listListeners(
+            std::vector<ListenerDescription> const& descriptions ) override;
+        void listTests( std::vector<TestCaseHandle> const& tests ) override;
+        void listTags( std::vector<TagInfo> const& tagInfos ) override;
+
+        void noMatchingTestCases( StringRef unmatchedSpec ) override;
+        void testRunStarting( TestRunInfo const& testRunInfo ) override;
+        void testCaseStarting( TestCaseInfo const& testInfo ) override;
+        void testCasePartialStarting( TestCaseInfo const& testInfo,
+                                      uint64_t partNumber ) override;
+        void sectionStarting( SectionInfo const& sectionInfo ) override;
+        void sectionEnded( SectionStats const& sectionStats ) override;
+        void testCasePartialEnded( TestCaseStats const& testCaseStats,
+                                   uint64_t partNumber ) override;
+        void testCaseEnded( TestCaseStats const& testCaseStats ) override;
+        void testRunEnded( TestRunStats const& testRunStats ) override;
+        void skipTest( TestCaseInfo const& testInfo ) override;
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_REPORTER_EVENT_LISTENER_HPP_INCLUDED
+
+
+#ifndef CATCH_REPORTER_HELPERS_HPP_INCLUDED
+#define CATCH_REPORTER_HELPERS_HPP_INCLUDED
+
+#include <iosfwd>
+#include <string>
+#include <vector>
+
+
+namespace Catch {
+
+    class IConfig;
+    class TestCaseHandle;
+    class ColourImpl;
+
+    // Returns double formatted as %.3f (format expected on output)
+    std::string getFormattedDuration( double duration );
+
+    //! Should the reporter show duration of test given current configuration?
+    bool shouldShowDuration( IConfig const& config, double duration );
+
+    std::string serializeFilters( std::vector<std::string> const& filters );
+
+    struct lineOfChars {
+        char c;
+        constexpr lineOfChars( char c_ ): c( c_ ) {}
+
+        friend std::ostream& operator<<( std::ostream& out, lineOfChars value );
+    };
+
+    /**
+     * Lists reporter descriptions to the provided stream in user-friendly
+     * format
+     *
+     * Used as the default listing implementation by the first party reporter
+     * bases. The output should be backwards compatible with the output of
+     * Catch2 v2 binaries.
+     */
+    void
+    defaultListReporters( std::ostream& out,
+                          std::vector<ReporterDescription> const& descriptions,
+                          Verbosity verbosity );
+
+    /**
+     * Lists listeners descriptions to the provided stream in user-friendly
+     * format
+     */
+    void defaultListListeners( std::ostream& out,
+                               std::vector<ListenerDescription> const& descriptions );
+
+    /**
+     * Lists tag information to the provided stream in user-friendly format
+     *
+     * Used as the default listing implementation by the first party reporter
+     * bases. The output should be backwards compatible with the output of
+     * Catch2 v2 binaries.
+     */
+    void defaultListTags( std::ostream& out, std::vector<TagInfo> const& tags, bool isFiltered );
+
+    /**
+     * Lists test case information to the provided stream in user-friendly
+     * format
+     *
+     * Used as the default listing implementation by the first party reporter
+     * bases. The output is backwards compatible with the output of Catch2
+     * v2 binaries, and also supports the format specific to the old
+     * `--list-test-names-only` option, for people who used it in integrations.
+     */
+    void defaultListTests( std::ostream& out,
+                           ColourImpl* streamColour,
+                           std::vector<TestCaseHandle> const& tests,
+                           bool isFiltered,
+                           Verbosity verbosity );
+
+    /**
+     * Prints test run totals to the provided stream in user-friendly format
+     *
+     * Used by the console and compact reporters.
+     */
+    void printTestRunTotals( std::ostream& stream,
+                      ColourImpl& streamColour,
+                      Totals const& totals );
+
+} // end namespace Catch
+
+#endif // CATCH_REPORTER_HELPERS_HPP_INCLUDED
+
+
+
+#ifndef CATCH_REPORTER_JSON_HPP_INCLUDED
+#define CATCH_REPORTER_JSON_HPP_INCLUDED
+
+
+#include <stack>
+
+namespace Catch {
+    class JsonReporter : public StreamingReporterBase {
+    public:
+        JsonReporter( ReporterConfig&& config );
+
+        ~JsonReporter() override;
+
+        static std::string getDescription();
+
+    public: // StreamingReporterBase
+        void testRunStarting( TestRunInfo const& runInfo ) override;
+        void testRunEnded( TestRunStats const& runStats ) override;
+
+        void testCaseStarting( TestCaseInfo const& tcInfo ) override;
+        void testCaseEnded( TestCaseStats const& tcStats ) override;
+
+        void testCasePartialStarting( TestCaseInfo const& tcInfo,
+                                      uint64_t index ) override;
+        void testCasePartialEnded( TestCaseStats const& tcStats,
+                                   uint64_t index ) override;
+
+        void sectionStarting( SectionInfo const& sectionInfo ) override;
+        void sectionEnded( SectionStats const& sectionStats ) override;
+
+        void assertionStarting( AssertionInfo const& assertionInfo ) override;
+        void assertionEnded( AssertionStats const& assertionStats ) override;
+
+        //void testRunEndedCumulative() override;
+
+        void benchmarkPreparing( StringRef name ) override;
+        void benchmarkStarting( BenchmarkInfo const& ) override;
+        void benchmarkEnded( BenchmarkStats<> const& ) override;
+        void benchmarkFailed( StringRef error ) override;
+
+        void listReporters(
+            std::vector<ReporterDescription> const& descriptions ) override;
+        void listListeners(
+            std::vector<ListenerDescription> const& descriptions ) override;
+        void listTests( std::vector<TestCaseHandle> const& tests ) override;
+        void listTags( std::vector<TagInfo> const& tags ) override;
+
+    private:
+        Timer m_testCaseTimer;
+        enum class Writer {
+            Object,
+            Array
+        };
+
+        JsonArrayWriter& startArray();
+        JsonArrayWriter& startArray( StringRef key );
+
+        JsonObjectWriter& startObject();
+        JsonObjectWriter& startObject( StringRef key );
+
+        void endObject();
+        void endArray();
+
+        bool isInside( Writer writer );
+
+        void startListing();
+        void endListing();
+
+        // Invariant:
+        // When m_writers is not empty and its top element is
+        // - Writer::Object, then m_objectWriters is not be empty
+        // - Writer::Array,  then m_arrayWriters shall not be empty
+        std::stack<JsonObjectWriter> m_objectWriters{};
+        std::stack<JsonArrayWriter> m_arrayWriters{};
+        std::stack<Writer> m_writers{};
+
+        bool m_startedListing = false;
+
+        // std::size_t m_sectionDepth = 0;
+        // std::size_t m_sectionStarted = 0;
+    };
+} // namespace Catch
+
+#endif // CATCH_REPORTER_JSON_HPP_INCLUDED
+
+
+#ifndef CATCH_REPORTER_JUNIT_HPP_INCLUDED
+#define CATCH_REPORTER_JUNIT_HPP_INCLUDED
+
+
+
+namespace Catch {
+
+    class JunitReporter final : public CumulativeReporterBase {
+    public:
+        JunitReporter(ReporterConfig&& _config);
+
+        static std::string getDescription();
+
+        void testRunStarting(TestRunInfo const& runInfo) override;
+
+        void testCaseStarting(TestCaseInfo const& testCaseInfo) override;
+        void assertionEnded(AssertionStats const& assertionStats) override;
+
+        void testCaseEnded(TestCaseStats const& testCaseStats) override;
+
+        void testRunEndedCumulative() override;
+
+    private:
+        void writeRun(TestRunNode const& testRunNode, double suiteTime);
+
+        void writeTestCase(TestCaseNode const& testCaseNode);
+
+        void writeSection( std::string const& className,
+                           std::string const& rootName,
+                           SectionNode const& sectionNode,
+                           bool testOkToFail );
+
+        void writeAssertions(SectionNode const& sectionNode);
+        void writeAssertion(AssertionStats const& stats);
+
+        XmlWriter xml;
+        Timer suiteTimer;
+        std::string stdOutForSuite;
+        std::string stdErrForSuite;
+        unsigned int unexpectedExceptions = 0;
+        bool m_okToFail = false;
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_REPORTER_JUNIT_HPP_INCLUDED
+
+
+#ifndef CATCH_REPORTER_MULTI_HPP_INCLUDED
+#define CATCH_REPORTER_MULTI_HPP_INCLUDED
+
+
+namespace Catch {
+
+    class MultiReporter final : public IEventListener {
+        /*
+         * Stores all added reporters and listeners
+         *
+         * All Listeners are stored before all reporters, and individual
+         * listeners/reporters are stored in order of insertion.
+         */
+        std::vector<IEventListenerPtr> m_reporterLikes;
+        bool m_haveNoncapturingReporters = false;
+
+        // Keep track of how many listeners we have already inserted,
+        // so that we can insert them into the main vector at the right place
+        size_t m_insertedListeners = 0;
+
+        void updatePreferences(IEventListener const& reporterish);
+
+    public:
+        using IEventListener::IEventListener;
+
+        void addListener( IEventListenerPtr&& listener );
+        void addReporter( IEventListenerPtr&& reporter );
+
+    public: // IEventListener
+
+        void noMatchingTestCases( StringRef unmatchedSpec ) override;
+        void fatalErrorEncountered( StringRef error ) override;
+        void reportInvalidTestSpec( StringRef arg ) override;
+
+        void benchmarkPreparing( StringRef name ) override;
+        void benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) override;
+        void benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) override;
+        void benchmarkFailed( StringRef error ) override;
+
+        void testRunStarting( TestRunInfo const& testRunInfo ) override;
+        void testCaseStarting( TestCaseInfo const& testInfo ) override;
+        void testCasePartialStarting(TestCaseInfo const& testInfo, uint64_t partNumber) override;
+        void sectionStarting( SectionInfo const& sectionInfo ) override;
+        void assertionStarting( AssertionInfo const& assertionInfo ) override;
+
+        void assertionEnded( AssertionStats const& assertionStats ) override;
+        void sectionEnded( SectionStats const& sectionStats ) override;
+        void testCasePartialEnded(TestCaseStats const& testStats, uint64_t partNumber) override;
+        void testCaseEnded( TestCaseStats const& testCaseStats ) override;
+        void testRunEnded( TestRunStats const& testRunStats ) override;
+
+        void skipTest( TestCaseInfo const& testInfo ) override;
+
+        void listReporters(std::vector<ReporterDescription> const& descriptions) override;
+        void listListeners(std::vector<ListenerDescription> const& descriptions) override;
+        void listTests(std::vector<TestCaseHandle> const& tests) override;
+        void listTags(std::vector<TagInfo> const& tags) override;
+
+
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_REPORTER_MULTI_HPP_INCLUDED
+
+
+#ifndef CATCH_REPORTER_REGISTRARS_HPP_INCLUDED
+#define CATCH_REPORTER_REGISTRARS_HPP_INCLUDED
+
+
+#include <type_traits>
+
+namespace Catch {
+
+    namespace Detail {
+
+        template <typename T, typename = void>
+        struct has_description : std::false_type {};
+
+        template <typename T>
+        struct has_description<
+            T,
+            void_t<decltype( T::getDescription() )>>
+            : std::true_type {};
+
+        //! Indirection for reporter registration, so that the error handling is
+        //! independent on the reporter's concrete type
+        void registerReporterImpl( std::string const& name,
+                                   IReporterFactoryPtr reporterPtr );
+        //! Actually registers the factory, independent on listener's concrete type
+        void registerListenerImpl( Detail::unique_ptr<EventListenerFactory> listenerFactory );
+    } // namespace Detail
+
+    class IEventListener;
+    using IEventListenerPtr = Detail::unique_ptr<IEventListener>;
+
+    template <typename T>
+    class ReporterFactory : public IReporterFactory {
+
+        IEventListenerPtr create( ReporterConfig&& config ) const override {
+            return Detail::make_unique<T>( CATCH_MOVE(config) );
+        }
+
+        std::string getDescription() const override {
+            return T::getDescription();
+        }
+    };
+
+
+    template<typename T>
+    class ReporterRegistrar {
+    public:
+        explicit ReporterRegistrar( std::string const& name ) {
+            registerReporterImpl( name,
+                                  Detail::make_unique<ReporterFactory<T>>() );
+        }
+    };
+
+    template<typename T>
+    class ListenerRegistrar {
+
+        class TypedListenerFactory : public EventListenerFactory {
+            StringRef m_listenerName;
+
+            std::string getDescriptionImpl( std::true_type ) const {
+                return T::getDescription();
+            }
+
+            std::string getDescriptionImpl( std::false_type ) const {
+                return "(No description provided)";
+            }
+
+        public:
+            TypedListenerFactory( StringRef listenerName ):
+                m_listenerName( listenerName ) {}
+
+            IEventListenerPtr create( IConfig const* config ) const override {
+                return Detail::make_unique<T>( config );
+            }
+
+            StringRef getName() const override {
+                return m_listenerName;
+            }
+
+            std::string getDescription() const override {
+                return getDescriptionImpl( Detail::has_description<T>{} );
+            }
+        };
+
+    public:
+        ListenerRegistrar(StringRef listenerName) {
+            registerListenerImpl( Detail::make_unique<TypedListenerFactory>(listenerName) );
+        }
+    };
+}
+
+#if !defined(CATCH_CONFIG_DISABLE)
+
+#    define CATCH_REGISTER_REPORTER( name, reporterType )                      \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                              \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                               \
+        namespace {                                                            \
+            Catch::ReporterRegistrar<reporterType> INTERNAL_CATCH_UNIQUE_NAME( \
+                catch_internal_RegistrarFor )( name );                         \
+        }                                                                      \
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+#    define CATCH_REGISTER_LISTENER( listenerType )                            \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                              \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                               \
+        namespace {                                                            \
+            Catch::ListenerRegistrar<listenerType> INTERNAL_CATCH_UNIQUE_NAME( \
+                catch_internal_RegistrarFor )( #listenerType##_catch_sr );     \
+        }                                                                      \
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+#else // CATCH_CONFIG_DISABLE
+
+#define CATCH_REGISTER_REPORTER(name, reporterType)
+#define CATCH_REGISTER_LISTENER(listenerType)
+
+#endif // CATCH_CONFIG_DISABLE
+
+#endif // CATCH_REPORTER_REGISTRARS_HPP_INCLUDED
+
+
+#ifndef CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
+#define CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
+
+
+
+namespace Catch {
+
+    class SonarQubeReporter final : public CumulativeReporterBase {
+    public:
+        SonarQubeReporter(ReporterConfig&& config)
+        : CumulativeReporterBase(CATCH_MOVE(config))
+        , xml(m_stream) {
+            m_preferences.shouldRedirectStdOut = true;
+            m_preferences.shouldReportAllAssertions = false;
+            m_shouldStoreSuccesfulAssertions = false;
+        }
+
+        static std::string getDescription() {
+            using namespace std::string_literals;
+            return "Reports test results in the Generic Test Data SonarQube XML format"s;
+        }
+
+        void testRunStarting( TestRunInfo const& testRunInfo ) override;
+
+        void testRunEndedCumulative() override {
+            writeRun( *m_testRun );
+            xml.endElement();
+        }
+
+        void writeRun( TestRunNode const& runNode );
+
+        void writeTestFile(StringRef filename, std::vector<TestCaseNode const*> const& testCaseNodes);
+
+        void writeTestCase(TestCaseNode const& testCaseNode);
+
+        void writeSection(std::string const& rootName, SectionNode const& sectionNode, bool okToFail);
+
+        void writeAssertions(SectionNode const& sectionNode, bool okToFail);
+
+        void writeAssertion(AssertionStats const& stats, bool okToFail);
+
+    private:
+        XmlWriter xml;
+    };
+
+
+} // end namespace Catch
+
+#endif // CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
+
+
+#ifndef CATCH_REPORTER_TAP_HPP_INCLUDED
+#define CATCH_REPORTER_TAP_HPP_INCLUDED
+
+
+namespace Catch {
+
+    class TAPReporter final : public StreamingReporterBase {
+    public:
+        TAPReporter( ReporterConfig&& config ):
+            StreamingReporterBase( CATCH_MOVE(config) ) {
+            m_preferences.shouldReportAllAssertions = true;
+        }
+
+        static std::string getDescription() {
+            using namespace std::string_literals;
+            return "Reports test results in TAP format, suitable for test harnesses"s;
+        }
+
+        void testRunStarting( TestRunInfo const& testInfo ) override;
+
+        void noMatchingTestCases( StringRef unmatchedSpec ) override;
+
+        void assertionEnded(AssertionStats const& _assertionStats) override;
+
+        void testRunEnded(TestRunStats const& _testRunStats) override;
+
+    private:
+        std::size_t counter = 0;
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_REPORTER_TAP_HPP_INCLUDED
+
+
+#ifndef CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
+#define CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
+
+
+#include <cstring>
+
+#ifdef __clang__
+#   pragma clang diagnostic push
+#   pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+namespace Catch {
+
+    class TeamCityReporter final : public StreamingReporterBase {
+    public:
+        TeamCityReporter( ReporterConfig&& _config )
+        :   StreamingReporterBase( CATCH_MOVE(_config) )
+        {
+            m_preferences.shouldRedirectStdOut = true;
+        }
+
+        ~TeamCityReporter() override;
+
+        static std::string getDescription() {
+            using namespace std::string_literals;
+            return "Reports test results as TeamCity service messages"s;
+        }
+
+        void testRunStarting( TestRunInfo const& runInfo ) override;
+        void testRunEnded( TestRunStats const& runStats ) override;
+
+
+        void assertionEnded(AssertionStats const& assertionStats) override;
+
+        void sectionStarting(SectionInfo const& sectionInfo) override {
+            m_headerPrintedForThisSection = false;
+            StreamingReporterBase::sectionStarting( sectionInfo );
+        }
+
+        void testCaseStarting(TestCaseInfo const& testInfo) override;
+
+        void testCaseEnded(TestCaseStats const& testCaseStats) override;
+
+    private:
+        void printSectionHeader(std::ostream& os);
+
+        bool m_headerPrintedForThisSection = false;
+        Timer m_testTimer;
+    };
+
+} // end namespace Catch
+
+#ifdef __clang__
+#   pragma clang diagnostic pop
+#endif
+
+#endif // CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
+
+
+#ifndef CATCH_REPORTER_XML_HPP_INCLUDED
+#define CATCH_REPORTER_XML_HPP_INCLUDED
+
+
+
+
+namespace Catch {
+    class XmlReporter : public StreamingReporterBase {
+    public:
+        XmlReporter(ReporterConfig&& _config);
+
+        ~XmlReporter() override;
+
+        static std::string getDescription();
+
+        virtual std::string getStylesheetRef() const;
+
+        void writeSourceInfo(SourceLineInfo const& sourceInfo);
+
+    public: // StreamingReporterBase
+
+        void testRunStarting(TestRunInfo const& testInfo) override;
+
+        void testCaseStarting(TestCaseInfo const& testInfo) override;
+
+        void sectionStarting(SectionInfo const& sectionInfo) override;
+
+        void assertionStarting(AssertionInfo const&) override;
+
+        void assertionEnded(AssertionStats const& assertionStats) override;
+
+        void sectionEnded(SectionStats const& sectionStats) override;
+
+        void testCaseEnded(TestCaseStats const& testCaseStats) override;
+
+        void testRunEnded(TestRunStats const& testRunStats) override;
+
+        void benchmarkPreparing( StringRef name ) override;
+        void benchmarkStarting(BenchmarkInfo const&) override;
+        void benchmarkEnded(BenchmarkStats<> const&) override;
+        void benchmarkFailed( StringRef error ) override;
+
+        void listReporters(std::vector<ReporterDescription> const& descriptions) override;
+        void listListeners(std::vector<ListenerDescription> const& descriptions) override;
+        void listTests(std::vector<TestCaseHandle> const& tests) override;
+        void listTags(std::vector<TagInfo> const& tags) override;
+
+    private:
+        Timer m_testCaseTimer;
+        XmlWriter m_xml;
+        int m_sectionDepth = 0;
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_REPORTER_XML_HPP_INCLUDED
+
+#endif // CATCH_REPORTERS_ALL_HPP_INCLUDED
+
+#endif // CATCH_ALL_HPP_INCLUDED
+#endif // CATCH_AMALGAMATED_HPP_INCLUDED
diff --git a/tests/conversion.cc b/tests/conversion.cc
index a5435334b0..6d016fb3db 100644
--- a/tests/conversion.cc
+++ b/tests/conversion.cc
@@ -3,7 +3,7 @@
 
   MIT License
 
-  Copyright (c) 2019 struktur AG, Dirk Farin <farin@struktur.de>
+  Copyright (c) 2019 Dirk Farin <dirk.farin@gmail.com>
 
   Permission is hereby granted, free of charge, to any person obtaining a copy
   of this software and associated documentation files (the "Software"), to deal
@@ -24,122 +24,735 @@
   SOFTWARE.
 */
 
-#include "catch.hpp"
-#include "libheif/heif_colorconversion.h"
-
-
-using namespace heif;
-
-TEST_CASE( "Color conversion", "[heif_image]" ) {
-
-  ColorConversionPipeline pipeline;
-  bool success;
-
-  printf("--- color conversions ---\n");
-
-  success = pipeline.construct_pipeline( { heif_colorspace_RGB, heif_chroma_444, false, 8 },
-                                         { heif_colorspace_RGB, heif_chroma_interleaved_RGB, false, 8 } );
-
-  REQUIRE( success );
-
-  printf("---\n");
-
-  success = pipeline.construct_pipeline( { heif_colorspace_YCbCr, heif_chroma_420, false, 8 },
-                                         { heif_colorspace_RGB, heif_chroma_interleaved_RGB, false, 8 } );
-
-  printf("---\n");
-
-  success = pipeline.construct_pipeline( { heif_colorspace_YCbCr, heif_chroma_420, false, 8 },
-                                         { heif_colorspace_RGB, heif_chroma_interleaved_RGBA, true, 8 } );
-
-  REQUIRE( success );
+#include <iomanip>
+#include "catch_amalgamated.hpp"
+#include "color-conversion/colorconversion.h"
+#include "pixelimage.h"
+#include <cmath>
+
+// Enable for more verbose test output.
+constexpr bool kEnableDebugOutput = false;
+
+struct Plane {
+  heif_channel channel;
+  int width;
+  int height;
+  int bit_depth;
+};
+
+bool PlatformIsBigEndian() {
+  int i = 1;
+  return !*((char*)&i);
+}
 
-  printf("---\n");
+bool EndiannessMatchesPlatform(heif_chroma chroma) {
+  if (chroma == heif_chroma_interleaved_RRGGBB_BE ||
+      chroma == heif_chroma_interleaved_RRGGBBAA_BE) {
+    return PlatformIsBigEndian();
+  } else if (chroma == heif_chroma_interleaved_RRGGBB_LE ||
+             chroma == heif_chroma_interleaved_RRGGBBAA_LE) {
+    return !PlatformIsBigEndian();
+  }
+  return true;
+}
 
-  success = pipeline.construct_pipeline( { heif_colorspace_YCbCr, heif_chroma_420, false, 10 },
-                                         { heif_colorspace_RGB, heif_chroma_444, false, 10 } );
+uint16_t SwapBytes(uint16_t v) {
+  const uint8_t hi = static_cast<uint8_t>((v & 0xff00) >> 8);
+  const uint8_t lo = static_cast<uint8_t>(v & 0x00ff);
+  return (uint16_t)((lo << 8) | hi);
+}
 
-  REQUIRE( success );
+uint16_t SwapBytesIfNeeded(uint16_t v, heif_chroma chroma) {
+  return EndiannessMatchesPlatform(chroma) ? v : SwapBytes(v);
+}
 
-  printf("---\n");
+template <typename T>
+std::string PrintChannel(const HeifPixelImage& image, heif_channel channel) {
+  heif_chroma chroma = image.get_chroma_format();
+  int num_interleaved = num_interleaved_components_per_plane(chroma);
+  bool is_interleaved = num_interleaved > 1;
+  uint32_t max_cols = is_interleaved ? 3 : 10;
+  uint32_t max_rows = 10;
+  uint32_t width = std::min(image.get_width(channel), max_cols);
+  uint32_t height = std::min(image.get_height(channel), max_rows);
+  size_t stride;
+  const T* p = (T*)image.get_plane(channel, &stride);
+  stride /= (int)sizeof(T);
+  int bpp = image.get_bits_per_pixel(channel);
+  int digits = (int)std::ceil(std::log10(1 << bpp)) + 1;
+
+  std::ostringstream os;
+  os << "channel=" << channel << " width=" << width << " height=" << height
+     << " bpp=" << bpp << "\n";
+  os << std::string(digits, ' ');
+  int header_width = digits * num_interleaved - 1 + (is_interleaved ? 3 : 0);
+  for (uint32_t x = 0; x < width; ++x) {
+    os << "|" << std::left << std::setw(header_width) << std::to_string(x);
+  }
+  os << "\n";
+  for (uint32_t y = 0; y < height; ++y) {
+    os << std::left << std::setw(digits) << std::to_string(y) << "|";
+    for (uint32_t x = 0; x < width; ++x) {
+      if (is_interleaved) os << "(";
+      for (int k = 0; k < num_interleaved; ++k) {
+        int v = SwapBytesIfNeeded(p[y * stride + x * num_interleaved + k], chroma);
+        os << std::left << std::setw(digits) << std::to_string(v);
+      }
+      if (is_interleaved) os << ") ";
+    }
+    os << "\n";
+  }
+  return os.str();
+}
 
-  success = pipeline.construct_pipeline( { heif_colorspace_RGB, heif_chroma_444, false, 10 },
-                                         { heif_colorspace_RGB, heif_chroma_interleaved_RRGGBBAA_BE, true, 10 } );
+std::string PrintChannel(const HeifPixelImage& image, heif_channel channel) {
+ if (image.get_bits_per_pixel(channel) <= 8) {
+    return PrintChannel<uint8_t>(image, channel);
+ } else {
+    return PrintChannel<uint16_t>(image, channel);
+ }
+}
 
-  REQUIRE( success );
+// Returns the PSNR between 'original' and 'compressed' images.
+// If expect_alpha_max is true, then alpha values in 'compressed' are expected
+// to be equal to (1<<bpp)-1 rather than the alpha value in the original image.
+template <typename T>
+double GetPsnr(const HeifPixelImage& original, const HeifPixelImage& compressed,
+               heif_channel channel, bool expect_alpha_max) {
+  uint32_t w = original.get_width(channel);
+  uint32_t h = original.get_height(channel);
+  heif_chroma chroma = original.get_chroma_format();
+
+  if (w == 0 || h == 0) {
+    return 0;
+  }
+
+  size_t orig_stride;
+  size_t compressed_stride;
+  const T* orig_p = (T*)original.get_plane(channel, &orig_stride);
+  const T* compressed_p = (T*)compressed.get_plane(channel, &compressed_stride);
+  orig_stride /= (int)sizeof(T);
+  compressed_stride /= (int)sizeof(T);
+  double mse = 0.0;
+
+  int num_interleaved = num_interleaved_components_per_plane(chroma);
+  int alpha_max = (1 << original.get_bits_per_pixel(channel)) - 1;
+  CAPTURE(expect_alpha_max);
+  for (uint32_t y = 0; y < h; y++) {
+    for (uint32_t x = 0; x < w * num_interleaved; x++) {
+      int orig_v = SwapBytesIfNeeded(orig_p[y * orig_stride + x], chroma);
+      if (expect_alpha_max && (channel == heif_channel_Alpha ||
+                               ((num_interleaved == 4) && x % 4 == 3))) {
+        orig_v = alpha_max;
+      }
+      int compressed_v = SwapBytesIfNeeded(compressed_p[y * compressed_stride + x], chroma);
+      int d = orig_v - compressed_v;
+      mse += d * d;
+    }
+  }
+  mse /= w * h;
+  int max = (1 << original.get_bits_per_pixel(channel)) - 1;
+  double psnr = 10 * log10(max * max / mse);
+  if (psnr < 0.) return 0.;
+  if (psnr > 100.) return 100.;
+  return psnr;
+}
 
-  printf("---\n");
+double GetPsnr(const HeifPixelImage& original, const HeifPixelImage& compressed,
+            heif_channel channel, bool expect_alpha_max) {
+ if (original.get_bits_per_pixel(channel) <= 8) {
+    return GetPsnr<uint8_t>(original, compressed, channel, expect_alpha_max);
+ } else {
+    return GetPsnr<uint16_t>(original, compressed, channel, expect_alpha_max);
+ }
+}
 
-  success = pipeline.construct_pipeline( { heif_colorspace_RGB, heif_chroma_444, false, 10 },
-                                         { heif_colorspace_RGB, heif_chroma_interleaved_RRGGBBAA_LE, true, 10 } );
+std::vector<Plane> GetPlanes(const ColorState& state, int width, int height) {
+  std::vector<Plane> planes;
+  if (state.colorspace == heif_colorspace_monochrome) {
+    if (state.chroma != heif_chroma_monochrome) return {};
+    planes.push_back({heif_channel_Y, width, height, state.bits_per_pixel});
+    if (state.has_alpha) {
+      planes.push_back(
+          {heif_channel_Alpha, width, height, state.bits_per_pixel});
+    }
+  } else if (state.colorspace == heif_colorspace_YCbCr) {
+    if (state.chroma != heif_chroma_444 && state.chroma != heif_chroma_422 &&
+        state.chroma != heif_chroma_420 && state.chroma != heif_chroma_monochrome) {
+      return {};
+    }
+    planes.push_back({heif_channel_Y, width, height, state.bits_per_pixel});
+    if (state.chroma != heif_chroma_monochrome) {
+      int chroma_width = state.chroma == heif_chroma_444 ? width : width / 2;
+      int chroma_height =
+          state.chroma == heif_chroma_444 || state.chroma == heif_chroma_422
+              ? height
+              : height / 2;
+      planes.push_back(
+          {heif_channel_Cb, chroma_width, chroma_height, state.bits_per_pixel});
+      planes.push_back(
+          {heif_channel_Cr, chroma_width, chroma_height, state.bits_per_pixel});
+    }
+    if (state.has_alpha) {
+      planes.push_back(
+          {heif_channel_Alpha, width, height, state.bits_per_pixel});
+    }
+  } else if (state.colorspace == heif_colorspace_RGB) {
+    if (state.chroma != heif_chroma_444 &&
+        state.chroma != heif_chroma_interleaved_RGB &&
+        state.chroma != heif_chroma_interleaved_RGBA &&
+        state.chroma != heif_chroma_interleaved_RRGGBB_BE &&
+        state.chroma != heif_chroma_interleaved_RRGGBBAA_BE &&
+        state.chroma != heif_chroma_interleaved_RRGGBB_LE &&
+        state.chroma != heif_chroma_interleaved_RRGGBBAA_LE) {
+      return {};
+    }
+    if (state.chroma == heif_chroma_444) {
+      planes.push_back({heif_channel_R, width, height, state.bits_per_pixel});
+      planes.push_back({heif_channel_G, width, height, state.bits_per_pixel});
+      planes.push_back({heif_channel_B, width, height, state.bits_per_pixel});
+      if (state.has_alpha) {
+        planes.push_back(
+            {heif_channel_Alpha, width, height, state.bits_per_pixel});
+      }
+    } else {
+      planes.push_back(
+          {heif_channel_interleaved, width, height, state.bits_per_pixel});
+    }
+  } else {
+    return {};  // Unsupported colorspace.
+  }
+  return planes;
+}
 
-  REQUIRE( success );
+bool MakeTestImage(const ColorState& state, int width, int height,
+                   HeifPixelImage* image) {
+  image->create(width, height, state.colorspace, state.chroma);
+  image->set_color_profile_nclx(state.nclx);
+  std::vector<Plane> planes = GetPlanes(state, width, height);
+  if (planes.empty()) return false;
+  for (size_t i = 0; i < planes.size(); ++i) {
+    const Plane& plane = planes[i];
+    int half_max = (1 << (plane.bit_depth -1));
+    uint16_t value = SwapBytesIfNeeded(
+        static_cast<uint16_t>(half_max + i * 10 + i), state.chroma);
+    auto err = image->fill_new_plane(plane.channel, value, plane.width, plane.height,
+                                     plane.bit_depth, nullptr);
+    if (err) {
+      return false;
+    }
+  }
+  return true;
+}
 
-  printf("---\n");
+static bool NclxMatches(heif_colorspace colorspace,
+                        const nclx_profile& src_nclx,
+                        const nclx_profile& dst_nclx) {
+  if (colorspace != heif_colorspace_YCbCr) {
+    return true;
+  }
 
-  success = pipeline.construct_pipeline( { heif_colorspace_monochrome, heif_chroma_monochrome, false, 8 },
-                                         { heif_colorspace_RGB, heif_chroma_interleaved_RGB, false, 8 } );
+  if (src_nclx.get_full_range_flag() != dst_nclx.get_full_range_flag() ||
+      src_nclx.get_matrix_coefficients() !=
+          dst_nclx.get_matrix_coefficients()) {
+    return false;
+  }
 
-  REQUIRE( success );
+  return true;
+}
 
-  printf("---\n");
+void nclx_default_if_undefined(ColorState& state)
+{
+  if (state.nclx.get_colour_primaries() == heif_color_primaries_unspecified) {
+    state.nclx.set_colour_primaries(1);
+  }
 
-  success = pipeline.construct_pipeline( { heif_colorspace_monochrome, heif_chroma_monochrome, false, 8 },
-                                         { heif_colorspace_RGB, heif_chroma_interleaved_RGBA, true, 8 } );
+  if (state.nclx.get_matrix_coefficients() == heif_matrix_coefficients_unspecified) {
+    state.nclx.set_matrix_coefficients(6);
+  }
 
-  printf("---\n");
+  if (state.nclx.get_transfer_characteristics() == heif_transfer_characteristic_unspecified) {
+    state.nclx.set_transfer_characteristics(13);
+  }
+}
 
-  success = pipeline.construct_pipeline( { heif_colorspace_RGB, heif_chroma_interleaved_RGBA, true, 8 },
-                                         { heif_colorspace_YCbCr, heif_chroma_420, false, 8 } );
 
-  REQUIRE( success );
+// Converts from 'input_state' to 'target_state' and checks that the resulting
+// image has the expected shape. If the reverse conversion is also supported,
+// does a round-trip back to the original state and checks the PSNR.
+// If 'require_supported' is true, checks that the conversion from 'input_state'
+// to 'target_state' is supported, otherwise, exists silently for unsupported
+// conversions.
+void TestConversion(const std::string& test_name, ColorState input_state,
+                    ColorState target_state,
+                    const heif_color_conversion_options& options,
+                    const heif_color_conversion_options_ext& options_ext,
+                    bool require_supported = true) {
+  nclx_default_if_undefined(input_state);
+  nclx_default_if_undefined(target_state);
+
+  INFO(test_name);
+  INFO("downsampling=" << options.preferred_chroma_downsampling_algorithm
+                       << " upsampling="
+                       << options.preferred_chroma_upsampling_algorithm
+                       << " only_used_preferred="
+                       << (bool)options.only_use_preferred_chroma_algorithm);
 
-  printf("---\n");
+  ColorConversionPipeline pipeline;
+  bool supported = pipeline.construct_pipeline(input_state, target_state, options, options_ext);
+  if (require_supported) REQUIRE(supported);
+  if (!supported) return;
+  INFO("conversion pipeline: " << pipeline.debug_dump_pipeline());
+
+  auto in_image = std::make_shared<HeifPixelImage>();
+  // Width and height are multiples of 4.
+  int width = 12;
+  int height = 8;
+  REQUIRE(MakeTestImage(input_state, width, height, in_image.get()));
+
+  auto out_image_result = pipeline.convert_image(in_image, nullptr);
+  REQUIRE(out_image_result);
+  std::shared_ptr<HeifPixelImage> out_image = *out_image_result;
+
+  REQUIRE(out_image != nullptr);
+  CHECK(out_image->get_colorspace() == target_state.colorspace);
+  CHECK(out_image->get_chroma_format() == target_state.chroma);
+  CHECK(out_image->has_alpha() == target_state.has_alpha);
+  for (const Plane& plane : GetPlanes(target_state, width, height)) {
+    INFO("Channel: " << plane.channel);
+    size_t stride;
+    CHECK(out_image->get_plane(plane.channel, &stride) != nullptr);
+    CHECK(out_image->get_bits_per_pixel(plane.channel) ==
+          target_state.bits_per_pixel);
+    // If an alpha plane was created from nothing, check that it's filled
+    // with the max alpha value.
+    if (plane.channel == heif_channel_Alpha && !input_state.has_alpha) {
+      double alpha_psnr = GetPsnr(*out_image, *out_image, heif_channel_Alpha,
+                                  /*expect_alpha_max=*/true);
+      REQUIRE(alpha_psnr == 100.f);
+    }
+  }
+
+
+  // Convert back in the other direction (if supported).
+  ColorConversionPipeline reverse_pipeline;
+  if (reverse_pipeline.construct_pipeline(target_state, input_state, options, options_ext)) {
+    INFO("reverse pipeline: " << reverse_pipeline.debug_dump_pipeline());
+    auto recovered_image_result =reverse_pipeline.convert_image(out_image, heif_get_disabled_security_limits());
+    REQUIRE(recovered_image_result);
+    std::shared_ptr<HeifPixelImage> recovered_image = *recovered_image_result;
+    // If the alpha plane was lost in the target state, it should come back
+    // as the max value for the given bpp, i.e. (1<<bpp)-1
+    bool expect_alpha_max = !target_state.has_alpha;
+    bool expect_lossless =
+        input_state.colorspace == target_state.colorspace &&
+        input_state.bits_per_pixel == target_state.bits_per_pixel &&
+        (input_state.chroma == target_state.chroma ||
+         (input_state.chroma != heif_chroma_420 &&
+          input_state.chroma != heif_chroma_422 &&
+          target_state.chroma != heif_chroma_420 &&
+          target_state.chroma != heif_chroma_422)) &&
+        NclxMatches(input_state.colorspace, input_state.nclx,
+                    target_state.nclx);
+    double expected_psnr = expect_lossless ? 100. : 38.;
+
+    for (const Plane& plane : GetPlanes(input_state, width, height)) {
+      INFO("Channel: "
+           << plane.channel
+           << " (set kEnableDebugOutput to true in the code for more info)");
+      if (kEnableDebugOutput) {
+        UNSCOPED_INFO("Original:\n" << PrintChannel(*in_image, plane.channel));
+        UNSCOPED_INFO("Recovered:\n"
+                      << PrintChannel(*recovered_image, plane.channel));
+        for (const Plane& converted_plane :
+             GetPlanes(target_state, width, height)) {
+          UNSCOPED_INFO("Converted channel "
+                        << converted_plane.channel << ":\n"
+                        << PrintChannel(*out_image, converted_plane.channel));
+        }
+      }
+      double psnr =
+          GetPsnr(*in_image, *recovered_image, plane.channel, expect_alpha_max);
+      CHECK(psnr >= expected_psnr);
+    }
+  }
+}
 
-  success = pipeline.construct_pipeline( { heif_colorspace_RGB, heif_chroma_444, false, 10 },
-                                         { heif_colorspace_RGB, heif_chroma_interleaved_RRGGBB_LE, false, 10 } );
+void TestFailingConversion(const std::string& test_name,
+                           const ColorState& input_state,
+                           const ColorState& target_state,
+                           const heif_color_conversion_options& options,
+                           const heif_color_conversion_options_ext& options_ext) {
+  INFO(test_name);
+  INFO("downsampling=" << options.preferred_chroma_downsampling_algorithm
+                       << " upsampling="
+                       << options.preferred_chroma_upsampling_algorithm
+                       << " only_used_preferred="
+                       << (bool)options.only_use_preferred_chroma_algorithm);
+  ColorConversionPipeline pipeline;
+  bool construct_pipeline_res =
+      pipeline.construct_pipeline(input_state, target_state, options, options_ext);
+  INFO("conversion pipeline: " << pipeline.debug_dump_pipeline());
+  REQUIRE_FALSE(construct_pipeline_res);
+}
 
-  REQUIRE( success );
+// Returns the list of valid has_alpha values for a given heif_chroma.
+std::vector<bool> GetValidHasAlpha(heif_chroma chroma) {
+  switch (chroma) {
+    case heif_chroma_monochrome:
+    case heif_chroma_420:
+    case heif_chroma_422:
+    case heif_chroma_444:
+      return {false, true};
+    case heif_chroma_interleaved_RGB:
+    case heif_chroma_interleaved_RRGGBB_BE:
+    case heif_chroma_interleaved_RRGGBB_LE:
+      return {false};
+    case heif_chroma_interleaved_RGBA:
+    case heif_chroma_interleaved_RRGGBBAA_BE:
+    case heif_chroma_interleaved_RRGGBBAA_LE:
+      return {true};
+    default:
+      return {};
+  }
+}
 
-  printf("---\n");
+// Returns some valid bits per pixels values for a given heif_chroma.
+std::vector<int> GetValidBitsPerPixel(heif_chroma chroma) {
+  const std::vector<int> sdr = {8};
+  const std::vector<int> hdr = {12};
+  const std::vector<int> both = {8, 12};
+  switch (chroma) {
+    case heif_chroma_monochrome:
+    case heif_chroma_420:
+    case heif_chroma_422:
+    case heif_chroma_444:
+      return both;
+    case heif_chroma_interleaved_RGB:
+    case heif_chroma_interleaved_RGBA:
+      return sdr;
+    case heif_chroma_interleaved_RRGGBB_BE:
+    case heif_chroma_interleaved_RRGGBB_LE:
+    case heif_chroma_interleaved_RRGGBBAA_BE:
+    case heif_chroma_interleaved_RRGGBBAA_LE:
+      return hdr;
+    default:
+      return {};
+  }
+}
 
-  success = pipeline.construct_pipeline( { heif_colorspace_RGB, heif_chroma_interleaved_RRGGBB_LE, false, 12 },
-                                         { heif_colorspace_RGB, heif_chroma_444, false, 12 } );
+// Returns a subset (to reduce the number of tests) of fully supported matrix
+// coefficients.
+const std::vector<heif_matrix_coefficients> GetSupportedMatrices() {
+  return {heif_matrix_coefficients_RGB_GBR,
+          heif_matrix_coefficients_SMPTE_240M};
+}
 
-  REQUIRE( success );
+// Returns matrix coefficients that are not currently supported by any operator.
+const std::vector<heif_matrix_coefficients> GetUnsupportedMatrices() {
+  return {heif_matrix_coefficients_SMPTE_ST_2085,
+          heif_matrix_coefficients_ICtCp};
+}
 
-  printf("---\n");
+// Returns of list of all valid ColorState (valid combinations
+// of a heif_colorspace/heif_chroma/has_alpha/bpp).
+std::vector<ColorState> GetAllColorStates(const std::vector<heif_matrix_coefficients>& matrices) {
+  std::vector<ColorState> color_states;
+  for (heif_colorspace colorspace : {heif_colorspace_YCbCr, heif_colorspace_RGB, heif_colorspace_monochrome}) {
+    for (heif_chroma chroma : get_valid_chroma_values_for_colorspace(colorspace)) {
+      for (bool has_alpha : GetValidHasAlpha(chroma)) {
+        for (int bits_per_pixel : GetValidBitsPerPixel(chroma)) {
+          // Without nclx.
+          ColorState color_state(colorspace, chroma, has_alpha, bits_per_pixel);
+          color_states.push_back(color_state);
+
+          // With nclx.
+          if (colorspace == heif_colorspace_YCbCr) {
+            for (heif_matrix_coefficients matrix : matrices) {
+              for (bool full_range : {true, false}) {
+                color_state.nclx.set_full_range_flag(full_range);
+                color_state.nclx.set_matrix_coefficients(matrix);
+                color_state.nclx.set_colour_primaries(
+                    heif_color_primaries_ITU_R_BT_709_5);
+                color_state.nclx.set_transfer_characteristics(
+                    heif_color_primaries_SMPTE_240M);
+                color_states.push_back(color_state);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  return color_states;
+}
 
-  success = pipeline.construct_pipeline( { heif_colorspace_RGB, heif_chroma_444, false, 12 },
-                                         { heif_colorspace_YCbCr, heif_chroma_420, false, 12 } );
+TEST_CASE("All conversions", "[heif_image]") {
+  bool only_use_preferred_chroma_algorithm = GENERATE(false, true);
+  heif_chroma_downsampling_algorithm downsampling =
+      heif_chroma_downsampling_nearest_neighbor;
+  heif_chroma_upsampling_algorithm upsampling =
+      heif_chroma_upsampling_nearest_neighbor;
+  if (only_use_preferred_chroma_algorithm) {
+    downsampling = GENERATE(heif_chroma_downsampling_nearest_neighbor,
+                            heif_chroma_downsampling_average,
+                            heif_chroma_downsampling_sharp_yuv);
+    upsampling = GENERATE(heif_chroma_upsampling_nearest_neighbor,
+                          heif_chroma_upsampling_bilinear);
+  }
+  heif_color_conversion_options options = {
+      .preferred_chroma_downsampling_algorithm = downsampling,
+      .preferred_chroma_upsampling_algorithm = upsampling,
+      .only_use_preferred_chroma_algorithm = only_use_preferred_chroma_algorithm};
+
+  heif_color_conversion_options_ext options_ext = {
+      .alpha_composition_mode = heif_alpha_composition_mode_none
+  };
+
+  // Test all source and destination state combinations.
+  ColorState src_state = GENERATE(
+      from_range(GetAllColorStates(GetSupportedMatrices())));
+  ColorState dst_state = GENERATE(
+      from_range(GetAllColorStates(GetSupportedMatrices())));
+  // To debug a particular combination, hardcode the ColorState values
+  // instead:
+  // ColorState src_state(heif_colorspace_YCbCr, heif_chroma_420, false, 8);
+  // src_state.nclx_profile.set_matrix_coefficients(...);
+  // ColorState dst_state(...);
+
+  bool require_supported = true;
+  // Converting to monochrome is not supported at the moment.
+  if (dst_state.colorspace == heif_colorspace_monochrome ||
+      dst_state.chroma == heif_chroma_monochrome) {
+    require_supported = false;
+  }
+  // Some conversions might not be supported when the exact upsampling
+  // or downsampling algorithm is specified.
+  if (only_use_preferred_chroma_algorithm) {
+    require_supported = false;
+  }
+
+  std::ostringstream os;
+  os << "from: " << src_state << "\nto:   " << dst_state;
+  TestConversion(os.str(), src_state, dst_state, options, options_ext, require_supported);
+}
 
-  REQUIRE( success );
+TEST_CASE("Unsupported matrices", "[heif_image]") {
+  bool only_use_preferred_chroma_algorithm = GENERATE(false, true);
+  heif_chroma_downsampling_algorithm downsampling =
+      heif_chroma_downsampling_nearest_neighbor;
+  heif_chroma_upsampling_algorithm upsampling =
+      heif_chroma_upsampling_nearest_neighbor;
+  if (only_use_preferred_chroma_algorithm) {
+    downsampling = GENERATE(heif_chroma_downsampling_nearest_neighbor,
+                            heif_chroma_downsampling_average,
+                            heif_chroma_downsampling_sharp_yuv);
+    upsampling = GENERATE(heif_chroma_upsampling_nearest_neighbor,
+                          heif_chroma_upsampling_bilinear);
+  }
+  heif_color_conversion_options options = {
+      .preferred_chroma_downsampling_algorithm = downsampling,
+      .preferred_chroma_upsampling_algorithm = upsampling,
+      .only_use_preferred_chroma_algorithm = only_use_preferred_chroma_algorithm};
+
+  heif_color_conversion_options_ext options_ext = {
+      .alpha_composition_mode = heif_alpha_composition_mode_none
+  };
+
+  ColorState src_state =
+      GENERATE(from_range(GetAllColorStates(GetUnsupportedMatrices())));
+  ColorState dst_state =
+      GENERATE(from_range(GetAllColorStates(GetUnsupportedMatrices())));
+  nclx_profile default_nclx = nclx_profile::defaults();
+
+  if (src_state == dst_state ||
+      NclxMatches(src_state.colorspace, src_state.nclx,
+                  dst_state.nclx) ||
+      (src_state.nclx.get_matrix_coefficients() == default_nclx.get_matrix_coefficients() ||
+       dst_state.nclx.get_matrix_coefficients() == default_nclx.get_matrix_coefficients())) {
+    return;
+  }
+
+  std::ostringstream os;
+  os << "from: " << src_state << "\nto:   " << dst_state;
+  TestFailingConversion(os.str(), src_state, dst_state, options, options_ext);
+}
 
-  printf("---\n");
+TEST_CASE("Sharp yuv conversion", "[heif_image]") {
+  heif_color_conversion_options sharp_yuv_options{
+      .preferred_chroma_downsampling_algorithm =
+          heif_chroma_downsampling_sharp_yuv,
+      .preferred_chroma_upsampling_algorithm = heif_chroma_upsampling_bilinear,
+      .only_use_preferred_chroma_algorithm = true};
+
+  heif_color_conversion_options_ext options_ext = {
+      .alpha_composition_mode = heif_alpha_composition_mode_none
+  };
+
+#ifdef HAVE_LIBSHARPYUV
+  TestConversion("### interleaved RGBA -> YCbCr 420 with sharp yuv",
+                 {heif_colorspace_RGB, heif_chroma_interleaved_RGBA, true, 8},
+                 {heif_colorspace_YCbCr, heif_chroma_420, true, 8},
+                 sharp_yuv_options, options_ext);
+  TestConversion("### interleaved RGB 10bit -> YCbCr 420 10bit with sharp yuv",
+                 {heif_colorspace_RGB, heif_chroma_interleaved_RGB, false, 8},
+                 {heif_colorspace_YCbCr, heif_chroma_420, false, 8},
+                 sharp_yuv_options, options_ext);
+
+  TestConversion("### interleaved RGBA 12bit big endian -> YCbCr 420 12bit with sharp yuv",
+                 {heif_colorspace_RGB, heif_chroma_interleaved_RRGGBBAA_BE, true, 12},
+                 {heif_colorspace_YCbCr, heif_chroma_420, true, 12},
+                 sharp_yuv_options, options_ext);
+  TestConversion("### interleaved RGBA 12bit little endian -> YCbCr 420 12bit with sharp yuv",
+                 {heif_colorspace_RGB, heif_chroma_interleaved_RRGGBBAA_LE, true, 12},
+                 {heif_colorspace_YCbCr, heif_chroma_420, true, 12},
+                 sharp_yuv_options, options_ext);
+  TestConversion("### planar RGB -> YCbCr 420 with sharp yuv",
+                 {heif_colorspace_RGB, heif_chroma_444, false, 8},
+                 {heif_colorspace_YCbCr, heif_chroma_420, false, 8},
+                 sharp_yuv_options, options_ext);
+  TestConversion("### planar RGBA -> YCbCr 420 with sharp yuv",
+                 {heif_colorspace_RGB, heif_chroma_444, true, 8},
+                 {heif_colorspace_YCbCr, heif_chroma_420, true, 8},
+                 sharp_yuv_options, options_ext);
+  TestConversion("### planar RGB 10bit -> YCbCr 420 10bit with sharp yuv",
+                 {heif_colorspace_RGB, heif_chroma_444, false, 10},
+                 {heif_colorspace_YCbCr, heif_chroma_420, false, 10},
+                 sharp_yuv_options, options_ext);
+  TestConversion("### planar RGBA 10bit -> YCbCr 420 10bit with sharp yuv",
+                 {heif_colorspace_RGB, heif_chroma_444, true, 10},
+                 {heif_colorspace_YCbCr, heif_chroma_420, true, 10},
+                 sharp_yuv_options, options_ext);
+#else
+  // Should fail if libsharpyuv is not compiled in.
+  TestFailingConversion(
+      "### interleaved RGBA -> YCbCr 420 with sharp yuv NOT COMPILED IN",
+      {heif_colorspace_RGB, heif_chroma_interleaved_RGBA, true, 8},
+      {heif_colorspace_YCbCr, heif_chroma_420, false, 8}, sharp_yuv_options, options_ext);
+  WARN("Tests built without sharp yuv");
+#endif
+
+  TestFailingConversion(
+      "### interleaved RGBA -> YCbCr 422 with sharp yuv (not supported!)",
+      {heif_colorspace_RGB, heif_chroma_interleaved_RGBA, true, 8},
+      {heif_colorspace_YCbCr, heif_chroma_422, false, 8}, sharp_yuv_options, options_ext);
+}
 
-  success = pipeline.construct_pipeline( { heif_colorspace_RGB, heif_chroma_interleaved_RRGGBB_BE, false, 12 },
-                                         { heif_colorspace_YCbCr, heif_chroma_420, false, 12 } );
 
-  REQUIRE( success );
+static void fill_plane(std::shared_ptr<HeifPixelImage>& img, heif_channel channel, int w, int h, const std::vector<uint8_t>& pixels)
+{
+  auto error = img->add_plane(channel, w, h, 8, nullptr);
+  REQUIRE(!error);
 
-  printf("---\n");
+  size_t stride;
+  uint8_t* p = img->get_plane(channel, &stride);
 
-  success = pipeline.construct_pipeline( { heif_colorspace_RGB, heif_chroma_interleaved_RRGGBB_LE, false, 12 },
-                                         { heif_colorspace_YCbCr, heif_chroma_420, false, 12 } );
+  for (int y = 0; y < h; y++) {
+    for (int x = 0; x < w; x++) {
+      p[y * stride + x] = pixels[y * w + x];
+    }
+  }
+}
 
-  REQUIRE( success );
 
-  printf("--- monochrome colorspace -> interleaved RGB\n");
+static void assert_plane(std::shared_ptr<HeifPixelImage>& img, heif_channel channel, const std::vector<uint8_t>& pixels)
+{
+  INFO("channel: " << channel);
+  uint32_t w = img->get_width(channel);
+  uint32_t h = img->get_height(channel);
 
-  success = pipeline.construct_pipeline( { heif_colorspace_monochrome, heif_chroma_monochrome, false, 8 },
-                                         { heif_colorspace_RGB, heif_chroma_interleaved_RGB, false, 8 } );
+  size_t stride;
+  uint8_t* p = img->get_plane(channel, &stride);
 
-  REQUIRE( success );
+  for (uint32_t y = 0; y < h; y++) {
+    INFO("row: " << y);
+    for (uint32_t x = 0; x < w; x++) {
+      INFO("column: " << x);
+      REQUIRE((int)p[y * stride + x] == (int)pixels[y * w + x]);
+    }
+  }
+}
 
-  printf("--- monochrome YCbCr -> interleaved RGB\n");
 
-  success = pipeline.construct_pipeline( { heif_colorspace_YCbCr, heif_chroma_monochrome, false, 8 },
-                                         { heif_colorspace_RGB, heif_chroma_interleaved_RGB, false, 8 } );
+TEST_CASE("Bilinear upsampling", "[heif_image]")
+{
+  heif_color_conversion_options options = {
+      .preferred_chroma_upsampling_algorithm = heif_chroma_upsampling_bilinear,
+      .only_use_preferred_chroma_algorithm = true};
+
+  std::shared_ptr<HeifPixelImage> img = std::make_shared<HeifPixelImage>();
+  img->create(4, 4, heif_colorspace_YCbCr, heif_chroma_420);
+
+  auto error = img->fill_new_plane(heif_channel_Y, 128, 4,4, 8, nullptr);
+  REQUIRE(!error);
+
+  fill_plane(img, heif_channel_Cb, 2,2,
+             {10, 40,
+              100, 240});
+  fill_plane(img, heif_channel_Cr, 2, 2,
+             {255, 200,
+              50, 0});
+
+  auto conversionResult = convert_colorspace(img, heif_colorspace_YCbCr, heif_chroma_444,
+                                             nclx_profile::defaults(), 8, options, nullptr, heif_get_disabled_security_limits());
+  REQUIRE(conversionResult);
+  std::shared_ptr<HeifPixelImage> out = *conversionResult;
+
+  assert_plane(out, heif_channel_Cb,
+               {
+                   10, 18, 33, 40,
+                   33, 47, 76, 90,
+                   78, 106, 162, 190,
+                   100, 135, 205, 240
+               });
+
+
+  assert_plane(out, heif_channel_Cr,
+               {
+                   255, 241, 214, 200,
+                   204, 190, 163, 150,
+                   101, 88, 63, 50,
+                   50, 38, 13, 0
+               });
+}
 
-  REQUIRE( success );
+TEST_CASE("RGB 5-6-5 to RGB")
+{
+  heif_color_conversion_options options = {};
+
+  std::shared_ptr<HeifPixelImage> img = std::make_shared<HeifPixelImage>();
+  const uint32_t width = 3;
+  const uint32_t height = 2;
+  img->create(width, height, heif_colorspace_RGB, heif_chroma_444);
+  Error err;
+  err = img->add_plane(heif_channel_R, width, height, 5, heif_get_disabled_security_limits());
+  REQUIRE(!err);
+  REQUIRE(img->get_bits_per_pixel(heif_channel_R) == 5);
+  err = img->add_plane(heif_channel_G, width, height, 6, heif_get_disabled_security_limits());
+  REQUIRE(!err);
+  REQUIRE(img->get_bits_per_pixel(heif_channel_G) == 6);
+  err = img->add_plane(heif_channel_B, width, height, 5, heif_get_disabled_security_limits());
+  REQUIRE(!err);
+  REQUIRE(img->get_bits_per_pixel(heif_channel_B) == 5);
+
+  uint8_t v = 1;
+  for (heif_channel plane: {heif_channel_R, heif_channel_G, heif_channel_B}) {
+    size_t dst_stride = 0;
+    uint8_t *dst = img->get_plane(plane, &dst_stride);
+    for (uint32_t y = 0; y < height; y++) {
+      for (uint32_t x = 0; x < width; x++) {
+        dst[y * dst_stride + x] = v;
+        v++;
+      }
+    }
+  }
+
+  auto conversionResult = convert_colorspace(img, heif_colorspace_RGB, heif_chroma_444,
+                                             nclx_profile::defaults(), 8, options, nullptr, heif_get_disabled_security_limits());
+  REQUIRE(conversionResult);
+  std::shared_ptr<HeifPixelImage> out = *conversionResult;
+
+  assert_plane(out, heif_channel_R, {8, 16, 24, 33, 41, 49});
+  assert_plane(out, heif_channel_G, {28, 32, 36, 40, 44, 48});
+  assert_plane(out, heif_channel_B, {107, 115, 123, 132, 140, 148});
 }
diff --git a/tests/cxx_wrapper.cc b/tests/cxx_wrapper.cc
new file mode 100644
index 0000000000..75a581f8db
--- /dev/null
+++ b/tests/cxx_wrapper.cc
@@ -0,0 +1,46 @@
+/*
+  libheif unit tests
+
+  MIT License
+
+  Copyright (c) 2025 Dirk Farin <dirk.farin@gmail.com>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#include "catch_amalgamated.hpp"
+#include "test_utils.h"
+#include <libheif/heif_cxx.h>
+#include <iostream>
+
+TEST_CASE( "C++ object copy (ColorProfile_nclx)" )
+{
+  // This is the reproducer from issue #1641
+
+  heif::Image img;
+
+  img.create(16,16, heif_colorspace_RGB, heif_chroma_interleaved_RGBA);
+
+  heif::ColorProfile_nclx nclx;
+  nclx.set_matrix_coefficients(heif_matrix_coefficients_SMPTE_240M);
+  img.set_nclx_color_profile(nclx);
+
+  heif::ColorProfile_nclx a = img.get_nclx_color_profile();
+  heif::ColorProfile_nclx b(a);
+}
\ No newline at end of file
diff --git a/tests/data/heifio/mono.tif b/tests/data/heifio/mono.tif
new file mode 100644
index 0000000000..6069f02e60
Binary files /dev/null and b/tests/data/heifio/mono.tif differ
diff --git a/tests/data/heifio/mono_planar.tif b/tests/data/heifio/mono_planar.tif
new file mode 100644
index 0000000000..bf21da93f1
Binary files /dev/null and b/tests/data/heifio/mono_planar.tif differ
diff --git a/tests/data/heifio/rgb.tif b/tests/data/heifio/rgb.tif
new file mode 100644
index 0000000000..ca6a0edc29
Binary files /dev/null and b/tests/data/heifio/rgb.tif differ
diff --git a/tests/data/heifio/rgb_planar.tif b/tests/data/heifio/rgb_planar.tif
new file mode 100644
index 0000000000..0020c20014
Binary files /dev/null and b/tests/data/heifio/rgb_planar.tif differ
diff --git a/tests/data/heifio/rgba.tif b/tests/data/heifio/rgba.tif
new file mode 100644
index 0000000000..07ab2e82fd
Binary files /dev/null and b/tests/data/heifio/rgba.tif differ
diff --git a/tests/data/heifio/rgba_planar.tif b/tests/data/heifio/rgba_planar.tif
new file mode 100644
index 0000000000..bc6a964d5a
Binary files /dev/null and b/tests/data/heifio/rgba_planar.tif differ
diff --git a/tests/data/lightning_mini.heif b/tests/data/lightning_mini.heif
new file mode 100644
index 0000000000..8fc4078166
Binary files /dev/null and b/tests/data/lightning_mini.heif differ
diff --git a/tests/data/rgb_generic_compressed_brotli.heif b/tests/data/rgb_generic_compressed_brotli.heif
new file mode 100644
index 0000000000..8d44e6e2b6
Binary files /dev/null and b/tests/data/rgb_generic_compressed_brotli.heif differ
diff --git a/tests/data/rgb_generic_compressed_defl.heif b/tests/data/rgb_generic_compressed_defl.heif
new file mode 100644
index 0000000000..580e5848a3
Binary files /dev/null and b/tests/data/rgb_generic_compressed_defl.heif differ
diff --git a/tests/data/rgb_generic_compressed_tile_deflate.heif b/tests/data/rgb_generic_compressed_tile_deflate.heif
new file mode 100644
index 0000000000..7c2acae025
Binary files /dev/null and b/tests/data/rgb_generic_compressed_tile_deflate.heif differ
diff --git a/tests/data/rgb_generic_compressed_zlib.heif b/tests/data/rgb_generic_compressed_zlib.heif
new file mode 100644
index 0000000000..d7c4a8be6a
Binary files /dev/null and b/tests/data/rgb_generic_compressed_zlib.heif differ
diff --git a/tests/data/rgb_generic_compressed_zlib_rows.heif b/tests/data/rgb_generic_compressed_zlib_rows.heif
new file mode 100644
index 0000000000..76a7692681
Binary files /dev/null and b/tests/data/rgb_generic_compressed_zlib_rows.heif differ
diff --git a/tests/data/rgb_generic_compressed_zlib_tiled.heif b/tests/data/rgb_generic_compressed_zlib_tiled.heif
new file mode 100644
index 0000000000..8532c66bfd
Binary files /dev/null and b/tests/data/rgb_generic_compressed_zlib_tiled.heif differ
diff --git a/tests/data/simple_osm_tile_alpha.avif b/tests/data/simple_osm_tile_alpha.avif
new file mode 100644
index 0000000000..66de47e74f
Binary files /dev/null and b/tests/data/simple_osm_tile_alpha.avif differ
diff --git a/tests/data/simple_osm_tile_meta.avif b/tests/data/simple_osm_tile_meta.avif
new file mode 100644
index 0000000000..9d974a6f3e
Binary files /dev/null and b/tests/data/simple_osm_tile_meta.avif differ
diff --git a/tests/data/uncompressed_comp_ABGR.heif b/tests/data/uncompressed_comp_ABGR.heif
new file mode 100644
index 0000000000..d0a01266eb
Binary files /dev/null and b/tests/data/uncompressed_comp_ABGR.heif differ
diff --git a/tests/data/uncompressed_comp_ABGR_tiled.heif b/tests/data/uncompressed_comp_ABGR_tiled.heif
new file mode 100644
index 0000000000..5e9ed55bcb
Binary files /dev/null and b/tests/data/uncompressed_comp_ABGR_tiled.heif differ
diff --git a/tests/data/uncompressed_comp_B16R16G16.heif b/tests/data/uncompressed_comp_B16R16G16.heif
new file mode 100644
index 0000000000..730106cc10
Binary files /dev/null and b/tests/data/uncompressed_comp_B16R16G16.heif differ
diff --git a/tests/data/uncompressed_comp_B16R16G16_tiled.heif b/tests/data/uncompressed_comp_B16R16G16_tiled.heif
new file mode 100644
index 0000000000..34c55deb40
Binary files /dev/null and b/tests/data/uncompressed_comp_B16R16G16_tiled.heif differ
diff --git a/tests/data/uncompressed_comp_M.heif b/tests/data/uncompressed_comp_M.heif
new file mode 100644
index 0000000000..e6d0c5424e
Binary files /dev/null and b/tests/data/uncompressed_comp_M.heif differ
diff --git a/tests/data/uncompressed_comp_M_tiled.heif b/tests/data/uncompressed_comp_M_tiled.heif
new file mode 100644
index 0000000000..92db9bf779
Binary files /dev/null and b/tests/data/uncompressed_comp_M_tiled.heif differ
diff --git a/tests/data/uncompressed_comp_R5G6B5_tiled.heif b/tests/data/uncompressed_comp_R5G6B5_tiled.heif
new file mode 100644
index 0000000000..07a67a2c5e
Binary files /dev/null and b/tests/data/uncompressed_comp_R5G6B5_tiled.heif differ
diff --git a/tests/data/uncompressed_comp_R7+1G7+1B7+1_tiled.heif b/tests/data/uncompressed_comp_R7+1G7+1B7+1_tiled.heif
new file mode 100644
index 0000000000..d1f4771d72
Binary files /dev/null and b/tests/data/uncompressed_comp_R7+1G7+1B7+1_tiled.heif differ
diff --git a/tests/data/uncompressed_comp_R7G7+1B7_tiled.heif b/tests/data/uncompressed_comp_R7G7+1B7_tiled.heif
new file mode 100644
index 0000000000..d3f4e26f95
Binary files /dev/null and b/tests/data/uncompressed_comp_R7G7+1B7_tiled.heif differ
diff --git a/tests/data/uncompressed_comp_R7G7B7_tiled.heif b/tests/data/uncompressed_comp_R7G7B7_tiled.heif
new file mode 100644
index 0000000000..34e37e899e
Binary files /dev/null and b/tests/data/uncompressed_comp_R7G7B7_tiled.heif differ
diff --git a/tests/data/uncompressed_comp_RGB.heif b/tests/data/uncompressed_comp_RGB.heif
new file mode 100644
index 0000000000..c74129d6fc
Binary files /dev/null and b/tests/data/uncompressed_comp_RGB.heif differ
diff --git a/tests/data/uncompressed_comp_RGB_tiled.heif b/tests/data/uncompressed_comp_RGB_tiled.heif
new file mode 100644
index 0000000000..ab30d7f211
Binary files /dev/null and b/tests/data/uncompressed_comp_RGB_tiled.heif differ
diff --git a/tests/data/uncompressed_comp_RGB_tiled_row_tile_align.heif b/tests/data/uncompressed_comp_RGB_tiled_row_tile_align.heif
new file mode 100644
index 0000000000..602cc850ff
Binary files /dev/null and b/tests/data/uncompressed_comp_RGB_tiled_row_tile_align.heif differ
diff --git a/tests/data/uncompressed_comp_RGxB.heif b/tests/data/uncompressed_comp_RGxB.heif
new file mode 100644
index 0000000000..a6a40778cd
Binary files /dev/null and b/tests/data/uncompressed_comp_RGxB.heif differ
diff --git a/tests/data/uncompressed_comp_RGxB_tiled.heif b/tests/data/uncompressed_comp_RGxB_tiled.heif
new file mode 100644
index 0000000000..3899c91c2f
Binary files /dev/null and b/tests/data/uncompressed_comp_RGxB_tiled.heif differ
diff --git a/tests/data/uncompressed_comp_VUY_420.heif b/tests/data/uncompressed_comp_VUY_420.heif
new file mode 100644
index 0000000000..143b1f3155
Binary files /dev/null and b/tests/data/uncompressed_comp_VUY_420.heif differ
diff --git a/tests/data/uncompressed_comp_VUY_422.heif b/tests/data/uncompressed_comp_VUY_422.heif
new file mode 100644
index 0000000000..53de4201ea
Binary files /dev/null and b/tests/data/uncompressed_comp_VUY_422.heif differ
diff --git a/tests/data/uncompressed_comp_Y16U16V16_420.heif b/tests/data/uncompressed_comp_Y16U16V16_420.heif
new file mode 100644
index 0000000000..412ab1d039
Binary files /dev/null and b/tests/data/uncompressed_comp_Y16U16V16_420.heif differ
diff --git a/tests/data/uncompressed_comp_Y16U16V16_422.heif b/tests/data/uncompressed_comp_Y16U16V16_422.heif
new file mode 100644
index 0000000000..16d71dacb4
Binary files /dev/null and b/tests/data/uncompressed_comp_Y16U16V16_422.heif differ
diff --git a/tests/data/uncompressed_comp_YUV_420.heif b/tests/data/uncompressed_comp_YUV_420.heif
new file mode 100644
index 0000000000..0836a7ea6a
Binary files /dev/null and b/tests/data/uncompressed_comp_YUV_420.heif differ
diff --git a/tests/data/uncompressed_comp_YUV_422.heif b/tests/data/uncompressed_comp_YUV_422.heif
new file mode 100644
index 0000000000..bf4d870095
Binary files /dev/null and b/tests/data/uncompressed_comp_YUV_422.heif differ
diff --git a/tests/data/uncompressed_comp_YUV_tiled.heif b/tests/data/uncompressed_comp_YUV_tiled.heif
new file mode 100644
index 0000000000..54c0d94ce2
Binary files /dev/null and b/tests/data/uncompressed_comp_YUV_tiled.heif differ
diff --git a/tests/data/uncompressed_comp_YVU_420.heif b/tests/data/uncompressed_comp_YVU_420.heif
new file mode 100644
index 0000000000..38afbeaab5
Binary files /dev/null and b/tests/data/uncompressed_comp_YVU_420.heif differ
diff --git a/tests/data/uncompressed_comp_YVU_422.heif b/tests/data/uncompressed_comp_YVU_422.heif
new file mode 100644
index 0000000000..7e3896efc7
Binary files /dev/null and b/tests/data/uncompressed_comp_YVU_422.heif differ
diff --git a/tests/data/uncompressed_mix_VUY_420.heif b/tests/data/uncompressed_mix_VUY_420.heif
new file mode 100644
index 0000000000..d13e101dac
Binary files /dev/null and b/tests/data/uncompressed_mix_VUY_420.heif differ
diff --git a/tests/data/uncompressed_mix_VUY_422.heif b/tests/data/uncompressed_mix_VUY_422.heif
new file mode 100644
index 0000000000..54820e7ca8
Binary files /dev/null and b/tests/data/uncompressed_mix_VUY_422.heif differ
diff --git a/tests/data/uncompressed_mix_Y16U16V16_420.heif b/tests/data/uncompressed_mix_Y16U16V16_420.heif
new file mode 100644
index 0000000000..9b24e1da12
Binary files /dev/null and b/tests/data/uncompressed_mix_Y16U16V16_420.heif differ
diff --git a/tests/data/uncompressed_mix_Y16U16V16_422.heif b/tests/data/uncompressed_mix_Y16U16V16_422.heif
new file mode 100644
index 0000000000..d58817fc01
Binary files /dev/null and b/tests/data/uncompressed_mix_Y16U16V16_422.heif differ
diff --git a/tests/data/uncompressed_mix_YUV_420.heif b/tests/data/uncompressed_mix_YUV_420.heif
new file mode 100644
index 0000000000..98c9425e88
Binary files /dev/null and b/tests/data/uncompressed_mix_YUV_420.heif differ
diff --git a/tests/data/uncompressed_mix_YUV_422.heif b/tests/data/uncompressed_mix_YUV_422.heif
new file mode 100644
index 0000000000..1f5688c313
Binary files /dev/null and b/tests/data/uncompressed_mix_YUV_422.heif differ
diff --git a/tests/data/uncompressed_mix_YVU_420.heif b/tests/data/uncompressed_mix_YVU_420.heif
new file mode 100644
index 0000000000..15770e2953
Binary files /dev/null and b/tests/data/uncompressed_mix_YVU_420.heif differ
diff --git a/tests/data/uncompressed_mix_YVU_422.heif b/tests/data/uncompressed_mix_YVU_422.heif
new file mode 100644
index 0000000000..4a82cbc633
Binary files /dev/null and b/tests/data/uncompressed_mix_YVU_422.heif differ
diff --git a/tests/data/uncompressed_pix_ABGR.heif b/tests/data/uncompressed_pix_ABGR.heif
new file mode 100644
index 0000000000..31bc45bbf6
Binary files /dev/null and b/tests/data/uncompressed_pix_ABGR.heif differ
diff --git a/tests/data/uncompressed_pix_ABGR_tiled.heif b/tests/data/uncompressed_pix_ABGR_tiled.heif
new file mode 100644
index 0000000000..031b908105
Binary files /dev/null and b/tests/data/uncompressed_pix_ABGR_tiled.heif differ
diff --git a/tests/data/uncompressed_pix_B16R16G16.heif b/tests/data/uncompressed_pix_B16R16G16.heif
new file mode 100644
index 0000000000..3b07cc4d78
Binary files /dev/null and b/tests/data/uncompressed_pix_B16R16G16.heif differ
diff --git a/tests/data/uncompressed_pix_B16R16G16_tiled.heif b/tests/data/uncompressed_pix_B16R16G16_tiled.heif
new file mode 100644
index 0000000000..39d1695c1e
Binary files /dev/null and b/tests/data/uncompressed_pix_B16R16G16_tiled.heif differ
diff --git a/tests/data/uncompressed_pix_M.heif b/tests/data/uncompressed_pix_M.heif
new file mode 100644
index 0000000000..2b4c44531f
Binary files /dev/null and b/tests/data/uncompressed_pix_M.heif differ
diff --git a/tests/data/uncompressed_pix_M_tiled.heif b/tests/data/uncompressed_pix_M_tiled.heif
new file mode 100644
index 0000000000..bae5b75c0b
Binary files /dev/null and b/tests/data/uncompressed_pix_M_tiled.heif differ
diff --git a/tests/data/uncompressed_pix_R5G6B5_tiled.heif b/tests/data/uncompressed_pix_R5G6B5_tiled.heif
new file mode 100644
index 0000000000..bb11120608
Binary files /dev/null and b/tests/data/uncompressed_pix_R5G6B5_tiled.heif differ
diff --git a/tests/data/uncompressed_pix_R7+1G7+1B7+1_tiled.heif b/tests/data/uncompressed_pix_R7+1G7+1B7+1_tiled.heif
new file mode 100644
index 0000000000..c77af9b14f
Binary files /dev/null and b/tests/data/uncompressed_pix_R7+1G7+1B7+1_tiled.heif differ
diff --git a/tests/data/uncompressed_pix_R7G7+1B7_tiled.heif b/tests/data/uncompressed_pix_R7G7+1B7_tiled.heif
new file mode 100644
index 0000000000..a2390e4386
Binary files /dev/null and b/tests/data/uncompressed_pix_R7G7+1B7_tiled.heif differ
diff --git a/tests/data/uncompressed_pix_R7G7B7_tiled.heif b/tests/data/uncompressed_pix_R7G7B7_tiled.heif
new file mode 100644
index 0000000000..8bfbe08b6e
Binary files /dev/null and b/tests/data/uncompressed_pix_R7G7B7_tiled.heif differ
diff --git a/tests/data/uncompressed_pix_R8G8B8A8_bsz0_psz10_tiled.heif b/tests/data/uncompressed_pix_R8G8B8A8_bsz0_psz10_tiled.heif
new file mode 100644
index 0000000000..3153cd3c6f
Binary files /dev/null and b/tests/data/uncompressed_pix_R8G8B8A8_bsz0_psz10_tiled.heif differ
diff --git a/tests/data/uncompressed_pix_R8G8B8A8_bsz0_psz5_tiled.heif b/tests/data/uncompressed_pix_R8G8B8A8_bsz0_psz5_tiled.heif
new file mode 100644
index 0000000000..5269301d78
Binary files /dev/null and b/tests/data/uncompressed_pix_R8G8B8A8_bsz0_psz5_tiled.heif differ
diff --git a/tests/data/uncompressed_pix_R8G8B8_bsz0_psz10_tiled.heif b/tests/data/uncompressed_pix_R8G8B8_bsz0_psz10_tiled.heif
new file mode 100644
index 0000000000..862c2b409b
Binary files /dev/null and b/tests/data/uncompressed_pix_R8G8B8_bsz0_psz10_tiled.heif differ
diff --git a/tests/data/uncompressed_pix_R8G8B8_bsz0_psz5_tiled.heif b/tests/data/uncompressed_pix_R8G8B8_bsz0_psz5_tiled.heif
new file mode 100644
index 0000000000..17aebda4bf
Binary files /dev/null and b/tests/data/uncompressed_pix_R8G8B8_bsz0_psz5_tiled.heif differ
diff --git a/tests/data/uncompressed_pix_RGB.heif b/tests/data/uncompressed_pix_RGB.heif
new file mode 100644
index 0000000000..dac85fca2e
Binary files /dev/null and b/tests/data/uncompressed_pix_RGB.heif differ
diff --git a/tests/data/uncompressed_pix_RGB_tiled.heif b/tests/data/uncompressed_pix_RGB_tiled.heif
new file mode 100644
index 0000000000..8eda57d504
Binary files /dev/null and b/tests/data/uncompressed_pix_RGB_tiled.heif differ
diff --git a/tests/data/uncompressed_pix_RGB_tiled_row_tile_align.heif b/tests/data/uncompressed_pix_RGB_tiled_row_tile_align.heif
new file mode 100644
index 0000000000..c2829edff8
Binary files /dev/null and b/tests/data/uncompressed_pix_RGB_tiled_row_tile_align.heif differ
diff --git a/tests/data/uncompressed_pix_RGxB.heif b/tests/data/uncompressed_pix_RGxB.heif
new file mode 100644
index 0000000000..ae8b8d814a
Binary files /dev/null and b/tests/data/uncompressed_pix_RGxB.heif differ
diff --git a/tests/data/uncompressed_pix_RGxB_tiled.heif b/tests/data/uncompressed_pix_RGxB_tiled.heif
new file mode 100644
index 0000000000..d964a29154
Binary files /dev/null and b/tests/data/uncompressed_pix_RGxB_tiled.heif differ
diff --git a/tests/data/uncompressed_pix_YUV_tiled.heif b/tests/data/uncompressed_pix_YUV_tiled.heif
new file mode 100644
index 0000000000..b84f32b091
Binary files /dev/null and b/tests/data/uncompressed_pix_YUV_tiled.heif differ
diff --git a/tests/data/uncompressed_row_ABGR.heif b/tests/data/uncompressed_row_ABGR.heif
new file mode 100644
index 0000000000..5a60fd6ec9
Binary files /dev/null and b/tests/data/uncompressed_row_ABGR.heif differ
diff --git a/tests/data/uncompressed_row_ABGR_tiled.heif b/tests/data/uncompressed_row_ABGR_tiled.heif
new file mode 100644
index 0000000000..896d341b98
Binary files /dev/null and b/tests/data/uncompressed_row_ABGR_tiled.heif differ
diff --git a/tests/data/uncompressed_row_B16R16G16.heif b/tests/data/uncompressed_row_B16R16G16.heif
new file mode 100644
index 0000000000..754d6b8af0
Binary files /dev/null and b/tests/data/uncompressed_row_B16R16G16.heif differ
diff --git a/tests/data/uncompressed_row_B16R16G16_tiled.heif b/tests/data/uncompressed_row_B16R16G16_tiled.heif
new file mode 100644
index 0000000000..8f8db75e5a
Binary files /dev/null and b/tests/data/uncompressed_row_B16R16G16_tiled.heif differ
diff --git a/tests/data/uncompressed_row_M.heif b/tests/data/uncompressed_row_M.heif
new file mode 100644
index 0000000000..130e7cee83
Binary files /dev/null and b/tests/data/uncompressed_row_M.heif differ
diff --git a/tests/data/uncompressed_row_M_tiled.heif b/tests/data/uncompressed_row_M_tiled.heif
new file mode 100644
index 0000000000..05aa7f71ac
Binary files /dev/null and b/tests/data/uncompressed_row_M_tiled.heif differ
diff --git a/tests/data/uncompressed_row_R5G6B5_tiled.heif b/tests/data/uncompressed_row_R5G6B5_tiled.heif
new file mode 100644
index 0000000000..d94e68675d
Binary files /dev/null and b/tests/data/uncompressed_row_R5G6B5_tiled.heif differ
diff --git a/tests/data/uncompressed_row_R7+1G7+1B7+1_tiled.heif b/tests/data/uncompressed_row_R7+1G7+1B7+1_tiled.heif
new file mode 100644
index 0000000000..7b299c0a56
Binary files /dev/null and b/tests/data/uncompressed_row_R7+1G7+1B7+1_tiled.heif differ
diff --git a/tests/data/uncompressed_row_R7G7+1B7_tiled.heif b/tests/data/uncompressed_row_R7G7+1B7_tiled.heif
new file mode 100644
index 0000000000..081b9b1c8c
Binary files /dev/null and b/tests/data/uncompressed_row_R7G7+1B7_tiled.heif differ
diff --git a/tests/data/uncompressed_row_R7G7B7_tiled.heif b/tests/data/uncompressed_row_R7G7B7_tiled.heif
new file mode 100644
index 0000000000..943b60655b
Binary files /dev/null and b/tests/data/uncompressed_row_R7G7B7_tiled.heif differ
diff --git a/tests/data/uncompressed_row_RGB.heif b/tests/data/uncompressed_row_RGB.heif
new file mode 100644
index 0000000000..30c440000e
Binary files /dev/null and b/tests/data/uncompressed_row_RGB.heif differ
diff --git a/tests/data/uncompressed_row_RGB_tiled.heif b/tests/data/uncompressed_row_RGB_tiled.heif
new file mode 100644
index 0000000000..a5d6ebcc5a
Binary files /dev/null and b/tests/data/uncompressed_row_RGB_tiled.heif differ
diff --git a/tests/data/uncompressed_row_RGB_tiled_row_tile_align.heif b/tests/data/uncompressed_row_RGB_tiled_row_tile_align.heif
new file mode 100644
index 0000000000..a9969bec4b
Binary files /dev/null and b/tests/data/uncompressed_row_RGB_tiled_row_tile_align.heif differ
diff --git a/tests/data/uncompressed_row_RGxB.heif b/tests/data/uncompressed_row_RGxB.heif
new file mode 100644
index 0000000000..de274d5c8b
Binary files /dev/null and b/tests/data/uncompressed_row_RGxB.heif differ
diff --git a/tests/data/uncompressed_row_RGxB_tiled.heif b/tests/data/uncompressed_row_RGxB_tiled.heif
new file mode 100644
index 0000000000..e438fc2268
Binary files /dev/null and b/tests/data/uncompressed_row_RGxB_tiled.heif differ
diff --git a/tests/data/uncompressed_row_YUV_tiled.heif b/tests/data/uncompressed_row_YUV_tiled.heif
new file mode 100644
index 0000000000..7238f7fadb
Binary files /dev/null and b/tests/data/uncompressed_row_YUV_tiled.heif differ
diff --git a/tests/data/uncompressed_tile_ABGR_tiled.heif b/tests/data/uncompressed_tile_ABGR_tiled.heif
new file mode 100644
index 0000000000..157944f4bb
Binary files /dev/null and b/tests/data/uncompressed_tile_ABGR_tiled.heif differ
diff --git a/tests/data/uncompressed_tile_B16R16G16_tiled.heif b/tests/data/uncompressed_tile_B16R16G16_tiled.heif
new file mode 100644
index 0000000000..3937184d17
Binary files /dev/null and b/tests/data/uncompressed_tile_B16R16G16_tiled.heif differ
diff --git a/tests/data/uncompressed_tile_M_tiled.heif b/tests/data/uncompressed_tile_M_tiled.heif
new file mode 100644
index 0000000000..07cce7eecd
Binary files /dev/null and b/tests/data/uncompressed_tile_M_tiled.heif differ
diff --git a/tests/data/uncompressed_tile_R5G6B5_tiled.heif b/tests/data/uncompressed_tile_R5G6B5_tiled.heif
new file mode 100644
index 0000000000..8c67f301c7
Binary files /dev/null and b/tests/data/uncompressed_tile_R5G6B5_tiled.heif differ
diff --git a/tests/data/uncompressed_tile_R7+1G7+1B7+1_tiled.heif b/tests/data/uncompressed_tile_R7+1G7+1B7+1_tiled.heif
new file mode 100644
index 0000000000..0c40460788
Binary files /dev/null and b/tests/data/uncompressed_tile_R7+1G7+1B7+1_tiled.heif differ
diff --git a/tests/data/uncompressed_tile_R7G7+1B7_tiled.heif b/tests/data/uncompressed_tile_R7G7+1B7_tiled.heif
new file mode 100644
index 0000000000..3f001eaa12
Binary files /dev/null and b/tests/data/uncompressed_tile_R7G7+1B7_tiled.heif differ
diff --git a/tests/data/uncompressed_tile_R7G7B7_tiled.heif b/tests/data/uncompressed_tile_R7G7B7_tiled.heif
new file mode 100644
index 0000000000..a0d51e6172
Binary files /dev/null and b/tests/data/uncompressed_tile_R7G7B7_tiled.heif differ
diff --git a/tests/data/uncompressed_tile_RGB_tiled.heif b/tests/data/uncompressed_tile_RGB_tiled.heif
new file mode 100644
index 0000000000..d4adc501da
Binary files /dev/null and b/tests/data/uncompressed_tile_RGB_tiled.heif differ
diff --git a/tests/data/uncompressed_tile_RGB_tiled_row_tile_align.heif b/tests/data/uncompressed_tile_RGB_tiled_row_tile_align.heif
new file mode 100644
index 0000000000..dc8f38484b
Binary files /dev/null and b/tests/data/uncompressed_tile_RGB_tiled_row_tile_align.heif differ
diff --git a/tests/data/uncompressed_tile_RGxB_tiled.heif b/tests/data/uncompressed_tile_RGxB_tiled.heif
new file mode 100644
index 0000000000..68a29d1877
Binary files /dev/null and b/tests/data/uncompressed_tile_RGxB_tiled.heif differ
diff --git a/tests/data/uncompressed_tile_YUV_tiled.heif b/tests/data/uncompressed_tile_YUV_tiled.heif
new file mode 100644
index 0000000000..3b965e6c32
Binary files /dev/null and b/tests/data/uncompressed_tile_YUV_tiled.heif differ
diff --git a/tests/encode.cc b/tests/encode.cc
index 3671f1216d..2213e26e77 100644
--- a/tests/encode.cc
+++ b/tests/encode.cc
@@ -3,7 +3,7 @@
 
   MIT License
 
-  Copyright (c) 2019 struktur AG, Dirk Farin <farin@struktur.de>
+  Copyright (c) 2019 Dirk Farin <dirk.farin@gmail.com>
 
   Permission is hereby granted, free of charge, to any person obtaining a copy
   of this software and associated documentation files (the "Software"), to deal
@@ -24,13 +24,18 @@
   SOFTWARE.
 */
 
-#include "catch.hpp"
+#include "catch_amalgamated.hpp"
 #include "libheif/heif.h"
+#include "pixelimage.h"
+#include "api_structs.h"
+#include "test_utils.h"
 
+#include <string.h>
 
-struct heif_image* createImage_RRGGBB_BE() {
-  struct heif_image* image;
-  struct heif_error err;
+
+heif_image* createImage_RRGGBB_BE() {
+  heif_image* image;
+  heif_error err;
   err = heif_image_create(256,256,
                           heif_colorspace_RGB,
                           heif_chroma_interleaved_RRGGBB_BE,
@@ -51,22 +56,15 @@ struct heif_image* createImage_RRGGBB_BE() {
 }
 
 
-struct heif_error encode_image(struct heif_image* img) {
-  struct heif_context* ctx = heif_context_alloc();
+heif_error encode_image(heif_image* img) {
+  heif_context* ctx = heif_context_alloc();
 
-  struct heif_encoder* enc;
-  struct heif_error err { heif_error_Ok };
-
-  err = heif_context_get_encoder_for_format(ctx,
-                                            heif_compression_HEVC,
-                                            &enc);
-  if (err.code) {
-    heif_context_free(ctx);
-    return err;
-  }
+  heif_encoder* enc = nullptr;
+  heif_error err { heif_error_Ok };
 
+  enc = get_encoder_or_skip_test(heif_compression_HEVC);
 
-  struct heif_image_handle* hdl;
+  heif_image_handle* hdl;
   err = heif_context_encode_image(ctx,
                                   img,
                                   enc,
@@ -78,6 +76,9 @@ struct heif_error encode_image(struct heif_image* img) {
     return err;
   }
 
+  heif_encoder_release(enc);
+  heif_image_handle_release(hdl);
+  heif_context_free(ctx);
   return err;
 }
 
@@ -101,3 +102,57 @@ TEST_CASE( "Encode HDR", "[heif_encoder]" ) {
   heif_image_release(img);
 }
 #endif
+
+static void test_ispe_size(heif_compression_format compression,
+                           heif_orientation orientation,
+                           int input_width, int input_height,
+                           int expected_minimum_ispe_width, int expected_minimum_ispe_height)
+{
+  heif_image* img;
+  heif_image_create(input_width,input_height, heif_colorspace_YCbCr, heif_chroma_420, &img);
+  fill_new_plane(img, heif_channel_Y, input_width, input_height);
+  fill_new_plane(img, heif_channel_Cb, (input_width+1)/2, (input_height+1)/2);
+  fill_new_plane(img, heif_channel_Cr, (input_width+1)/2, (input_height+1)/2);
+
+  heif_context* ctx = heif_context_alloc();
+  heif_encoder* enc = get_encoder_or_skip_test(compression);
+
+  heif_encoding_options* options;
+  options = heif_encoding_options_alloc();
+  options->macOS_compatibility_workaround = false;
+  options->macOS_compatibility_workaround_no_nclx_profile = false;
+  options->image_orientation = orientation;
+
+  heif_image_handle* handle;
+  heif_error err = heif_context_encode_image(ctx, img, enc, options, &handle);
+  UNSCOPED_INFO("heif_context_encode_image: " << err.message);
+  REQUIRE(err.code == heif_error_Ok);
+
+  int ispe_width = heif_image_handle_get_ispe_width(handle);
+  int ispe_height = heif_image_handle_get_ispe_height(handle);
+
+  REQUIRE(ispe_width >= expected_minimum_ispe_width);
+  REQUIRE(ispe_height >= expected_minimum_ispe_height);
+
+  heif_image_handle_release(handle);
+  heif_encoder_release(enc);
+  heif_encoding_options_free(options);
+  heif_context_free(ctx);
+  heif_image_release(img);
+}
+
+
+TEST_CASE( "ispe odd size", "[heif_context]" ) {
+
+  // HEVC encoders typically encode with even dimensions only
+  test_ispe_size(heif_compression_HEVC, heif_orientation_normal, 121,99, 122,100);
+  test_ispe_size(heif_compression_HEVC, heif_orientation_rotate_180, 121,99, 122,100);
+  test_ispe_size(heif_compression_HEVC, heif_orientation_rotate_90_cw, 121,99, 122,100);
+  test_ispe_size(heif_compression_HEVC, heif_orientation_rotate_90_cw, 120,100, 120,100);
+
+  // AVIF encoders typically encode with odd dimensions
+  test_ispe_size(heif_compression_AV1, heif_orientation_normal, 121,99, 121,99);
+  test_ispe_size(heif_compression_AV1, heif_orientation_rotate_180, 121,99, 121,99);
+  test_ispe_size(heif_compression_AV1, heif_orientation_rotate_90_cw, 121,99, 121,99);
+  test_ispe_size(heif_compression_AV1, heif_orientation_rotate_90_cw, 120,100, 120,100);
+}
diff --git a/tests/encode_htj2k.cc b/tests/encode_htj2k.cc
new file mode 100644
index 0000000000..295a3a056a
--- /dev/null
+++ b/tests/encode_htj2k.cc
@@ -0,0 +1,85 @@
+/*
+  libheif unit tests
+
+  MIT License
+
+  Copyright (c) 2023 Brad Hards <bradh@frogmouth.net>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#include "catch_amalgamated.hpp"
+#include "libheif/heif.h"
+#include "api_structs.h"
+#include "pixelimage.h"
+
+#include "test_utils.h"
+
+#include <string.h>
+
+static heif_encoding_options * get_encoding_options()
+{
+  heif_encoding_options * options = heif_encoding_options_alloc();
+  options->macOS_compatibility_workaround = false;
+  options->macOS_compatibility_workaround_no_nclx_profile = true;
+  options->image_orientation = heif_orientation_normal;
+  return options;
+}
+
+static void do_encode(heif_image* input_image, const char* filename, bool lossless)
+{
+  REQUIRE(input_image != nullptr);
+
+  heif_context *ctx = heif_context_alloc();
+  heif_encoder *encoder;
+  heif_error err;
+  err = heif_context_get_encoder_for_format(ctx, heif_compression_HTJ2K, &encoder);
+  REQUIRE(err.code == heif_error_Ok);
+
+  err = heif_encoder_set_lossless(encoder, lossless);
+  REQUIRE(err.code == heif_error_Ok);
+
+  heif_encoding_options *options = get_encoding_options();
+
+  heif_image_handle *output_image_handle;
+
+  err = heif_context_encode_image(ctx, input_image, encoder, options, &output_image_handle);
+  REQUIRE(err.code == heif_error_Ok);
+  err = heif_context_write_to_file(ctx, filename);
+  REQUIRE(err.code == heif_error_Ok);
+
+  heif_image_handle_release(output_image_handle);
+  heif_encoding_options_free(options);
+  heif_encoder_release(encoder);
+  heif_image_release(input_image);
+
+  heif_context_free(ctx);
+}
+
+TEST_CASE("Encode High Throughput JPEG2000 lossy")
+{
+  heif_image *input_image = createImage_RGB_planar();
+  do_encode(input_image, "encode_htj2k_rgb_lossy.heif", false);
+}
+
+TEST_CASE("Encode High Throughput JPEG2000 lossless")
+{
+  heif_image *input_image = createImage_RGB_planar();
+  do_encode(input_image, "encode_htj2k_rgb_lossless.heif", true);
+}
diff --git a/tests/encode_jpeg2000.cc b/tests/encode_jpeg2000.cc
new file mode 100644
index 0000000000..eb4c4ff332
--- /dev/null
+++ b/tests/encode_jpeg2000.cc
@@ -0,0 +1,86 @@
+/*
+  libheif unit tests
+
+  MIT License
+
+  Copyright (c) 2023 Brad Hards <bradh@frogmouth.net>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#include "catch_amalgamated.hpp"
+#include "libheif/heif.h"
+#include "api_structs.h"
+#include "pixelimage.h"
+
+#include "test_utils.h"
+
+#include <string.h>
+
+static heif_encoding_options * set_encoding_options()
+{
+  heif_encoding_options * options = heif_encoding_options_alloc();
+  options->macOS_compatibility_workaround = false;
+  options->macOS_compatibility_workaround_no_nclx_profile = true;
+  options->image_orientation = heif_orientation_normal;
+  return options;
+}
+
+static void do_encode(heif_image* input_image, const char* filename, bool lossless)
+{
+  REQUIRE(input_image != nullptr);
+  heif_init(nullptr);
+  heif_context *ctx = heif_context_alloc();
+  heif_encoder *encoder;
+  heif_error err;
+  err = heif_context_get_encoder_for_format(ctx, heif_compression_JPEG2000, &encoder);
+  REQUIRE(err.code == heif_error_Ok);
+
+  err = heif_encoder_set_lossless(encoder, lossless);
+  REQUIRE(err.code == heif_error_Ok);
+
+  heif_encoding_options *options = set_encoding_options();
+
+  heif_image_handle *output_image_handle;
+
+  err = heif_context_encode_image(ctx, input_image, encoder, options, &output_image_handle);
+  REQUIRE(err.code == heif_error_Ok);
+  err = heif_context_write_to_file(ctx, filename);
+  REQUIRE(err.code == heif_error_Ok);
+
+  heif_image_handle_release(output_image_handle);
+  heif_encoding_options_free(options);
+  heif_encoder_release(encoder);
+  heif_image_release(input_image);
+
+  heif_context_free(ctx);
+  heif_deinit();
+}
+
+TEST_CASE("Encode JPEG2000 lossy")
+{
+  heif_image *input_image = createImage_RGB_planar();
+  do_encode(input_image, "encode_j2k_rgb_lossy.heif", false);
+}
+
+TEST_CASE("Encode JPEG2000 lossless")
+{
+  heif_image *input_image = createImage_RGB_planar();
+  do_encode(input_image, "encode_j2k_rgb_lossless.heif", true);
+}
diff --git a/tests/extended_type.cc b/tests/extended_type.cc
new file mode 100644
index 0000000000..39a3609a63
--- /dev/null
+++ b/tests/extended_type.cc
@@ -0,0 +1,93 @@
+/*
+  libheif integration tests for extended type (uuid) boxes
+
+  MIT License
+
+  Copyright (c) 2024 Brad Hards <bradh@frogmouth.net>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#include "catch_amalgamated.hpp"
+#include "api_structs.h"
+#include "libheif/heif.h"
+#include "test-config.h"
+#include "test_utils.h"
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+
+
+TEST_CASE("make extended type") {
+  heif_image *input_image = createImage_RGB_planar();
+  heif_init(nullptr);
+  heif_context *ctx = heif_context_alloc();
+  heif_encoder *encoder;
+  heif_error err;
+  encoder = get_encoder_or_skip_test(heif_compression_HEVC);
+
+  heif_encoding_options *options = heif_encoding_options_alloc();
+
+  heif_image_handle *output_image_handle;
+
+  err = heif_context_encode_image(ctx, input_image, encoder, nullptr, &output_image_handle);
+  UNSCOPED_INFO("heif_context_encode_image: " << err.message);
+  REQUIRE(err.code == heif_error_Ok);
+
+  heif_item_id itemId;
+  err = heif_context_get_primary_image_ID(ctx, &itemId);
+  REQUIRE(err.code == heif_error_Ok);
+
+  const uint8_t uuid[] = {0x13, 0x7a, 0x17, 0x42, 0x75, 0xac, 0x47, 0x47, 0x82, 0xbc, 0x65, 0x95, 0x76, 0xe8, 0x67, 0x5b};
+  std::vector<uint8_t> body {0x00, 0x00, 0x00, 0x01, 0xfa, 0xde, 0x99, 0x04};
+  heif_property_id propertyId;
+  err = heif_item_add_raw_property(ctx, itemId, heif_item_property_type_uuid, &uuid[0], body.data(), body.size(), 0, &propertyId);
+  REQUIRE(err.code == heif_error_Ok);
+  REQUIRE(propertyId == 4);
+  err = heif_context_write_to_file(ctx, "with_uuid.heif");
+  REQUIRE(err.code == heif_error_Ok);
+
+  uint8_t extended_type[16];
+  err = heif_item_get_property_uuid_type(ctx, itemId, propertyId, &extended_type[0]);
+  REQUIRE(err.code == heif_error_Ok);
+  for (int i = 0; i < 16; i++) {
+    REQUIRE(extended_type[i] == uuid[i]);
+  }
+
+  size_t size = 0;
+  err = heif_item_get_property_raw_size(ctx, itemId, propertyId, &size);
+  REQUIRE(err.code == heif_error_Ok);
+  REQUIRE(size == 8);
+
+  uint8_t data[8];
+  err = heif_item_get_property_raw_data(ctx, itemId, propertyId, &data[0]);
+  REQUIRE(err.code == heif_error_Ok);
+  for (int i = 0; i < 8; i++) {
+    REQUIRE(data[i] == body[i]);
+  }
+
+  heif_image_handle_release(output_image_handle);
+  heif_encoding_options_free(options);
+  heif_encoder_release(encoder);
+  heif_image_release(input_image);
+
+  heif_context_free(ctx);
+  heif_deinit();
+}
+
diff --git a/tests/file_layout.cc b/tests/file_layout.cc
new file mode 100644
index 0000000000..4daf3322fe
--- /dev/null
+++ b/tests/file_layout.cc
@@ -0,0 +1,49 @@
+/*
+  libheif integration tests for uncompressed decoder
+
+  MIT License
+
+  Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+#include "catch_amalgamated.hpp"
+#include "libheif/heif.h"
+#include "api_structs.h"
+#include <cstdint>
+#include <stdio.h>
+#include "test_utils.h"
+#include <string.h>
+#include "file_layout.h"
+#include "test-config.h"
+
+#include <fstream>
+
+
+TEST_CASE("parse file layout") {
+  auto istr = std::unique_ptr<std::istream>(new std::ifstream(tests_data_directory + "/uncompressed_comp_ABGR.heif", std::ios::binary));
+  auto reader = std::make_shared<StreamReader_istream>(std::move(istr));
+
+  FileLayout file;
+  Error err = file.read(reader, heif_get_global_security_limits());
+
+  REQUIRE(err.error_code == heif_error_Ok);
+
+  // TODO: read file where 'meta' box is not the first one after 'ftyp'
+}
diff --git a/tests/idat.cc b/tests/idat.cc
new file mode 100644
index 0000000000..af2415db94
--- /dev/null
+++ b/tests/idat.cc
@@ -0,0 +1,51 @@
+/*
+  libheif Item Data Box (idat) unit tests
+
+  MIT License
+
+  Copyright (c) 2023 Brad Hards <bradh@frogmouth.net>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#include "catch_amalgamated.hpp"
+#include "box.h"
+#include <cstdint>
+#include <iostream>
+
+TEST_CASE("idat bad") {
+  std::vector<uint8_t> testData{0x00, 0x00, 0x00, 0x00, 'i',
+                                'd',  'a',  't',  0x65};
+  auto reader = std::make_shared<StreamReader_memory>(testData.data(),
+                                                      testData.size(), false);
+
+  BitstreamRange range(reader, testData.size());
+  for (;;) {
+    std::shared_ptr<Box> box;
+    Error error = Box::read(range, &box, heif_get_global_security_limits());
+    if (error != Error::Ok || range.error()) {
+      break;
+    }
+
+    box->get_type();
+    box->get_type_string();
+    Indent indent;
+    box->dump(indent);
+  }
+}
diff --git a/tests/jpeg2000.cc b/tests/jpeg2000.cc
new file mode 100644
index 0000000000..fa7e384c4e
--- /dev/null
+++ b/tests/jpeg2000.cc
@@ -0,0 +1,729 @@
+/*
+  libheif JPEG 2000 unit tests
+
+  MIT License
+
+  Copyright (c) 2023 Brad Hards <bradh@frogmouth.net>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#include "catch_amalgamated.hpp"
+#include "libheif/heif.h"
+#include "codecs/jpeg2000_boxes.h"
+#include <cstdint>
+#include <iostream>
+
+
+TEST_CASE( "cdef" )
+{
+    std::shared_ptr<Box_cdef> cdef = std::make_shared<Box_cdef>();
+    REQUIRE(cdef->get_channels().size() == 0);
+    Box_cdef::Channel channel;
+    channel.channel_index = 1;
+    channel.channel_type = 2;
+    channel.channel_association = 0;
+    cdef->add_channel(channel);
+    REQUIRE(cdef->get_channels().size() == 1);
+    REQUIRE(cdef->get_channels()[0].channel_index == 1);
+    REQUIRE(cdef->get_channels()[0].channel_type == 2);
+    REQUIRE(cdef->get_channels()[0].channel_association == 0);
+
+    StreamWriter writer;
+    Error err = cdef->write(writer);
+    REQUIRE(err.error_code == heif_error_Ok);
+    const std::vector<uint8_t> bytes = writer.get_data();
+    std::vector<uint8_t> expected = {0x00, 0x00, 0x00, 0x10, 'c', 'd', 'e', 'f', 0x00, 0x01, 0x00, 0x01, 0x00, 0x02, 0x00, 0x00};
+    REQUIRE(bytes == expected);
+
+    Indent indent;
+    std::string dump_output = cdef->dump(indent);
+    REQUIRE(dump_output == "Box: cdef -----\nsize: 0   (header size: 0)\nchannel_index: 1, channel_type: 2, channel_association: 0\n");
+}
+
+TEST_CASE( "cmap" )
+{
+    std::shared_ptr<Box_cmap> cmap = std::make_shared<Box_cmap>();
+    REQUIRE(cmap->get_components().size() == 0);
+    Box_cmap::Component component;
+    component.component_index = 2;
+    component.mapping_type = 1;
+    component.palette_colour = 3;
+    cmap->add_component(component);
+    Box_cmap::Component component2;
+    component2.component_index = 4;
+    component2.mapping_type = 0;
+    component2.palette_colour = 0;
+    cmap->add_component(component2);
+
+    REQUIRE(cmap->get_components().size() == 2);
+    REQUIRE(cmap->get_components()[0].component_index == 2);
+    REQUIRE(cmap->get_components()[0].mapping_type == 1);
+    REQUIRE(cmap->get_components()[0].palette_colour == 3);
+    REQUIRE(cmap->get_components()[1].component_index == 4);
+    REQUIRE(cmap->get_components()[1].mapping_type == 0);
+    REQUIRE(cmap->get_components()[1].palette_colour == 0);
+    StreamWriter writer;
+    Error err = cmap->write(writer);
+    REQUIRE(err.error_code == heif_error_Ok);
+    const std::vector<uint8_t> bytes = writer.get_data();
+    std::vector<uint8_t> expected = {0x00, 0x00, 0x00, 0x10, 'c', 'm', 'a', 'p', 0x00, 0x02, 0x01, 0x03, 0x00, 0x04, 0x00, 0x00};
+    REQUIRE(bytes == expected);
+
+    Indent indent;
+    std::string dump_output = cmap->dump(indent);
+    REQUIRE(dump_output == "Box: cmap -----\nsize: 0   (header size: 0)\ncomponent_index: 2, mapping_type: 1, palette_colour: 3\ncomponent_index: 4, mapping_type: 0, palette_colour: 0\n");
+}
+
+TEST_CASE( "pclr empty" )
+{
+    std::shared_ptr<Box_pclr> pclr = std::make_shared<Box_pclr>();
+    REQUIRE(pclr->get_entries().size() == 0);
+    REQUIRE(pclr->get_num_entries() == 0);
+    REQUIRE(pclr->get_num_columns() == 0);
+    REQUIRE(pclr->get_bit_depths().size() == 0);
+
+    Indent indent;
+    std::string dump_output = pclr->dump(indent);
+    REQUIRE(dump_output == "Box: pclr -----\nsize: 0   (header size: 0)\nNE: 0, NPC: 0, B: \n");
+
+    StreamWriter writer;
+    Error err = pclr->write(writer);
+    REQUIRE(err.error_code == heif_error_Ok);
+    const std::vector<uint8_t> bytes = writer.get_data();
+    REQUIRE(bytes.size() == 0);
+}
+
+TEST_CASE( "pclr" )
+{
+    std::shared_ptr<Box_pclr> pclr = std::make_shared<Box_pclr>();
+    pclr->set_columns(3, 8);
+    Box_pclr::PaletteEntry entry0;
+    entry0.columns = std::vector<uint16_t> { 1, 2, 3};
+    pclr->add_entry(entry0);
+    Box_pclr::PaletteEntry entry1;
+    entry1.columns = std::vector<uint16_t> { 255, 254, 253};
+    pclr->add_entry(entry1);
+    REQUIRE(pclr->get_entries().size() == 2);
+    REQUIRE(pclr->get_num_entries() == 2);
+    REQUIRE(pclr->get_num_columns() == 3);
+    REQUIRE(pclr->get_bit_depths().size() == 3);
+    REQUIRE(pclr->get_bit_depths()[0] == 8);
+    REQUIRE(pclr->get_bit_depths()[1] == 8);
+    REQUIRE(pclr->get_bit_depths()[2] == 8);
+    StreamWriter writer;
+    Error err = pclr->write(writer);
+    REQUIRE(err.error_code == heif_error_Ok);
+    const std::vector<uint8_t> bytes = writer.get_data();
+    std::vector<uint8_t> expected = {0x00, 0x00, 0x00, 0x14, 'p', 'c', 'l', 'r', 0x00, 0x02, 0x03, 0x08, 0x08, 0x08, 0x01, 0x02, 0x03, 0xFF, 0xFE, 0xFD};
+    REQUIRE(bytes == expected);
+    Indent indent;
+    std::string dump_output = pclr->dump(indent);
+    REQUIRE(dump_output == "Box: pclr -----\nsize: 0   (header size: 0)\nNE: 2, NPC: 3, B: 8, 8, 8, \n");
+}
+
+TEST_CASE( "pclr 12 bit" )
+{
+    std::shared_ptr<Box_pclr> pclr = std::make_shared<Box_pclr>();
+    pclr->set_columns(3, 12);
+    Box_pclr::PaletteEntry entry0;
+    entry0.columns = std::vector<uint16_t> { 1, 2, 3};
+    pclr->add_entry(entry0);
+    Box_pclr::PaletteEntry entry1;
+    entry1.columns = std::vector<uint16_t> { 4095, 4094, 4093};
+    pclr->add_entry(entry1);
+    REQUIRE(pclr->get_entries().size() == 2);
+    REQUIRE(pclr->get_num_entries() == 2);
+    REQUIRE(pclr->get_num_columns() == 3);
+    REQUIRE(pclr->get_bit_depths().size() == 3);
+    REQUIRE(pclr->get_bit_depths()[0] == 12);
+    REQUIRE(pclr->get_bit_depths()[1] == 12);
+    REQUIRE(pclr->get_bit_depths()[2] == 12);
+    StreamWriter writer;
+    Error err = pclr->write(writer);
+    REQUIRE(err.error_code == heif_error_Ok);
+    const std::vector<uint8_t> bytes = writer.get_data();
+    std::vector<uint8_t> expected = {0x00, 0x00, 0x00, 0x1A, 'p', 'c', 'l', 'r', 0x00, 0x02, 0x03, 0x0C, 0x0C, 0x0C, 0x00, 0x01, 0x00, 0x02, 0x00, 0x03, 0x0F, 0xFF, 0x0F, 0xFE, 0x0F, 0xFD};
+    REQUIRE(bytes == expected);
+    Indent indent;
+    std::string dump_output = pclr->dump(indent);
+    REQUIRE(dump_output == "Box: pclr -----\nsize: 0   (header size: 0)\nNE: 2, NPC: 3, B: 12, 12, 12, \n");
+}
+
+TEST_CASE( "j2kL" )
+{
+    std::shared_ptr<Box_j2kL> j2kL = std::make_shared<Box_j2kL>();
+    REQUIRE(j2kL->get_layers().size() == 0);
+    Box_j2kL::Layer layer;
+    layer.layer_id = 1;
+    layer.discard_levels = 2;
+    layer.decode_layers = 3;
+    j2kL->add_layer(layer);
+    REQUIRE(j2kL->get_layers().size() == 1);
+    REQUIRE(j2kL->get_layers()[0].layer_id == 1);
+    REQUIRE(j2kL->get_layers()[0].discard_levels == 2);
+    REQUIRE(j2kL->get_layers()[0].decode_layers == 3);
+
+    StreamWriter writer;
+    Error err = j2kL->write(writer);
+    REQUIRE(err.error_code == heif_error_Ok);
+    const std::vector<uint8_t> bytes = writer.get_data();
+    std::vector<uint8_t> expected = {0x00, 0x00, 0x00, 0x13, 'j', '2', 'k', 'L', 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x02, 0x00, 0x03};
+    REQUIRE(bytes == expected);
+
+    Indent indent;
+    std::string dump_output = j2kL->dump(indent);
+    REQUIRE(dump_output == "Box: j2kL -----\nsize: 0   (header size: 0)\nlayer_id: 1, discard_levels: 2, decode_layers: 3\n");
+}
+
+
+TEST_CASE( "codestream too short for SOC" )
+{
+    std::vector<uint8_t> data = {0xFF};
+    JPEG2000MainHeader uut;
+    uut.setHeaderData(data);
+    Error err = uut.doParse();
+    REQUIRE(err.error_code == heif_error_Invalid_input);
+    REQUIRE(err.sub_error_code == heif_suberror_Invalid_J2K_codestream);
+}
+
+
+TEST_CASE( "codestream missing SOC" )
+{
+    std::vector<uint8_t> data = {0xFF, 0x4E};
+    JPEG2000MainHeader uut;
+    uut.setHeaderData(data);
+    Error err = uut.doParse();
+    REQUIRE(err.error_code == heif_error_Invalid_input);
+    REQUIRE(err.sub_error_code == heif_suberror_Invalid_J2K_codestream);
+}
+
+TEST_CASE( "codestream too short for SIZ body" )
+{
+    std::vector<uint8_t> data = {0xFF, 0x4F, 0xFF, 0x51};
+    JPEG2000MainHeader uut;
+    uut.setHeaderData(data);
+    Error err = uut.doParse();
+    REQUIRE(err.error_code == heif_error_Invalid_input);
+    REQUIRE(err.sub_error_code == heif_suberror_Invalid_J2K_codestream);
+}
+
+TEST_CASE( "codestream - COD + SIZ" )
+{
+    // This data is a subset of the example in ISO/IEC 15444-1:2019 Section J.10.1 "Main header"
+    std::vector<uint8_t> data = {
+    0xFF, 0x4F, 0xFF, 0x51, 0x00, 0x29, 0x00, 0x00,   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   0x00, 0x01, 0x07, 0x01, 0x01, 0xFF, 0x5C, 0x00,
+    };
+    JPEG2000MainHeader uut;
+    uut.setHeaderData(data);
+    Error err = uut.doParse();
+    REQUIRE(err.error_code == heif_error_Ok);
+    REQUIRE(uut.get_SIZ().reference_grid_width == 1);
+    REQUIRE(uut.get_SIZ().reference_grid_height == 9);
+    REQUIRE(uut.get_SIZ().image_horizontal_offset == 0);
+    REQUIRE(uut.get_SIZ().image_vertical_offset == 0);
+    REQUIRE(uut.get_SIZ().tile_width == 1);
+    REQUIRE(uut.get_SIZ().tile_height == 9);
+    REQUIRE(uut.get_SIZ().tile_offset_x == 0);
+    REQUIRE(uut.get_SIZ().tile_offset_y == 0);
+    REQUIRE(uut.get_SIZ().components.size() == 1);
+    REQUIRE(uut.get_SIZ().components[0].precision == 8);
+    REQUIRE(uut.get_SIZ().components[0].is_signed == false);
+    REQUIRE(uut.get_SIZ().components[0].h_separation == 1);
+    REQUIRE(uut.get_SIZ().components[0].v_separation == 1);
+    REQUIRE(uut.get_chroma_format() == heif_chroma_monochrome);
+    REQUIRE(uut.get_precision(0) == 8);
+    REQUIRE(uut.hasHighThroughputExtension() == false);
+}
+
+TEST_CASE( "codestream - COD + SIZ first plane subsampled" )
+{
+    // This data is a subset of the example in ISO/IEC 15444-1:2019 Section J.10.1 "Main header"
+    // with modifications
+    std::vector<uint8_t> data = {
+    0xFF, 0x4F, 0xFF, 0x51, 0x00, 0x29, 0x00, 0x00,   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   0x00, 0x01, 0x07, 0x01, 0x02, 0xFF, 0x5C, 0x00,
+    };
+    JPEG2000MainHeader uut;
+    uut.setHeaderData(data);
+    Error err = uut.doParse();
+    REQUIRE(err.error_code == heif_error_Ok);
+    REQUIRE(uut.get_SIZ().reference_grid_width == 1);
+    REQUIRE(uut.get_SIZ().reference_grid_height == 9);
+    REQUIRE(uut.get_SIZ().image_horizontal_offset == 0);
+    REQUIRE(uut.get_SIZ().image_vertical_offset == 0);
+    REQUIRE(uut.get_SIZ().tile_width == 1);
+    REQUIRE(uut.get_SIZ().tile_height == 9);
+    REQUIRE(uut.get_SIZ().tile_offset_x == 0);
+    REQUIRE(uut.get_SIZ().tile_offset_y == 0);
+    REQUIRE(uut.get_SIZ().components.size() == 1);
+    REQUIRE(uut.get_SIZ().components[0].precision == 8);
+    REQUIRE(uut.get_SIZ().components[0].is_signed == false);
+    REQUIRE(uut.get_SIZ().components[0].h_separation == 1);
+    REQUIRE(uut.get_SIZ().components[0].v_separation == 2);
+    REQUIRE(uut.get_chroma_format() == heif_chroma_undefined);
+    REQUIRE(uut.get_precision(0) == 8);
+    REQUIRE(uut.hasHighThroughputExtension() == false);
+}
+
+TEST_CASE( "codestream - COD + SIZ 4:4:4" )
+{
+    // This data is a subset of the example in ISO/IEC 15444-1:2019 Section J.10.1 "Main header"
+    // with modifications
+    std::vector<uint8_t> data = {
+    0xFF, 0x4F, 0xFF, 0x51, 0x00, 0x2F, 0x00, 0x00,   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   0x00, 0x03, 0x07, 0x01, 0x01, 0x06, 0x01, 0x01,
+    0x05, 0x01, 0x01, 0xFF, 0x5C, 0x00,
+    };
+    JPEG2000MainHeader uut;
+    uut.setHeaderData(data);
+    Error err = uut.doParse();
+    REQUIRE(err.error_code == heif_error_Ok);
+    REQUIRE(uut.get_SIZ().reference_grid_width == 1);
+    REQUIRE(uut.get_SIZ().reference_grid_height == 9);
+    REQUIRE(uut.get_SIZ().image_horizontal_offset == 0);
+    REQUIRE(uut.get_SIZ().image_vertical_offset == 0);
+    REQUIRE(uut.get_SIZ().tile_width == 1);
+    REQUIRE(uut.get_SIZ().tile_height == 9);
+    REQUIRE(uut.get_SIZ().tile_offset_x == 0);
+    REQUIRE(uut.get_SIZ().tile_offset_y == 0);
+    REQUIRE(uut.get_SIZ().components.size() == 3);
+    REQUIRE(uut.get_SIZ().components[0].precision == 8);
+    REQUIRE(uut.get_SIZ().components[0].is_signed == false);
+    REQUIRE(uut.get_SIZ().components[0].h_separation == 1);
+    REQUIRE(uut.get_SIZ().components[0].v_separation == 1);
+    REQUIRE(uut.get_SIZ().components[1].precision == 7);
+    REQUIRE(uut.get_SIZ().components[1].is_signed == false);
+    REQUIRE(uut.get_SIZ().components[1].h_separation == 1);
+    REQUIRE(uut.get_SIZ().components[1].v_separation == 1);
+    REQUIRE(uut.get_SIZ().components[2].precision == 6);
+    REQUIRE(uut.get_SIZ().components[2].is_signed == false);
+    REQUIRE(uut.get_SIZ().components[2].h_separation == 1);
+    REQUIRE(uut.get_SIZ().components[2].v_separation == 1);
+    REQUIRE(uut.get_chroma_format() == heif_chroma_444);
+    REQUIRE(uut.get_precision(0) == 8);
+    REQUIRE(uut.get_precision(1) == 7);
+    REQUIRE(uut.get_precision(2) == 6);
+    REQUIRE(uut.hasHighThroughputExtension() == false);
+}
+
+TEST_CASE( "codestream - COD + SIZ 4:2:2" )
+{
+    // This data is a subset of the example in ISO/IEC 15444-1:2019 Section J.10.1 "Main header"
+    // with modifications
+    std::vector<uint8_t> data = {
+    0xFF, 0x4F, 0xFF, 0x51, 0x00, 0x2F, 0x00, 0x00,   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   0x00, 0x03, 0x07, 0x01, 0x01, 0x07, 0x02, 0x01,
+    0x07, 0x02, 0x01, 0xFF, 0x5C, 0x00,
+    };
+    JPEG2000MainHeader uut;
+    uut.setHeaderData(data);
+    Error err = uut.doParse();
+    REQUIRE(err.error_code == heif_error_Ok);
+    REQUIRE(uut.get_SIZ().reference_grid_width == 1);
+    REQUIRE(uut.get_SIZ().reference_grid_height == 9);
+    REQUIRE(uut.get_SIZ().image_horizontal_offset == 0);
+    REQUIRE(uut.get_SIZ().image_vertical_offset == 0);
+    REQUIRE(uut.get_SIZ().tile_width == 1);
+    REQUIRE(uut.get_SIZ().tile_height == 9);
+    REQUIRE(uut.get_SIZ().tile_offset_x == 0);
+    REQUIRE(uut.get_SIZ().tile_offset_y == 0);
+    REQUIRE(uut.get_SIZ().components.size() == 3);
+    REQUIRE(uut.get_SIZ().components[0].precision == 8);
+    REQUIRE(uut.get_SIZ().components[0].is_signed == false);
+    REQUIRE(uut.get_SIZ().components[0].h_separation == 1);
+    REQUIRE(uut.get_SIZ().components[0].v_separation == 1);
+    REQUIRE(uut.get_SIZ().components[1].precision == 8);
+    REQUIRE(uut.get_SIZ().components[1].is_signed == false);
+    REQUIRE(uut.get_SIZ().components[1].h_separation == 2);
+    REQUIRE(uut.get_SIZ().components[1].v_separation == 1);
+    REQUIRE(uut.get_SIZ().components[2].precision == 8);
+    REQUIRE(uut.get_SIZ().components[2].is_signed == false);
+    REQUIRE(uut.get_SIZ().components[2].h_separation == 2);
+    REQUIRE(uut.get_SIZ().components[2].v_separation == 1);
+    REQUIRE(uut.get_chroma_format() == heif_chroma_422);
+    REQUIRE(uut.get_precision(0) == 8);
+    REQUIRE(uut.get_precision(1) == 8);
+    REQUIRE(uut.get_precision(2) == 8);
+    REQUIRE(uut.hasHighThroughputExtension() == false);
+}
+
+TEST_CASE( "codestream - COD + SIZ 4:2:0" )
+{
+    // This data is a subset of the example in ISO/IEC 15444-1:2019 Section J.10.1 "Main header"
+    // with modifications
+    std::vector<uint8_t> data = {
+    0xFF, 0x4F, 0xFF, 0x51, 0x00, 0x2F, 0x00, 0x00,   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   0x00, 0x03, 0x07, 0x01, 0x01, 0x07, 0x02, 0x02,
+    0x07, 0x02, 0x02, 0xFF, 0x5C, 0x00,
+    };
+    JPEG2000MainHeader uut;
+    uut.setHeaderData(data);
+    Error err = uut.doParse();
+    REQUIRE(err.error_code == heif_error_Ok);
+    REQUIRE(uut.get_SIZ().reference_grid_width == 1);
+    REQUIRE(uut.get_SIZ().reference_grid_height == 9);
+    REQUIRE(uut.get_SIZ().image_horizontal_offset == 0);
+    REQUIRE(uut.get_SIZ().image_vertical_offset == 0);
+    REQUIRE(uut.get_SIZ().tile_width == 1);
+    REQUIRE(uut.get_SIZ().tile_height == 9);
+    REQUIRE(uut.get_SIZ().tile_offset_x == 0);
+    REQUIRE(uut.get_SIZ().tile_offset_y == 0);
+    REQUIRE(uut.get_SIZ().components.size() == 3);
+    REQUIRE(uut.get_SIZ().components[0].precision == 8);
+    REQUIRE(uut.get_SIZ().components[0].is_signed == false);
+    REQUIRE(uut.get_SIZ().components[0].h_separation == 1);
+    REQUIRE(uut.get_SIZ().components[0].v_separation == 1);
+    REQUIRE(uut.get_SIZ().components[1].precision == 8);
+    REQUIRE(uut.get_SIZ().components[1].is_signed == false);
+    REQUIRE(uut.get_SIZ().components[1].h_separation == 2);
+    REQUIRE(uut.get_SIZ().components[1].v_separation == 2);
+    REQUIRE(uut.get_SIZ().components[2].precision == 8);
+    REQUIRE(uut.get_SIZ().components[2].is_signed == false);
+    REQUIRE(uut.get_SIZ().components[2].h_separation == 2);
+    REQUIRE(uut.get_SIZ().components[2].v_separation == 2);
+    REQUIRE(uut.get_chroma_format() == heif_chroma_420);
+    REQUIRE(uut.get_precision(0) == 8);
+    REQUIRE(uut.get_precision(1) == 8);
+    REQUIRE(uut.get_precision(2) == 8);
+    REQUIRE(uut.hasHighThroughputExtension() == false);
+}
+
+
+TEST_CASE( "codestream - COD + SIZ mismatched v subsampling" )
+{
+    // This data is a subset of the example in ISO/IEC 15444-1:2019 Section J.10.1 "Main header"
+    // with modifications
+    std::vector<uint8_t> data = {
+    0xFF, 0x4F, 0xFF, 0x51, 0x00, 0x2F, 0x00, 0x00,   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   0x00, 0x03, 0x07, 0x01, 0x01, 0x07, 0x02, 0x02,
+    0x07, 0x02, 0x01, 0xFF, 0x5C, 0x00,
+    };
+    JPEG2000MainHeader uut;
+    uut.setHeaderData(data);
+    Error err = uut.doParse();
+    REQUIRE(err.error_code == heif_error_Ok);
+    REQUIRE(uut.get_SIZ().components.size() == 3);
+    REQUIRE(uut.get_SIZ().components[1].h_separation == 2);
+    REQUIRE(uut.get_SIZ().components[1].v_separation == 2);
+    REQUIRE(uut.get_SIZ().components[2].h_separation == 2);
+    REQUIRE(uut.get_SIZ().components[2].v_separation == 1);
+    REQUIRE(uut.get_chroma_format() == heif_chroma_undefined);
+}
+
+TEST_CASE( "codestream - COD + SIZ mismatched h subsampling" )
+{
+    // This data is a subset of the example in ISO/IEC 15444-1:2019 Section J.10.1 "Main header"
+    // with modifications
+    std::vector<uint8_t> data = {
+    0xFF, 0x4F, 0xFF, 0x51, 0x00, 0x2F, 0x00, 0x00,   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   0x00, 0x03, 0x07, 0x01, 0x01, 0x07, 0x01, 0x02,
+    0x07, 0x02, 0x02, 0xFF, 0x5C, 0x00,
+    };
+    JPEG2000MainHeader uut;
+    uut.setHeaderData(data);
+    Error err = uut.doParse();
+    REQUIRE(err.error_code == heif_error_Ok);
+    REQUIRE(uut.get_SIZ().components.size() == 3);
+    REQUIRE(uut.get_SIZ().components[1].h_separation == 1);
+    REQUIRE(uut.get_SIZ().components[1].v_separation == 2);
+    REQUIRE(uut.get_SIZ().components[2].h_separation == 2);
+    REQUIRE(uut.get_SIZ().components[2].v_separation == 2);
+    REQUIRE(uut.get_chroma_format() == heif_chroma_undefined);
+}
+
+TEST_CASE( "codestream - COD + SIZ unsupported subsampling" )
+{
+    // This data is a subset of the example in ISO/IEC 15444-1:2019 Section J.10.1 "Main header"
+    // with modifications
+    std::vector<uint8_t> data = {
+    0xFF, 0x4F, 0xFF, 0x51, 0x00, 0x2F, 0x00, 0x00,   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   0x00, 0x03, 0x07, 0x01, 0x01, 0x07, 0x04, 0x01,
+    0x07, 0x04, 0x01, 0xFF, 0x5C, 0x00,
+    };
+    JPEG2000MainHeader uut;
+    uut.setHeaderData(data);
+    Error err = uut.doParse();
+    REQUIRE(err.error_code == heif_error_Ok);
+    REQUIRE(uut.get_SIZ().components.size() == 3);
+    REQUIRE(uut.get_SIZ().components[1].h_separation == 4);
+    REQUIRE(uut.get_SIZ().components[1].v_separation == 1);
+    REQUIRE(uut.get_SIZ().components[2].h_separation == 4);
+    REQUIRE(uut.get_SIZ().components[2].v_separation == 1);
+    REQUIRE(uut.get_chroma_format() == heif_chroma_undefined);
+}
+
+
+TEST_CASE( "codestream wrong marker SIZ" )
+{
+    std::vector<uint8_t> data = {
+    0xFF, 0x4F, 0xFF, 0xEF, 0x00, 0x29, 0x00, 0x00,   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   0x00, 0x01, 0x07, 0x01, 0x01, 0xFF, 0x5C, 0x00,
+    };
+    JPEG2000MainHeader uut;
+    uut.setHeaderData(data);
+    Error err = uut.doParse();
+    REQUIRE(err.error_code == heif_error_Invalid_input);
+    REQUIRE(err.sub_error_code == heif_suberror_Invalid_J2K_codestream);
+}
+
+TEST_CASE( "codestream Lsiz too small" )
+{
+    std::vector<uint8_t> data = {
+    0xFF, 0x4F, 0xFF, 0x51, 0x00, 0x28, 0x00, 0x00,   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   0x00, 0x01, 0x07, 0x01, 0x01, 0xFF, 0x5C, 0x00,
+    };
+    JPEG2000MainHeader uut;
+    uut.setHeaderData(data);
+    Error err = uut.doParse();
+    REQUIRE(err.error_code == heif_error_Invalid_input);
+    REQUIRE(err.sub_error_code == heif_suberror_Invalid_J2K_codestream);
+}
+
+TEST_CASE( "codestream Lsiz too large" )
+{
+    std::vector<uint8_t> data = {
+    0xFF, 0x4F, 0xFF, 0x51, 0xC0, 0x27, 0x00, 0x00,   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   0x00, 0x01, 0x07, 0x01, 0x01, 0xFF, 0x5C, 0x00,
+    };
+    JPEG2000MainHeader uut;
+    uut.setHeaderData(data);
+    Error err = uut.doParse();
+    REQUIRE(err.error_code == heif_error_Invalid_input);
+    REQUIRE(err.sub_error_code == heif_suberror_Invalid_J2K_codestream);
+}
+
+TEST_CASE( "codestream Csiz too small" )
+{
+    std::vector<uint8_t> data = {
+    0xFF, 0x4F, 0xFF, 0x51, 0x00, 0x29, 0x00, 0x00,   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   0x00, 0x00, 0x07, 0x01, 0x01, 0xFF, 0x5C, 0x00,
+    };
+    JPEG2000MainHeader uut;
+    uut.setHeaderData(data);
+    Error err = uut.doParse();
+    REQUIRE(err.error_code == heif_error_Invalid_input);
+    REQUIRE(err.sub_error_code == heif_suberror_Invalid_J2K_codestream);
+}
+
+TEST_CASE( "codestream Csiz too large" )
+{
+    std::vector<uint8_t> data = {
+    0xFF, 0x4F, 0xFF, 0x51, 0x00, 0x29, 0x00, 0x00,   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   0x40, 0x01, 0x07, 0x01, 0x01, 0xFF, 0x5C, 0x00,
+    };
+    JPEG2000MainHeader uut;
+    uut.setHeaderData(data);
+    Error err = uut.doParse();
+    REQUIRE(err.error_code == heif_error_Invalid_input);
+    REQUIRE(err.sub_error_code == heif_suberror_Invalid_J2K_codestream);
+}
+
+
+TEST_CASE( "codestream bad Csiz" )
+{
+    std::vector<uint8_t> data = {
+    0xFF, 0x4F, 0xFF, 0x51, 0x00, 0x29, 0x00, 0x00,   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   0x00, 0x04, 0x07, 0x01, 0x01, 0xFF, 0x5C, 0x00,
+    };
+    JPEG2000MainHeader uut;
+    uut.setHeaderData(data);
+    Error err = uut.doParse();
+    REQUIRE(err.error_code == heif_error_Invalid_input);
+    REQUIRE(err.sub_error_code == heif_suberror_Invalid_J2K_codestream);
+}
+
+
+TEST_CASE( "codestream missing segments" )
+{
+    std::vector<uint8_t> data = {
+    0xFF, 0x4F, 0xFF, 0x51, 0x00, 0x29, 0x00, 0x00,   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   0x00, 0x01, 0x07, 0x01, 0x01
+    };
+    JPEG2000MainHeader uut;
+    uut.setHeaderData(data);
+    Error err = uut.doParse();
+    REQUIRE(err.error_code == heif_error_Invalid_input);
+    REQUIRE(err.sub_error_code == heif_suberror_Invalid_J2K_codestream);
+}
+
+TEST_CASE( "codestream - COD + SIZ + CAP" )
+{
+    // This data is a modified version of subset of the example in ISO/IEC 15444-1:2019 Section
+    // J.10.1 "Main header"
+    std::vector<uint8_t> data = {
+    0xFF, 0x4F, 0xFF, 0x51, 0x00, 0x29, 0x00, 0x00,   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   0x00, 0x01, 0x07, 0x01, 0x01, 
+    0xFF, 0x50, 0x00, 0x08, 0x00, 0x02, 0x00, 0x00,   0x00, 0x22,
+    0xFF, 0x5C, 0x00,
+    };
+    JPEG2000MainHeader uut;
+    uut.setHeaderData(data);
+    Error err = uut.doParse();
+    REQUIRE(err.error_code == heif_error_Ok);
+    REQUIRE(uut.get_SIZ().reference_grid_width == 1);
+    REQUIRE(uut.get_SIZ().reference_grid_height == 9);
+    REQUIRE(uut.get_SIZ().image_horizontal_offset == 0);
+    REQUIRE(uut.get_SIZ().image_vertical_offset == 0);
+    REQUIRE(uut.get_SIZ().tile_width == 1);
+    REQUIRE(uut.get_SIZ().tile_height == 9);
+    REQUIRE(uut.get_SIZ().tile_offset_x == 0);
+    REQUIRE(uut.get_SIZ().tile_offset_y == 0);
+    REQUIRE(uut.get_SIZ().components.size() == 1);
+    REQUIRE(uut.get_SIZ().components[0].precision == 8);
+    REQUIRE(uut.get_SIZ().components[0].is_signed == false);
+    REQUIRE(uut.get_SIZ().components[0].h_separation == 1);
+    REQUIRE(uut.get_SIZ().components[0].v_separation == 1);
+    REQUIRE(uut.get_chroma_format() == heif_chroma_monochrome);
+    REQUIRE(uut.get_precision(0) == 8);
+    REQUIRE(uut.hasHighThroughputExtension() == true);
+}
+
+TEST_CASE( "codestream CAP short" )
+{
+    std::vector<uint8_t> data = {
+    0xFF, 0x4F, 0xFF, 0x51, 0x00, 0x29, 0x00, 0x00,   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   0x00, 0x01, 0x07, 0x01, 0x01, 
+    0xFF, 0x50, 0x00, 0x08, 0x00, 0x02, 0x00, 0x00,   0x00
+    };
+    JPEG2000MainHeader uut;
+    uut.setHeaderData(data);
+    Error err = uut.doParse();
+    REQUIRE(err.error_code == heif_error_Invalid_input);
+    REQUIRE(err.sub_error_code == heif_suberror_Invalid_J2K_codestream);
+}
+
+TEST_CASE( "codestream Lcap short" )
+{
+std::vector<uint8_t> data = {
+    0xFF, 0x4F, 0xFF, 0x51, 0x00, 0x29, 0x00, 0x00,   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   0x00, 0x01, 0x07, 0x01, 0x01, 
+    0xFF, 0x50, 0x00, 0x07, 0x00, 0x02, 0x00, 0x00,   0x00, 0x22,
+    0xFF, 0x5C, 0x00,
+    };
+    JPEG2000MainHeader uut;
+    uut.setHeaderData(data);
+    Error err = uut.doParse();
+    REQUIRE(err.error_code == heif_error_Invalid_input);
+    REQUIRE(err.sub_error_code == heif_suberror_Invalid_J2K_codestream);
+}
+
+TEST_CASE( "codestream Lcap long" )
+{
+std::vector<uint8_t> data = {
+    0xFF, 0x4F, 0xFF, 0x51, 0x00, 0x29, 0x00, 0x00,   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   0x00, 0x01, 0x07, 0x01, 0x01, 
+    0xFF, 0x50, 0x00, 0x47, 0x00, 0x02, 0x00, 0x00,   0x00, 0x22,
+    0xFF, 0x5C, 0x00,
+    };
+    JPEG2000MainHeader uut;
+    uut.setHeaderData(data);
+    Error err = uut.doParse();
+    REQUIRE(err.error_code == heif_error_Invalid_input);
+    REQUIRE(err.sub_error_code == heif_suberror_Invalid_J2K_codestream);
+}
+
+
+TEST_CASE( "codestream - COD + SIZ + CAP multiple" )
+{
+    // This data is a modified version of subset of the example in ISO/IEC 15444-1:2019 Section
+    // J.10.1 "Main header"
+    std::vector<uint8_t> data = {
+    0xFF, 0x4F, 0xFF, 0x51, 0x00, 0x29, 0x00, 0x00,   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   0x00, 0x01, 0x07, 0x01, 0x01, 
+    0xFF, 0x50, 0x00, 0x0A, 0x00, 0x12, 0x00, 0x00,   0xFF, 0xFF, 0x00, 0x22,
+    0xFF, 0x5C, 0x00,
+    };
+    JPEG2000MainHeader uut;
+    uut.setHeaderData(data);
+    Error err = uut.doParse();
+    REQUIRE(err.error_code == heif_error_Ok);
+    REQUIRE(uut.get_SIZ().reference_grid_width == 1);
+    REQUIRE(uut.get_SIZ().reference_grid_height == 9);
+    REQUIRE(uut.get_SIZ().image_horizontal_offset == 0);
+    REQUIRE(uut.get_SIZ().image_vertical_offset == 0);
+    REQUIRE(uut.get_SIZ().tile_width == 1);
+    REQUIRE(uut.get_SIZ().tile_height == 9);
+    REQUIRE(uut.get_SIZ().tile_offset_x == 0);
+    REQUIRE(uut.get_SIZ().tile_offset_y == 0);
+    REQUIRE(uut.get_SIZ().components.size() == 1);
+    REQUIRE(uut.get_SIZ().components[0].precision == 8);
+    REQUIRE(uut.get_SIZ().components[0].is_signed == false);
+    REQUIRE(uut.get_SIZ().components[0].h_separation == 1);
+    REQUIRE(uut.get_SIZ().components[0].v_separation == 1);
+    REQUIRE(uut.get_chroma_format() == heif_chroma_monochrome);
+    REQUIRE(uut.get_precision(0) == 8);
+    REQUIRE(uut.hasHighThroughputExtension() == true);
+}
+
+
+TEST_CASE( "codestream - COD + SIZ + CAP other" )
+{
+    // This data is a modified version of subset of the example in ISO/IEC 15444-1:2019 Section
+    // J.10.1 "Main header"
+    // Note that the ccap2 value may not be valid
+    std::vector<uint8_t> data = {
+    0xFF, 0x4F, 0xFF, 0x51, 0x00, 0x29, 0x00, 0x00,   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   0x00, 0x01, 0x07, 0x01, 0x01, 
+    0xFF, 0x50, 0x00, 0x08, 0x00, 0x40, 0x00, 0x00,   0x00, 0x22,
+    0xFF, 0x5C, 0x00,
+    };
+    JPEG2000MainHeader uut;
+    uut.setHeaderData(data);
+    Error err = uut.doParse();
+    REQUIRE(err.error_code == heif_error_Ok);
+    REQUIRE(uut.get_SIZ().reference_grid_width == 1);
+    REQUIRE(uut.get_SIZ().reference_grid_height == 9);
+    REQUIRE(uut.get_SIZ().image_horizontal_offset == 0);
+    REQUIRE(uut.get_SIZ().image_vertical_offset == 0);
+    REQUIRE(uut.get_SIZ().tile_width == 1);
+    REQUIRE(uut.get_SIZ().tile_height == 9);
+    REQUIRE(uut.get_SIZ().tile_offset_x == 0);
+    REQUIRE(uut.get_SIZ().tile_offset_y == 0);
+    REQUIRE(uut.get_SIZ().components.size() == 1);
+    REQUIRE(uut.get_SIZ().components[0].precision == 8);
+    REQUIRE(uut.get_SIZ().components[0].is_signed == false);
+    REQUIRE(uut.get_SIZ().components[0].h_separation == 1);
+    REQUIRE(uut.get_SIZ().components[0].v_separation == 1);
+    REQUIRE(uut.get_chroma_format() == heif_chroma_monochrome);
+    REQUIRE(uut.get_precision(0) == 8);
+    REQUIRE(uut.hasHighThroughputExtension() == false);
+}
diff --git a/tests/main.cc b/tests/main.cc
index 8033466e4f..a58d5bdf74 100644
--- a/tests/main.cc
+++ b/tests/main.cc
@@ -3,7 +3,7 @@
 
   MIT License
 
-  Copyright (c) 2019 struktur AG, Dirk Farin <farin@struktur.de>
+  Copyright (c) 2019 Dirk Farin <dirk.farin@gmail.com>
 
   Permission is hereby granted, free of charge, to any person obtaining a copy
   of this software and associated documentation files (the "Software"), to deal
@@ -25,4 +25,4 @@
 */
 
 #define CATCH_CONFIG_MAIN
-#include "catch.hpp"
+#include "catch_amalgamated.hpp"
diff --git a/tests/mini_box.cc b/tests/mini_box.cc
new file mode 100644
index 0000000000..f8499b2d20
--- /dev/null
+++ b/tests/mini_box.cc
@@ -0,0 +1,274 @@
+/*
+  libheif AVC (H.264) unit tests
+
+  MIT License
+
+  Copyright (c) 2023 Brad Hards <bradh@frogmouth.net>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#include "catch_amalgamated.hpp"
+#include <bitstream.h>
+#include <box.h>
+#include "error.h"
+#include <logging.h>
+#include <cstdint>
+#include <fstream>
+#include <iostream>
+#include <memory>
+#include <mini.h>
+#include "test_utils.h"
+#include "test-config.h"
+#include <file_layout.h>
+
+TEST_CASE("mini")
+{
+  std::vector<uint8_t> byteArray{
+      0x00, 0x00, 0x00, 0x10, 0x66, 0x74, 0x79, 0x70,
+      0x6d, 0x69, 0x66, 0x33, 0x61, 0x76, 0x69, 0x66,
+      0x00, 0x00, 0x00, 0x4a, 0x6d, 0x69, 0x6e, 0x69,
+      0x08, 0x18, 0x00, 0xff, 0x01, 0xfe, 0xe0, 0x03,
+      0x40, 0x81, 0x20, 0x00, 0x00, 0x12, 0x00, 0x0a,
+      0x09, 0x38, 0x1d, 0xff, 0xff, 0xd8, 0x40, 0x43,
+      0x41, 0xa4, 0x32, 0x26, 0x11, 0x90, 0x01, 0x86,
+      0x18, 0x61, 0x00, 0xb4, 0x83, 0x5a, 0x70, 0x50,
+      0x8b, 0xe5, 0x7d, 0xf5, 0xc7, 0xd3, 0x6e, 0x92,
+      0xea, 0x80, 0x01, 0x50, 0x91, 0xc4, 0x06, 0xa3,
+      0xe1, 0xca, 0x44, 0x43, 0xe7, 0xb8, 0x67, 0x43,
+      0xea, 0x80};
+
+  auto reader = std::make_shared<StreamReader_memory>(byteArray.data(),
+                                                      byteArray.size(), false);
+
+  BitstreamRange range(reader, byteArray.size());
+  std::shared_ptr<Box> box;
+  Error error = Box::read(range, &box, heif_get_global_security_limits());
+  REQUIRE(error == Error::Ok);
+  REQUIRE(range.error() == 0);
+
+  REQUIRE(box->get_short_type() == fourcc("ftyp"));
+  REQUIRE(box->get_type_string() == "ftyp");
+  std::shared_ptr<Box_ftyp> ftyp = std::dynamic_pointer_cast<Box_ftyp>(box);
+  REQUIRE(ftyp->get_major_brand() == fourcc("mif3"));
+  REQUIRE(ftyp->get_minor_version() == fourcc("avif"));
+  REQUIRE(ftyp->list_brands().size() == 0);
+  Indent indent;
+  std::string dumpResult = box->dump(indent);
+  REQUIRE(dumpResult == "Box: ftyp ----- (File Type)\n"
+                        "size: 16   (header size: 8)\n"
+                        "major brand: mif3\n"
+                        "minor version: avif\n"
+                        "compatible brands: \n");
+
+  error = Box::read(range, &box, heif_get_global_security_limits());
+  REQUIRE(error == Error::Ok);
+  REQUIRE(range.error() == 0);
+
+  REQUIRE(box->get_short_type() == fourcc("mini"));
+  REQUIRE(box->get_type_string() == "mini");
+  std::shared_ptr<Box_mini> mini = std::dynamic_pointer_cast<Box_mini>(box);
+  REQUIRE(mini->get_exif_flag() == false);
+  REQUIRE(mini->get_xmp_flag() == false);
+  REQUIRE(mini->get_bit_depth() == 8);
+  REQUIRE(mini->get_colour_primaries() == 1);
+  REQUIRE(mini->get_transfer_characteristics() == 13);
+  REQUIRE(mini->get_matrix_coefficients() == 6);
+  REQUIRE(mini->get_width() == 256);
+  REQUIRE(mini->get_height() == 256);
+  REQUIRE(mini->get_main_item_codec_config().size() == 4);
+  REQUIRE((int)(mini->get_main_item_codec_config().data()[0]) == 0x81);
+  REQUIRE((int)(mini->get_main_item_codec_config().data()[1]) == 0x20);
+  REQUIRE((int)(mini->get_main_item_codec_config().data()[2]) == 0x00);
+  REQUIRE((int)(mini->get_main_item_codec_config().data()[3]) == 0x00);
+  dumpResult = box->dump(indent);
+  REQUIRE(dumpResult == "Box: mini -----\n"
+                        "size: 74   (header size: 8)\n"
+                        "version: 0\n"
+                        "explicit_codec_types_flag: 0\n"
+                        "float_flag: 0\n"
+                        "full_range_flag: 1\n"
+                        "alpha_flag: 0\n"
+                        "explicit_cicp_flag: 0\n"
+                        "hdr_flag: 0\n"
+                        "icc_flag: 0\n"
+                        "exif_flag: 0\n"
+                        "xmp_flag: 0\n"
+                        "chroma_subsampling: 3\n"
+                        "orientation: 1\n"
+                        "width: 256\n"
+                        "height: 256\n"
+                        "bit_depth: 8\n"
+                        "colour_primaries: 1\n"
+                        "transfer_characteristics: 13\n"
+                        "matrix_coefficients: 6\n"
+                        "main_item_code_config size: 4\n"
+                        "main_item_data offset: 37, size: 53\n");
+}
+
+TEST_CASE("check mini+alpha version")
+{
+  auto istr = std::unique_ptr<std::istream>(new std::ifstream(tests_data_directory + "/simple_osm_tile_alpha.avif", std::ios::binary));
+  auto reader = std::make_shared<StreamReader_istream>(std::move(istr));
+  FileLayout file;
+  Error err = file.read(reader, heif_get_global_security_limits());
+  REQUIRE(err.error_code == heif_error_Ok);
+
+  std::shared_ptr<Box_mini> mini = file.get_mini_box();
+  REQUIRE(mini->get_exif_flag() == false);
+  REQUIRE(mini->get_xmp_flag() == false);
+  REQUIRE(mini->get_bit_depth() == 8);
+  REQUIRE(mini->get_colour_primaries() == 2);
+  REQUIRE(mini->get_transfer_characteristics() == 2);
+  REQUIRE(mini->get_matrix_coefficients() == 6);
+  REQUIRE(mini->get_width() == 256);
+  REQUIRE(mini->get_height() == 256);
+  REQUIRE(mini->get_main_item_codec_config().size() == 4);
+  REQUIRE((int)(mini->get_main_item_codec_config().data()[0]) == 0x81);
+  REQUIRE((int)(mini->get_main_item_codec_config().data()[1]) == 0x20);
+  REQUIRE((int)(mini->get_main_item_codec_config().data()[2]) == 0x00);
+  REQUIRE((int)(mini->get_main_item_codec_config().data()[3]) == 0x00);
+  Indent indent;
+  std::string dumpResult = mini->dump(indent);
+  REQUIRE(dumpResult == "Box: mini -----\n"
+                        "size: 788   (header size: 8)\n"
+                        "version: 0\n"
+                        "explicit_codec_types_flag: 0\n"
+                        "float_flag: 0\n"
+                        "full_range_flag: 1\n"
+                        "alpha_flag: 1\n"
+                        "explicit_cicp_flag: 0\n"
+                        "hdr_flag: 0\n"
+                        "icc_flag: 1\n"
+                        "exif_flag: 0\n"
+                        "xmp_flag: 0\n"
+                        "chroma_subsampling: 3\n"
+                        "orientation: 1\n"
+                        "width: 256\n"
+                        "height: 256\n"
+                        "bit_depth: 8\n"
+                        "alpha_is_premultiplied: 0\n"
+                        "colour_primaries: 2\n"
+                        "transfer_characteristics: 2\n"
+                        "matrix_coefficients: 6\n"
+                        "alpha_item_code_config size: 4\n"
+                        "main_item_code_config size: 4\n"
+                        "icc_data size: 672\n"
+                        "alpha_item_data offset: 717, size: 34\n"
+                        "main_item_data offset: 751, size: 53\n");
+}
+
+TEST_CASE("check mini+exif+xmp version")
+{
+  auto istr = std::unique_ptr<std::istream>(new std::ifstream(tests_data_directory + "/simple_osm_tile_meta.avif", std::ios::binary));
+  auto reader = std::make_shared<StreamReader_istream>(std::move(istr));
+  FileLayout file;
+  Error err = file.read(reader, heif_get_global_security_limits());
+  REQUIRE(err.error_code == heif_error_Ok);
+
+  std::shared_ptr<Box_mini> mini = file.get_mini_box();
+  REQUIRE(mini->get_exif_flag() == true);
+  REQUIRE(mini->get_xmp_flag() == true);
+  REQUIRE(mini->get_bit_depth() == 8);
+  REQUIRE(mini->get_colour_primaries() == 2);
+  REQUIRE(mini->get_transfer_characteristics() == 2);
+  REQUIRE(mini->get_matrix_coefficients() == 6);
+  REQUIRE(mini->get_width() == 256);
+  REQUIRE(mini->get_height() == 256);
+  REQUIRE(mini->get_main_item_codec_config().size() == 4);
+  REQUIRE((int)(mini->get_main_item_codec_config().data()[0]) == 0x81);
+  REQUIRE((int)(mini->get_main_item_codec_config().data()[1]) == 0x20);
+  REQUIRE((int)(mini->get_main_item_codec_config().data()[2]) == 0x00);
+  REQUIRE((int)(mini->get_main_item_codec_config().data()[3]) == 0x00);
+  Indent indent;
+  std::string dumpResult = mini->dump(indent);
+  REQUIRE(dumpResult == "Box: mini -----\n"
+                        "size: 4388   (header size: 8)\n"
+                        "version: 0\n"
+                        "explicit_codec_types_flag: 0\n"
+                        "float_flag: 0\n"
+                        "full_range_flag: 1\n"
+                        "alpha_flag: 0\n"
+                        "explicit_cicp_flag: 0\n"
+                        "hdr_flag: 0\n"
+                        "icc_flag: 1\n"
+                        "exif_flag: 1\n"
+                        "xmp_flag: 1\n"
+                        "chroma_subsampling: 3\n"
+                        "orientation: 1\n"
+                        "width: 256\n"
+                        "height: 256\n"
+                        "bit_depth: 8\n"
+                        "colour_primaries: 2\n"
+                        "transfer_characteristics: 2\n"
+                        "matrix_coefficients: 6\n"
+                        "main_item_code_config size: 4\n"
+                        "icc_data size: 672\n"
+                        "main_item_data offset: 717, size: 53\n"
+                        "exif_data offset: 770, size: 208\n"
+                        "xmp_data offset: 978, size: 3426\n");
+}
+
+
+TEST_CASE("check heif mini")
+{
+  auto istr = std::unique_ptr<std::istream>(new std::ifstream(tests_data_directory + "/lightning_mini.heif", std::ios::binary));
+  auto reader = std::make_shared<StreamReader_istream>(std::move(istr));
+  FileLayout file;
+  Error err = file.read(reader, heif_get_global_security_limits());
+  REQUIRE(err.error_code == heif_error_Ok);
+
+  std::shared_ptr<Box_mini> mini = file.get_mini_box();
+  REQUIRE(mini->get_exif_flag() == false);
+  REQUIRE(mini->get_xmp_flag() == false);
+  REQUIRE(mini->get_bit_depth() == 8);
+  REQUIRE(mini->get_colour_primaries() == 1);
+  REQUIRE(mini->get_transfer_characteristics() == 13);
+  REQUIRE(mini->get_matrix_coefficients() == 6);
+  REQUIRE(mini->get_width() == 128);
+  REQUIRE(mini->get_height() == 128);
+  REQUIRE(mini->get_main_item_codec_config().size() == 112);
+  Indent indent;
+  std::string dumpResult = mini->dump(indent);
+  REQUIRE(dumpResult == "Box: mini -----\n"
+                        "size: 4710   (header size: 8)\n"
+                        "version: 0\n"
+                        "explicit_codec_types_flag: 0\n"
+                        "float_flag: 0\n"
+                        "full_range_flag: 1\n"
+                        "alpha_flag: 0\n"
+                        "explicit_cicp_flag: 0\n"
+                        "hdr_flag: 0\n"
+                        "icc_flag: 0\n"
+                        "exif_flag: 0\n"
+                        "xmp_flag: 0\n"
+                        "chroma_subsampling: 1\n"
+                        "orientation: 1\n"
+                        "width: 128\n"
+                        "height: 128\n"
+                        "chroma_is_horizontally_centered: 0\n"
+                        "chroma_is_vertically_centered: 0\n"
+                        "bit_depth: 8\n"
+                        "colour_primaries: 1\n"
+                        "transfer_characteristics: 13\n"
+                        "matrix_coefficients: 6\n"
+                        "main_item_code_config size: 112\n"
+                        "main_item_data offset: 144, size: 4582\n");
+}
+
diff --git a/tests/mini_decode.cc b/tests/mini_decode.cc
new file mode 100644
index 0000000000..c3be83dd86
--- /dev/null
+++ b/tests/mini_decode.cc
@@ -0,0 +1,109 @@
+/*
+  libheif integration tests for uncompressed decoder
+
+  MIT License
+
+  Copyright (c) 2023 Brad Hards <bradh@frogmouth.net>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+#include "catch_amalgamated.hpp"
+#include "libheif/heif.h"
+#include "api_structs.h"
+#include <cstdint>
+#include <stdio.h>
+#include "test_utils.h"
+#include <string.h>
+
+#define MINI_FILES \
+  "simple_osm_tile_alpha.avif", "simple_osm_tile_meta.avif"
+
+void check_image_handle_size(struct heif_context *&context) {
+  heif_image_handle *handle = get_primary_image_handle(context);
+  int ispe_width = heif_image_handle_get_ispe_width(handle);
+  REQUIRE(ispe_width == 256);
+  int ispe_height = heif_image_handle_get_ispe_height(handle);
+  REQUIRE(ispe_height == 256);
+  int width = heif_image_handle_get_width(handle);
+  REQUIRE(width == 256);
+  int height = heif_image_handle_get_height(handle);
+  REQUIRE(height == 256);
+
+  heif_image_handle_release(handle);
+}
+
+TEST_CASE("check image handle size") {
+  auto file = GENERATE(MINI_FILES);
+  auto context = get_context_for_test_file(file);
+  INFO("file name: " << file);
+  check_image_handle_size(context);
+  heif_context_free(context);
+}
+
+void check_image_size_heif_mini(struct heif_context *&context) {
+  heif_image_handle *handle = get_primary_image_handle(context);
+  heif_image *img = get_primary_image_ycbcr(handle, heif_chroma_444);
+
+  REQUIRE(heif_image_has_channel(img, heif_channel_Y) == 1);
+  REQUIRE(heif_image_has_channel(img, heif_channel_Cb) == 1);
+  REQUIRE(heif_image_has_channel(img, heif_channel_Cr) == 1);
+  REQUIRE(heif_image_has_channel(img, heif_channel_R) == 0);
+  REQUIRE(heif_image_has_channel(img, heif_channel_G) == 0);
+  REQUIRE(heif_image_has_channel(img, heif_channel_B) == 0);
+  REQUIRE(heif_image_has_channel(img, heif_channel_Alpha) == 0);
+  REQUIRE(heif_image_has_channel(img, heif_channel_interleaved) == 0);
+  int width = heif_image_get_primary_width(img);
+  REQUIRE(width == 128);
+  int height = heif_image_get_primary_height(img);
+  REQUIRE(height == 128);
+  width = heif_image_get_width(img, heif_channel_Y);
+  REQUIRE(width == 128);
+  height = heif_image_get_height(img, heif_channel_Y);
+  REQUIRE(height == 128);
+  width = heif_image_get_width(img, heif_channel_Cb);
+  REQUIRE(width == 128);
+  height = heif_image_get_height(img, heif_channel_Cr);
+  REQUIRE(height == 128);
+  width = heif_image_get_width(img, heif_channel_Cr);
+  REQUIRE(width == 128);
+  height = heif_image_get_height(img, heif_channel_Cr);
+  REQUIRE(height == 128);
+
+  int pixel_depth = heif_image_get_bits_per_pixel(img, heif_channel_Y);
+  REQUIRE(pixel_depth == 8);
+  pixel_depth = heif_image_get_bits_per_pixel(img, heif_channel_Cb);
+  REQUIRE(pixel_depth == 8);
+  pixel_depth = heif_image_get_bits_per_pixel(img, heif_channel_Cr);
+  REQUIRE(pixel_depth == 8);
+  int pixel_range = heif_image_get_bits_per_pixel_range(img, heif_channel_Y);
+  REQUIRE(pixel_range == 8);
+  pixel_range = heif_image_get_bits_per_pixel_range(img, heif_channel_Cb);
+  REQUIRE(pixel_range == 8);
+  pixel_range = heif_image_get_bits_per_pixel_range(img, heif_channel_Cr);
+  REQUIRE(pixel_range == 8);
+
+  heif_image_release(img);
+  heif_image_handle_release(handle);
+}
+
+TEST_CASE("check image size HEIF mini") {
+  auto context = get_context_for_test_file("lightning_mini.heif");
+  check_image_size_heif_mini(context);
+  heif_context_free(context);
+}
diff --git a/tests/omaf.cc b/tests/omaf.cc
new file mode 100644
index 0000000000..cbc8ed611f
--- /dev/null
+++ b/tests/omaf.cc
@@ -0,0 +1,92 @@
+/*
+  libheif OMAF (ISO/IEC 23090-2) unit tests
+
+  MIT License
+
+  Copyright (c) 2026 Brad Hards <bradh@frogmouth.net>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#include "catch_amalgamated.hpp"
+#include "libheif/heif.h"
+#include "api_structs.h"
+#include "pixelimage.h"
+
+#include "test_utils.h"
+
+#include <string.h>
+
+static heif_encoding_options * set_encoding_options()
+{
+  heif_encoding_options * options = heif_encoding_options_alloc();
+  options->macOS_compatibility_workaround = false;
+  options->macOS_compatibility_workaround_no_nclx_profile = true;
+  options->image_orientation = heif_orientation_normal;
+  return options;
+}
+
+static void do_encode(heif_image* input_image, const char* filename, heif_omaf_image_projection projection)
+{
+  REQUIRE(input_image != nullptr);
+  heif_init(nullptr);
+  heif_context *ctx = heif_context_alloc();
+  heif_encoder *encoder;
+  heif_error err;
+  err = heif_context_get_encoder_for_format(ctx, heif_compression_HEVC, &encoder);
+  REQUIRE(err.code == heif_error_Ok);
+
+  heif_encoding_options *options = set_encoding_options();
+
+  heif_image_handle *output_image_handle;
+
+  err = heif_context_encode_image(ctx, input_image, encoder, options, &output_image_handle);
+  REQUIRE(err.code == heif_error_Ok);
+  heif_image_handle_set_omaf_image_projection(output_image_handle, projection);
+  err = heif_context_write_to_file(ctx, filename);
+  REQUIRE(err.code == heif_error_Ok);
+
+  heif_image_handle_release(output_image_handle);
+  heif_encoding_options_free(options);
+  heif_encoder_release(encoder);
+  heif_image_release(input_image);
+
+  heif_context_free(ctx);
+
+  heif_context *readbackCtx = get_context_for_local_file(filename);
+  heif_image_handle *readbackHandle = get_primary_image_handle(readbackCtx);
+  heif_omaf_image_projection readbackProjection = heif_image_handle_get_omaf_image_projection(readbackHandle);
+  REQUIRE(readbackProjection == projection);
+  heif_image_handle_release(readbackHandle);
+  heif_context_free(readbackCtx);
+  
+  heif_deinit();
+}
+
+TEST_CASE("Encode OMAF HEIC")
+{
+  heif_image *input_image = createImage_RGB_planar();
+  do_encode(input_image, "encode_omaf_equirectangular.heic", heif_omaf_image_projection::heif_omaf_image_projection_equirectangular);
+}
+
+TEST_CASE("Encode OMAF HEIC Cubemap")
+{
+  heif_image *input_image = createImage_RGB_planar();
+  do_encode(input_image, "encode_omaf_cubemap.heic", heif_omaf_image_projection::heif_omaf_image_projection_cube_map);
+}
\ No newline at end of file
diff --git a/tests/omaf_boxes.cc b/tests/omaf_boxes.cc
new file mode 100644
index 0000000000..27c0280dca
--- /dev/null
+++ b/tests/omaf_boxes.cc
@@ -0,0 +1,62 @@
+/*
+  libheif OMAF (ISO/IEC 23090-2) unit tests
+
+  MIT License
+
+  Copyright (c) 2026 Brad Hards <bradh@frogmouth.net>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#include "catch_amalgamated.hpp"
+#include "omaf_boxes.h"
+#include "error.h"
+#include <cstdint>
+#include <iostream>
+#include <memory>
+
+
+TEST_CASE("prfr") {
+  std::vector<uint8_t> byteArray{0x00, 0x00, 0x00, 0x0d, 0x70, 0x72, 0x66, 0x72, 0x00, 0x00, 0x00, 0x00, 0x01};
+
+  auto reader = std::make_shared<StreamReader_memory>(byteArray.data(),
+                                                      byteArray.size(), false);
+
+  BitstreamRange range(reader, byteArray.size());
+  std::shared_ptr<Box> box;
+  Error error = Box::read(range, &box, heif_get_global_security_limits());
+  REQUIRE(error == Error::Ok);
+  REQUIRE(range.error() == 0);
+
+  REQUIRE(box->get_short_type() == fourcc("prfr"));
+  REQUIRE(box->get_type_string() == "prfr");
+  std::shared_ptr<Box_prfr> prfr = std::dynamic_pointer_cast<Box_prfr>(box);
+  REQUIRE(prfr->get_omaf_image_projection() == heif_omaf_image_projection_cube_map);
+  Indent indent;
+  std::string dumpResult = box->dump(indent);
+  REQUIRE(dumpResult == "Box: prfr ----- (Projection Format)\n"
+                        "size: 13   (header size: 12)\n"
+                        "projection_type: cube-map\n");
+
+  StreamWriter writer;
+  Error err = prfr->write(writer);
+  REQUIRE(err.error_code == heif_error_Ok);
+  const std::vector<uint8_t> bytes = writer.get_data();
+  REQUIRE(bytes == byteArray);
+}
diff --git a/tests/pixel_data_types.cc b/tests/pixel_data_types.cc
new file mode 100644
index 0000000000..e57ce73353
--- /dev/null
+++ b/tests/pixel_data_types.cc
@@ -0,0 +1,179 @@
+/*
+  libheif unit tests
+
+  MIT License
+
+  Copyright (c) 2024 Dirk Farin <dirk.farin@gmail.com>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#include "pixelimage.h"
+#include "catch_amalgamated.hpp"
+
+TEST_CASE( "uint32_t" )
+{
+  HeifPixelImage image;
+
+  auto* limits = heif_get_global_security_limits();
+  image.create(3,2, heif_colorspace_nonvisual, heif_chroma_undefined);
+  image.add_channel(heif_channel_Y, 3,2, heif_channel_datatype_unsigned_integer, 32, limits);
+
+  size_t stride;
+  uint32_t* data = image.get_channel<uint32_t>(heif_channel_Y, &stride);
+
+  REQUIRE(stride >= 3);
+  REQUIRE(image.get_width(heif_channel_Y) == 3);
+  REQUIRE(image.get_height(heif_channel_Y) == 2);
+  REQUIRE(image.get_bits_per_pixel(heif_channel_Y) == 32);
+  REQUIRE(image.get_storage_bits_per_pixel(heif_channel_Y) == 32);
+  REQUIRE(image.get_datatype(heif_channel_Y) == heif_channel_datatype_unsigned_integer);
+  REQUIRE(image.get_number_of_interleaved_components(heif_channel_Y) == 1);
+
+  data[0*stride + 0] = 0;
+  data[0*stride + 1] = 0xFFFFFFFFu;
+  data[0*stride + 2] = 1000;
+  data[1*stride + 0] = 0xFFFFFFFFu;
+  data[1*stride + 1] = 0;
+  data[1*stride + 2] = 2000;
+
+  REQUIRE(data[0*stride + 1] == 0xFFFFFFFFu);
+
+  // --- rotate data
+
+  std::shared_ptr<HeifPixelImage> rot;
+  auto rotationResult = image.rotate_ccw(90, limits);
+  REQUIRE(rotationResult.error().error_code == heif_error_Ok);
+  rot = *rotationResult;
+
+  data = rot->get_channel<uint32_t>(heif_channel_Y, &stride);
+
+  REQUIRE(data[0*stride + 0] == 1000);
+  REQUIRE(data[0*stride + 1] == 2000);
+  REQUIRE(data[1*stride + 0] == 0xFFFFFFFFu);
+  REQUIRE(data[1*stride + 1] == 0);
+  REQUIRE(data[2*stride + 0] == 0);
+  REQUIRE(data[2*stride + 1] == 0xFFFFFFFFu);
+
+  // --- mirror
+
+  rot->mirror_inplace(heif_transform_mirror_direction_horizontal, limits);
+
+  REQUIRE(data[0*stride + 1] == 1000);
+  REQUIRE(data[0*stride + 0] == 2000);
+  REQUIRE(data[1*stride + 1] == 0xFFFFFFFFu);
+  REQUIRE(data[1*stride + 0] == 0);
+  REQUIRE(data[2*stride + 1] == 0);
+  REQUIRE(data[2*stride + 0] == 0xFFFFFFFFu);
+
+  rot->mirror_inplace(heif_transform_mirror_direction_vertical, limits);
+
+  REQUIRE(data[2*stride + 1] == 1000);
+  REQUIRE(data[2*stride + 0] == 2000);
+  REQUIRE(data[1*stride + 1] == 0xFFFFFFFFu);
+  REQUIRE(data[1*stride + 0] == 0);
+  REQUIRE(data[0*stride + 1] == 0);
+  REQUIRE(data[0*stride + 0] == 0xFFFFFFFFu);
+
+  // --- crop
+
+  std::shared_ptr<HeifPixelImage> crop;
+  auto cropResult = image.crop(1,2,1,1, limits);
+  REQUIRE(cropResult.error().error_code == heif_error_Ok);
+  crop = *cropResult;
+
+  REQUIRE(crop->get_width(heif_channel_Y) == 2);
+  REQUIRE(crop->get_height(heif_channel_Y) == 1);
+
+  data = crop->get_channel<uint32_t>(heif_channel_Y, &stride);
+
+  REQUIRE(data[0*stride + 0] == 0);
+  REQUIRE(data[0*stride + 1] == 2000);
+
+  cropResult = image.crop(0,1,0,1, limits);
+  REQUIRE(cropResult.error().error_code == heif_error_Ok);
+  crop = *cropResult;
+
+  REQUIRE(crop->get_width(heif_channel_Y) == 2);
+  REQUIRE(crop->get_height(heif_channel_Y) == 2);
+
+  data = crop->get_channel<uint32_t>(heif_channel_Y, &stride);
+
+  REQUIRE(data[0*stride + 0] == 0);
+  REQUIRE(data[0*stride + 1] == 0xFFFFFFFFu);
+  REQUIRE(data[1*stride + 0] == 0xFFFFFFFFu);
+  REQUIRE(data[1*stride + 1] == 0);
+}
+
+
+TEST_CASE( "complex64_t" )
+{
+  HeifPixelImage image;
+
+  auto* limits = heif_get_global_security_limits();
+  image.create(3,2, heif_colorspace_nonvisual, heif_chroma_undefined);
+  image.add_channel(heif_channel_Y, 3,2, heif_channel_datatype_complex_number, 128, limits);
+
+  size_t stride;
+  heif_complex64* data = image.get_channel<heif_complex64>(heif_channel_Y, &stride);
+
+  REQUIRE(stride >= 3);
+  REQUIRE(image.get_width(heif_channel_Y) == 3);
+  REQUIRE(image.get_height(heif_channel_Y) == 2);
+  REQUIRE(image.get_bits_per_pixel(heif_channel_Y) == 128);
+  REQUIRE(image.get_storage_bits_per_pixel(heif_channel_Y) == 128);
+  REQUIRE(image.get_datatype(heif_channel_Y) == heif_channel_datatype_complex_number);
+  REQUIRE(image.get_number_of_interleaved_components(heif_channel_Y) == 1);
+
+  data[0*stride + 0] = {0.0, -1.0};
+  data[0*stride + 1] = {1.0, 2.0};
+  data[0*stride + 2] = {2.0, -1.0};
+  data[1*stride + 0] = {0.25, 0.5};
+  data[1*stride + 1] = {0.0, 0.0};
+  data[1*stride + 2] = {-0.75, 0.125};
+
+  REQUIRE(data[0*stride + 1].real == 1.0);
+  REQUIRE(data[0*stride + 1].imaginary == 2.0);
+}
+
+
+TEST_CASE( "image datatype through public API" )
+{
+  heif_image* image;
+  heif_error error = heif_image_create(3,2,heif_colorspace_nonvisual, heif_chroma_undefined, &image);
+  REQUIRE(!error.code);
+
+  uint32_t comp_idx;
+  error = heif_image_add_component(image, 3, 2, 0, heif_channel_datatype_unsigned_integer, 32, &comp_idx);
+  REQUIRE(!error.code);
+
+  size_t stride;
+  uint32_t* data = heif_image_get_component_uint32(image, comp_idx, &stride);
+  REQUIRE(data != nullptr);
+
+  REQUIRE(stride >= 3);
+  REQUIRE(heif_image_get_component_bits_per_pixel(image, comp_idx) == 32);
+
+  data[stride*0 + 0] = 0xFFFFFFFFu;
+  data[stride*0 + 1] = 0;
+  data[stride*0 + 2] = 1000;
+  data[stride*1 + 0] = 0xFFFFFFFFu;
+  data[stride*1 + 1] = 200;
+  data[stride*1 + 2] = 5;
+}
diff --git a/tests/region.cc b/tests/region.cc
new file mode 100644
index 0000000000..1db6947e6d
--- /dev/null
+++ b/tests/region.cc
@@ -0,0 +1,588 @@
+/*
+  libheif integration tests for regions
+
+  MIT License
+
+  Copyright (c) 2023 Brad Hards <bradh@frogmouth.net>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#include "catch_amalgamated.hpp"
+#include "api_structs.h"
+#include "libheif/heif.h"
+#include "test-config.h"
+#include "test_utils.h"
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+
+
+TEST_CASE("no regions") {
+  // skip test if we do not have the uncompressed codec
+  if (!heif_have_decoder_for_format(heif_compression_uncompressed)) {
+    SKIP("Skipping test because uncompressed codec is not compiled.");
+  }
+
+  auto context = get_context_for_test_file("uncompressed_comp_RGB.heif");
+  heif_image_handle *handle = get_primary_image_handle(context);
+  int num_region_items = heif_image_handle_get_number_of_region_items(handle);
+  REQUIRE(num_region_items == 0);
+  heif_image_handle_release(handle);
+  heif_context_free(context);
+}
+
+TEST_CASE("create regions") {
+  struct heif_error err;
+
+  heif_image* img;
+  uint32_t input_width = 1280;
+  uint32_t input_height = 1024;
+  heif_image_create(input_width,input_height, heif_colorspace_YCbCr, heif_chroma_420, &img);
+  fill_new_plane(img, heif_channel_Y, input_width, input_height);
+  fill_new_plane(img, heif_channel_Cb, (input_width+1)/2, (input_height+1)/2);
+  fill_new_plane(img, heif_channel_Cr, (input_width+1)/2, (input_height+1)/2);
+
+  heif_context* ctx = heif_context_alloc();
+  heif_encoder* enc;
+  err = heif_context_get_encoder_for_format(ctx, heif_compression_AV1, &enc);
+  REQUIRE(err.code == heif_error_Ok);
+
+  struct heif_encoding_options* options;
+  options = heif_encoding_options_alloc();
+  options->macOS_compatibility_workaround = false;
+  options->macOS_compatibility_workaround_no_nclx_profile = false;
+  options->image_orientation = heif_orientation_normal;
+
+  heif_image_handle* handle;
+  err = heif_context_encode_image(ctx, img, enc, options, &handle);
+  REQUIRE(err.code == heif_error_Ok);
+
+  struct heif_region_item* region_item1;
+  err = heif_image_handle_add_region_item(handle, input_width, input_height, &region_item1);
+  REQUIRE(err.code == heif_error_Ok);
+  struct heif_region *regionA;
+  err = heif_region_item_add_region_point(region_item1, 100, 200, &regionA);
+  REQUIRE(err.code == heif_error_Ok);
+  struct heif_region *regionB;
+  err = heif_region_item_add_region_rectangle(region_item1, 150, 250, 30, 50, &regionB);
+  REQUIRE(err.code == heif_error_Ok);
+  int32_t polylinePoints[6] = {10, 20, 15, 20, 15, 50};
+  int nPolylinePoints = (sizeof(polylinePoints)/sizeof(polylinePoints[0])) / 2;
+  err = heif_region_item_add_region_polyline(region_item1, polylinePoints, nPolylinePoints, NULL);
+  REQUIRE(err.code == heif_error_Ok);
+
+  struct heif_region_item* region_item2;
+  err = heif_image_handle_add_region_item(handle, input_width, input_height, &region_item2);
+  REQUIRE(err.code == heif_error_Ok);
+  struct heif_region *regionC;
+  err = heif_region_item_add_region_ellipse(region_item2, 350, 450, 60, 80, &regionC);
+  REQUIRE(err.code == heif_error_Ok);
+  err = heif_region_item_add_region_point(region_item2, 360, 460, NULL);
+  REQUIRE(err.code == heif_error_Ok);
+  err = heif_region_item_add_region_rectangle(region_item2, 370, 420, 10, 16, NULL);
+  REQUIRE(err.code == heif_error_Ok);
+  int32_t polygonPoints[6] = {100, 120, 115, 120, 125, 150};
+  int nPolygonPoints = (sizeof(polygonPoints)/sizeof(polygonPoints[0])) / 2;
+  err = heif_region_item_add_region_polygon(region_item2, polygonPoints, nPolygonPoints, NULL);
+  REQUIRE(err.code == heif_error_Ok);
+
+  err = heif_context_write_to_file(ctx, "regions.heif");
+  REQUIRE(err.code == heif_error_Ok);
+
+  heif_region_release(regionA);
+  heif_region_release(regionB);
+  heif_region_release(regionC);
+  heif_region_item_release(region_item1);
+  heif_region_item_release(region_item2);
+
+  heif_image_handle_release(handle);
+  heif_encoder_release(enc);
+  heif_encoding_options_free(options);
+  heif_context_free(ctx);
+  heif_image_release(img);
+
+  heif_context *readbackCtx = get_context_for_local_file("regions.heif");
+  heif_image_handle *readbackHandle = get_primary_image_handle(readbackCtx);
+  int num_region_items = heif_image_handle_get_number_of_region_items(readbackHandle);
+  REQUIRE(num_region_items == 2);
+  std::vector<heif_item_id> region_item_ids_minus(1);
+  int num_returned = heif_image_handle_get_list_of_region_item_ids(readbackHandle, region_item_ids_minus.data(), 1);
+  REQUIRE(num_returned == 1);
+  std::vector<heif_item_id> region_item_ids_extra(3);
+  num_returned = heif_image_handle_get_list_of_region_item_ids(readbackHandle, region_item_ids_extra.data(), 3);
+  REQUIRE(num_returned == num_region_items);
+  std::vector<heif_item_id> region_item_ids(num_region_items);
+  num_returned = heif_image_handle_get_list_of_region_item_ids(readbackHandle, region_item_ids.data(), num_region_items);
+  REQUIRE(num_returned == 2);
+  heif_region_item* in_region_1;
+  err = heif_context_get_region_item(readbackCtx, region_item_ids[0], &in_region_1);
+  heif_item_id id1 = heif_region_item_get_id(in_region_1);
+  REQUIRE(id1 == region_item_ids[0]);
+  uint32_t width1;
+  uint32_t height1;
+  heif_region_item_get_reference_size(in_region_1, &width1, &height1);
+  REQUIRE(width1 == input_width);
+  REQUIRE(height1 == input_height);
+  int num_regions_region_item1 = heif_region_item_get_number_of_regions(in_region_1);
+  REQUIRE(num_regions_region_item1 == 3);
+  std::vector<heif_region*> out_regions_1(num_regions_region_item1);
+  int num_regions1 = heif_region_item_get_list_of_regions(in_region_1, out_regions_1.data(), (int)(out_regions_1.size()));
+  REQUIRE(num_regions1 == num_regions_region_item1);
+  REQUIRE(heif_region_get_type(out_regions_1[0]) == heif_region_type_point);
+  int32_t x, y;
+  err = heif_region_get_point(out_regions_1[0], &x, &y);
+  REQUIRE (err.code == heif_error_Ok);
+  REQUIRE(x == 100);
+  REQUIRE(y == 200);
+  REQUIRE(heif_region_get_type(out_regions_1[1]) == heif_region_type_rectangle);
+  uint32_t width, height;
+  err = heif_region_get_rectangle(out_regions_1[1], &x, &y, &width, &height);
+  REQUIRE (err.code == heif_error_Ok);
+  REQUIRE(x == 150);
+  REQUIRE(y == 250);
+  REQUIRE(width == 30);
+  REQUIRE(height == 50);
+  REQUIRE(heif_region_get_type(out_regions_1[2]) == heif_region_type_polyline);
+  int num_polyline_points_out = heif_region_get_polyline_num_points(out_regions_1[2]);
+  REQUIRE(num_polyline_points_out == 3);
+  std::vector<int32_t> polyline(num_polyline_points_out * 2);
+  err = heif_region_get_polyline_points(out_regions_1[2], polyline.data());
+  REQUIRE(err.code == heif_error_Ok);
+  REQUIRE(polyline[0] == 10);
+  REQUIRE(polyline[1] == 20);
+  REQUIRE(polyline[2] == 15);
+  REQUIRE(polyline[3] == 20);
+  REQUIRE(polyline[4] == 15);
+  REQUIRE(polyline[5] == 50);
+  heif_region_release_many(out_regions_1.data(), (int)(out_regions_1.size()));
+
+  heif_region_item* in_region_2;
+  err = heif_context_get_region_item(readbackCtx, region_item_ids[1], &in_region_2);
+  heif_item_id id2 = heif_region_item_get_id(in_region_2);
+  REQUIRE(id2 == region_item_ids[1]);
+  uint32_t width2;
+  uint32_t height2;
+  heif_region_item_get_reference_size(in_region_2, &width2, &height2);
+  REQUIRE(width2 == input_width);
+  REQUIRE(height2 == input_height);
+  int num_regions_region_item2 = heif_region_item_get_number_of_regions(in_region_2);
+  REQUIRE(num_regions_region_item2 == 4);
+  std::vector<heif_region*> out_regions_2(num_regions_region_item2);
+  int num_regions2 = heif_region_item_get_list_of_regions(in_region_2, out_regions_2.data(), (int)(out_regions_2.size()));
+  REQUIRE(num_regions2 == num_regions_region_item2);
+  REQUIRE(heif_region_get_type(out_regions_2[0]) == heif_region_type_ellipse);
+  uint32_t radius_x, radius_y;
+  err = heif_region_get_ellipse(out_regions_2[0], &x, &y, &radius_x, &radius_y);
+  REQUIRE (err.code == heif_error_Ok);
+  REQUIRE(x == 350);
+  REQUIRE(y == 450);
+  REQUIRE(radius_x == 60);
+  REQUIRE(radius_y == 80);
+  heif_region_release(out_regions_2[0]);
+  REQUIRE(heif_region_get_type(out_regions_2[1]) == heif_region_type_point);
+  err = heif_region_get_point(out_regions_2[1], &x, &y);
+  REQUIRE (err.code == heif_error_Ok);
+  REQUIRE(x == 360);
+  REQUIRE(y == 460);
+  heif_region_release(out_regions_2[1]);
+  REQUIRE(heif_region_get_type(out_regions_2[2]) == heif_region_type_rectangle);
+  err = heif_region_get_rectangle(out_regions_2[2], &x, &y, &width, &height);
+  REQUIRE (err.code == heif_error_Ok);
+  REQUIRE(x == 370);
+  REQUIRE(y == 420);
+  REQUIRE(width == 10);
+  REQUIRE(height == 16);
+  heif_region_release(out_regions_2[2]);
+  REQUIRE(heif_region_get_type(out_regions_2[3]) == heif_region_type_polygon);
+  int num_polygon_points_out = heif_region_get_polygon_num_points(out_regions_2[3]);
+  REQUIRE(num_polygon_points_out == 3);
+  std::vector<int32_t> polygon(num_polygon_points_out * 2);
+  err = heif_region_get_polygon_points(out_regions_2[3], polygon.data());
+  REQUIRE(err.code == heif_error_Ok);
+  REQUIRE(polygon[0] == 100);
+  REQUIRE(polygon[1] == 120);
+  REQUIRE(polygon[2] == 115);
+  REQUIRE(polygon[3] == 120);
+  REQUIRE(polygon[4] == 125);
+  REQUIRE(polygon[5] == 150);
+  heif_region_release(out_regions_2[3]);
+
+  heif_region_item_release(in_region_1);
+  heif_region_item_release(in_region_2);
+  heif_image_handle_release(readbackHandle);
+  heif_context_free(readbackCtx);
+}
+
+TEST_CASE("create mask region") {
+  struct heif_error err;
+
+  heif_image* img;
+  uint32_t input_width = 1280;
+  uint32_t input_height = 1024;
+  heif_image_create(input_width, input_height, heif_colorspace_YCbCr,
+                    heif_chroma_420, &img);
+  fill_new_plane(img, heif_channel_Y, input_width, input_height);
+  fill_new_plane(img, heif_channel_Cb, (input_width + 1) / 2,
+                 (input_height + 1) / 2);
+  fill_new_plane(img, heif_channel_Cr, (input_width + 1) / 2,
+                 (input_height + 1) / 2);
+
+  heif_context *ctx = heif_context_alloc();
+  heif_encoder *enc;
+  err = heif_context_get_encoder_for_format(ctx, heif_compression_AV1, &enc);
+  REQUIRE(err.code == heif_error_Ok);
+
+  struct heif_encoding_options *options;
+  options = heif_encoding_options_alloc();
+  options->macOS_compatibility_workaround = false;
+  options->macOS_compatibility_workaround_no_nclx_profile = false;
+  options->image_orientation = heif_orientation_normal;
+
+  heif_image_handle *handle;
+  err = heif_context_encode_image(ctx, img, enc, options, &handle);
+  REQUIRE(err.code == heif_error_Ok);
+
+  heif_image *mask;
+  heif_image_create(128, 64, heif_colorspace_monochrome,
+                    heif_chroma_monochrome, &mask);
+  fill_new_plane(mask, heif_channel_Y, 128, 64);
+  int mask_stride;
+  uint8_t* p = heif_image_get_plane(mask, heif_channel_Y, &mask_stride);
+  p[0] = 0xff;
+  p[127] = 0x00;
+  p[128*64 - 1] = 0xfe;
+
+  heif_encoder *mask_enc;
+  err = heif_context_get_encoder_for_format(ctx, heif_compression_mask,
+                                            &mask_enc);
+  REQUIRE(err.code == heif_error_Ok);
+  heif_image_handle *mask_handle;
+  err = heif_context_encode_image(ctx, mask, mask_enc, options, &mask_handle);
+  REQUIRE(err.code == heif_error_Ok);
+
+  struct heif_region_item *region_item1;
+  err = heif_image_handle_add_region_item(handle, input_width, input_height,
+                                          &region_item1);
+  REQUIRE(err.code == heif_error_Ok);
+
+  err = heif_region_item_add_region_referenced_mask(
+      region_item1, 200, 140, 128, 64,
+      heif_image_handle_get_item_id(mask_handle), NULL);
+  REQUIRE(err.code == heif_error_Ok);
+  // TODO: maybe another mask or two?
+
+  err = heif_context_write_to_file(ctx, "regions_mask.heif");
+  REQUIRE(err.code == heif_error_Ok);
+
+  heif_region_item_release(region_item1);
+
+  heif_image_handle_release(handle);
+  heif_encoder_release(enc);
+  heif_image_handle_release(mask_handle);
+  heif_encoder_release(mask_enc);
+  heif_encoding_options_free(options);
+  heif_context_free(ctx);
+  heif_image_release(img);
+  heif_image_release(mask);
+
+  heif_context *readbackCtx = get_context_for_local_file("regions_mask.heif");
+  heif_image_handle *readbackHandle = get_primary_image_handle(readbackCtx);
+  int num_region_items = heif_image_handle_get_number_of_region_items(readbackHandle);
+  REQUIRE(num_region_items == 1);
+  std::vector<heif_item_id> region_item_ids(num_region_items);
+  int num_returned = heif_image_handle_get_list_of_region_item_ids(readbackHandle, region_item_ids.data(), num_region_items);
+  REQUIRE(num_returned == 1);
+  heif_region_item* in_region_item;
+  err = heif_context_get_region_item(readbackCtx, region_item_ids[0], &in_region_item);
+  heif_item_id id1 = heif_region_item_get_id(in_region_item);
+  REQUIRE(id1 == region_item_ids[0]);
+  int num_regions = heif_region_item_get_number_of_regions(in_region_item);
+  REQUIRE(num_regions == 1);
+  std::vector<heif_region*> regions(num_regions);
+  int num_regions_returned = heif_region_item_get_list_of_regions(in_region_item, regions.data(), (int)(regions.size()));
+  REQUIRE(num_regions_returned == num_regions);
+  REQUIRE(heif_region_get_type(regions[0]) == heif_region_type_referenced_mask);
+  int32_t x, y;
+  uint32_t width, height;
+  heif_item_id referenced_item_id;
+  err = heif_region_get_referenced_mask_ID(regions[0], &x, &y, &width, &height, &referenced_item_id);
+  REQUIRE (err.code == heif_error_Ok);
+  REQUIRE(x == 200);
+  REQUIRE(y == 140);
+  REQUIRE(width == 128);
+  REQUIRE(height == 64);
+  // This is kind of an implementation detail, but checks the iref is in the right direction
+  REQUIRE(referenced_item_id == 2);
+  heif_image_handle* mski_handle_in;
+  err = heif_context_get_image_handle(readbackCtx, referenced_item_id, &mski_handle_in);
+  REQUIRE(err.code == heif_error_Ok);
+  heif_image* mski_in;
+  err = heif_decode_image(mski_handle_in, &mski_in, heif_colorspace_monochrome, heif_chroma_monochrome, NULL);
+  REQUIRE(err.code == heif_error_Ok);
+  int mski_in_width = heif_image_get_width(mski_in, heif_channel_Y);
+  int mski_in_height = heif_image_get_height(mski_in, heif_channel_Y);
+  REQUIRE(mski_in_width == 128);
+  REQUIRE(mski_in_height == 64);
+  int mask_stride_in;
+  uint8_t* plane_in = heif_image_get_plane(mski_in, heif_channel_Y, &mask_stride_in);
+  REQUIRE(plane_in[0] == 0xff);
+  REQUIRE(plane_in[mski_in_width - 1] == 0x00);
+  REQUIRE(plane_in[mski_in_width*mski_in_height - 1] == 0xfe);
+
+  heif_region_release(regions[0]);
+  heif_image_release(mski_in);
+  heif_image_handle_release(mski_handle_in);
+  heif_region_item_release(in_region_item);
+  heif_image_handle_release(readbackHandle);
+  heif_context_free(readbackCtx);
+}
+
+
+TEST_CASE("create inline mask region from data") {
+  struct heif_error err;
+
+  heif_image* img;
+  uint32_t input_width = 1280;
+  uint32_t input_height = 1024;
+  heif_image_create(input_width, input_height, heif_colorspace_YCbCr,
+                    heif_chroma_420, &img);
+  fill_new_plane(img, heif_channel_Y, input_width, input_height);
+  fill_new_plane(img, heif_channel_Cb, (input_width + 1) / 2,
+                 (input_height + 1) / 2);
+  fill_new_plane(img, heif_channel_Cr, (input_width + 1) / 2,
+                 (input_height + 1) / 2);
+
+  heif_context *ctx = heif_context_alloc();
+  heif_encoder *enc;
+  err = heif_context_get_encoder_for_format(ctx, heif_compression_AV1, &enc);
+  REQUIRE(err.code == heif_error_Ok);
+
+  struct heif_encoding_options *options;
+  options = heif_encoding_options_alloc();
+  options->macOS_compatibility_workaround = false;
+  options->macOS_compatibility_workaround_no_nclx_profile = false;
+  options->image_orientation = heif_orientation_normal;
+
+  heif_image_handle *handle;
+  err = heif_context_encode_image(ctx, img, enc, options, &handle);
+  REQUIRE(err.code == heif_error_Ok);
+
+  struct heif_region_item *region_item1;
+  err = heif_image_handle_add_region_item(handle, input_width, input_height,
+                                          &region_item1);
+  REQUIRE(err.code == heif_error_Ok);
+
+  std::vector<uint8_t> mask_data((64 * 3) / 8);
+  mask_data[0] = 0x80;
+  mask_data[2] = 0x7f;
+  mask_data[10] = 0x3e;
+  mask_data[18] = 0x1d;
+  mask_data[23] = 0x01; 
+  err = heif_region_item_add_region_inline_mask_data(region_item1, 20, 50, 64, 3, mask_data.data(), mask_data.size(), NULL);
+  REQUIRE(err.code == heif_error_Ok);
+
+  err = heif_context_write_to_file(ctx, "regions_mask_inline_data.heif");
+  REQUIRE(err.code == heif_error_Ok);
+
+  heif_region_item_release(region_item1);
+
+  heif_image_handle_release(handle);
+  heif_encoder_release(enc);
+  heif_encoding_options_free(options);
+  heif_context_free(ctx);
+  heif_image_release(img);;
+
+  heif_context *readbackCtx = get_context_for_local_file("regions_mask_inline_data.heif");
+  heif_image_handle *readbackHandle = get_primary_image_handle(readbackCtx);
+  int num_region_items = heif_image_handle_get_number_of_region_items(readbackHandle);
+  REQUIRE(num_region_items == 1);
+  std::vector<heif_item_id> region_item_ids(num_region_items);
+  int num_returned = heif_image_handle_get_list_of_region_item_ids(readbackHandle, region_item_ids.data(), num_region_items);
+  REQUIRE(num_returned == 1);
+  heif_region_item* in_region_item;
+  err = heif_context_get_region_item(readbackCtx, region_item_ids[0], &in_region_item);
+  heif_item_id id1 = heif_region_item_get_id(in_region_item);
+  REQUIRE(id1 == region_item_ids[0]);
+  int num_regions = heif_region_item_get_number_of_regions(in_region_item);
+  REQUIRE(num_regions == 1);
+  std::vector<heif_region*> regions(num_regions);
+  int num_regions_returned = heif_region_item_get_list_of_regions(in_region_item, regions.data(), (int)(regions.size()));
+  REQUIRE(num_regions_returned == num_regions);
+  REQUIRE(heif_region_get_type(regions[0]) == heif_region_type_inline_mask);
+  size_t data_len = heif_region_get_inline_mask_data_len(regions[0]);
+  int32_t x, y;
+  uint32_t width, height;
+  std::vector<uint8_t> mask_data_in(data_len);
+  err = heif_region_get_inline_mask_data(regions[0], &x, &y, &width, &height, mask_data_in.data());
+  REQUIRE (err.code == heif_error_Ok);
+  REQUIRE(x == 20);
+  REQUIRE(y == 50);
+  REQUIRE(width == 64);
+  REQUIRE(height == 3);
+  REQUIRE(mask_data_in[0] == 0x80);
+  REQUIRE(mask_data_in[1] == 0x00);
+  REQUIRE(mask_data_in[2] == 0x7f);
+  REQUIRE(mask_data_in[10] == 0x3e);
+  REQUIRE(mask_data_in[18] == 0x1d);
+  REQUIRE(mask_data_in[23] == 0x01);
+  heif_region_release(regions[0]);
+
+  heif_region_item_release(in_region_item);
+  heif_image_handle_release(readbackHandle);
+  heif_context_free(readbackCtx);
+}
+
+
+TEST_CASE("create inline mask region from image") {
+  struct heif_error err;
+
+  heif_image* img;
+  uint32_t input_width = 1280;
+  uint32_t input_height = 1024;
+  heif_image_create(input_width, input_height, heif_colorspace_YCbCr,
+                    heif_chroma_420, &img);
+  fill_new_plane(img, heif_channel_Y, input_width, input_height);
+  fill_new_plane(img, heif_channel_Cb, (input_width + 1) / 2,
+                 (input_height + 1) / 2);
+  fill_new_plane(img, heif_channel_Cr, (input_width + 1) / 2,
+                 (input_height + 1) / 2);
+
+  heif_context *ctx = heif_context_alloc();
+  heif_encoder *enc;
+  err = heif_context_get_encoder_for_format(ctx, heif_compression_AV1, &enc);
+  REQUIRE(err.code == heif_error_Ok);
+
+  struct heif_encoding_options *options;
+  options = heif_encoding_options_alloc();
+  options->macOS_compatibility_workaround = false;
+  options->macOS_compatibility_workaround_no_nclx_profile = false;
+  options->image_orientation = heif_orientation_normal;
+
+  heif_image_handle *handle;
+  err = heif_context_encode_image(ctx, img, enc, options, &handle);
+  REQUIRE(err.code == heif_error_Ok);
+
+  struct heif_region_item *region_item1;
+  err = heif_image_handle_add_region_item(handle, input_width, input_height,
+                                          &region_item1);
+  REQUIRE(err.code == heif_error_Ok);
+
+  heif_image* mask_image;
+  heif_image_create(64, 3, heif_colorspace_monochrome,
+                    heif_chroma_monochrome, &mask_image);
+  err = heif_image_add_plane(mask_image, heif_channel_Y, 64, 3, 8);
+  REQUIRE(err.code == heif_error_Ok);
+  int stride;
+  uint8_t* p = heif_image_get_plane(mask_image, heif_channel_Y, &stride);
+  memset(p, 0, 3 * stride);
+  p[0] = 0x82;
+  p[17] = 0x81;
+  p[18] = 0x81;
+  p[19] = 0x81;
+  p[20] = 0x81;
+  p[21] = 0xff;
+  p[22] = 0xff;
+  p[23] = 0xff;
+  p[stride + 18] = 0x86;
+  p[stride + 19] = 0x86;
+  p[stride + 20] = 0x87;
+  p[stride + 21] = 0x87;
+  p[stride + 22] = 0x87;
+  p[2*stride + 19] = 0x81;
+  p[2*stride + 20] = 0x81;
+  p[2*stride + 21] = 0x81;
+  p[2*stride + 23] = 0x81;
+  p[2*stride + 63] = 0x81;
+  err = heif_region_item_add_region_inline_mask(region_item1, 20, 50, 64, 3, mask_image, NULL);
+  REQUIRE(err.code == heif_error_Ok);
+
+  err = heif_context_write_to_file(ctx, "regions_mask_inline_image.heif");
+  REQUIRE(err.code == heif_error_Ok);
+
+  heif_image_release(mask_image);
+  heif_region_item_release(region_item1);
+
+  heif_image_handle_release(handle);
+  heif_encoder_release(enc);
+  heif_encoding_options_free(options);
+  heif_context_free(ctx);
+  heif_image_release(img);;
+
+  heif_context *readbackCtx = get_context_for_local_file("regions_mask_inline_image.heif");
+  heif_image_handle *readbackHandle = get_primary_image_handle(readbackCtx);
+  int num_region_items = heif_image_handle_get_number_of_region_items(readbackHandle);
+  REQUIRE(num_region_items == 1);
+  std::vector<heif_item_id> region_item_ids(num_region_items);
+  int num_returned = heif_image_handle_get_list_of_region_item_ids(readbackHandle, region_item_ids.data(), num_region_items);
+  REQUIRE(num_returned == 1);
+  heif_region_item* in_region_item;
+  err = heif_context_get_region_item(readbackCtx, region_item_ids[0], &in_region_item);
+  heif_item_id id1 = heif_region_item_get_id(in_region_item);
+  REQUIRE(id1 == region_item_ids[0]);
+  int num_regions = heif_region_item_get_number_of_regions(in_region_item);
+  REQUIRE(num_regions == 1);
+  std::vector<heif_region*> regions(num_regions);
+  int num_regions_returned = heif_region_item_get_list_of_regions(in_region_item, regions.data(), (int)(regions.size()));
+  REQUIRE(num_regions_returned == num_regions);
+  REQUIRE(heif_region_get_type(regions[0]) == heif_region_type_inline_mask);
+  heif_image * mask_image_in;
+  int32_t x, y;
+  uint32_t width, height;
+  err = heif_region_get_mask_image(regions[0], &x, &y, &width, &height, &mask_image_in);
+  REQUIRE (err.code == heif_error_Ok);
+  REQUIRE(x == 20);
+  REQUIRE(y == 50);
+  REQUIRE(width == 64);
+  REQUIRE(height == 3);
+  uint8_t* p_in = heif_image_get_plane(mask_image_in, heif_channel_Y, &stride);
+  REQUIRE(p_in[0] == 0xff);
+  REQUIRE(p_in[1] == 0x00);
+  REQUIRE(p_in[8] == 0x00);
+  REQUIRE(p_in[16] == 0x00);
+  REQUIRE(p_in[17] == 0xff);
+  REQUIRE(p_in[18] == 0xff);
+  REQUIRE(p_in[19] == 0xff);
+  REQUIRE(p_in[20] == 0xff);
+  REQUIRE(p_in[21] == 0xff);
+  REQUIRE(p_in[22] == 0xff);
+  REQUIRE(p_in[23] == 0xff);
+  REQUIRE(p_in[24] == 0x00);
+  REQUIRE(p_in[81] == 0x00);
+  REQUIRE(p_in[82] == 0xff);
+  REQUIRE(p_in[83] == 0xff);
+  REQUIRE(p_in[84] == 0xff);
+  REQUIRE(p_in[85] == 0xff);
+  REQUIRE(p_in[86] == 0xff);
+  REQUIRE(p_in[87] == 0x00);
+  REQUIRE(p_in[146] == 0x00);
+  REQUIRE(p_in[147] == 0xff);
+  REQUIRE(p_in[148] == 0xff);
+  REQUIRE(p_in[149] == 0xff);
+  REQUIRE(p_in[150] == 0x00);
+  REQUIRE(p_in[151] == 0xff);
+  REQUIRE(p_in[190] == 0x00);
+  REQUIRE(p_in[191] == 0xff);
+  heif_image_release(mask_image_in);
+  heif_region_release(regions[0]);
+
+  heif_region_item_release(in_region_item);
+  heif_image_handle_release(readbackHandle);
+  heif_context_free(readbackCtx);
+}
diff --git a/tests/tai.cc b/tests/tai.cc
new file mode 100644
index 0000000000..7210a9f5b6
--- /dev/null
+++ b/tests/tai.cc
@@ -0,0 +1,140 @@
+/*
+  libheif unit tests
+
+  MIT License
+
+  Copyright (c) 2025 Dirk Farin <dirk.farin@gmail.com>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#include "catch_amalgamated.hpp"
+#include "test_utils.h"
+#include <libheif/heif.h>
+#include <libheif/heif_tai_timestamps.h>
+
+TEST_CASE( "image-tai" )
+{
+  heif_error err{};
+
+  err = heif_init(nullptr);
+  REQUIRE(err.code == heif_error_Ok);
+
+  std::string filename = get_tests_output_file_path("tai-1.heic");
+
+  heif_image* img = createImage_RGB_planar();
+  heif_encoder* enc = get_encoder_or_skip_test(heif_compression_HEVC);
+  heif_context* ctx = heif_context_alloc();
+
+  heif_image_handle* handle;
+  err = heif_context_encode_image(ctx, img, enc, nullptr, &handle);
+  REQUIRE(err.code == heif_error_Ok);
+  heif_item_id itemId = heif_image_handle_get_item_id(handle);
+
+  // add TAI clock info
+
+  heif_tai_clock_info* clock_info = heif_tai_clock_info_alloc();
+  clock_info->clock_resolution = 1000;
+  clock_info->clock_drift_rate = 123;
+  clock_info->clock_type = heif_tai_clock_info_clock_type_synchronized_to_atomic_source;
+  clock_info->time_uncertainty = 999;
+
+  err = heif_item_set_property_tai_clock_info(ctx, itemId, clock_info, nullptr);
+  REQUIRE(err.code == heif_error_Ok);
+
+  // check that adding a second timestamp leads to an error
+  err = heif_item_set_property_tai_clock_info(ctx, itemId, clock_info, nullptr);
+  REQUIRE(err.code != heif_error_Ok);
+
+  heif_tai_clock_info_release(clock_info);
+
+  // add TAI timestamp
+
+  heif_tai_timestamp_packet* timestamp = heif_tai_timestamp_packet_alloc();
+  timestamp->tai_timestamp = 1234567890;
+  timestamp->synchronization_state = 1;
+  timestamp->timestamp_generation_failure = 0;
+  timestamp->timestamp_is_modified = 0;
+
+  err = heif_item_set_property_tai_timestamp(ctx, itemId, timestamp, nullptr);
+  REQUIRE(err.code == heif_error_Ok);
+
+  // check that adding a second timestamp leads to an error
+  err = heif_item_set_property_tai_timestamp(ctx, itemId, timestamp, nullptr);
+  REQUIRE(err.code != heif_error_Ok);
+
+  heif_tai_timestamp_packet_release(timestamp);
+
+  err = heif_context_write_to_file(ctx, filename.c_str());
+  REQUIRE(err.code == heif_error_Ok);
+
+  heif_image_handle_release(handle);
+  heif_context_free(ctx);
+  heif_image_release(img);
+
+
+  // --- read file
+
+  ctx = heif_context_alloc();
+  err = heif_context_read_from_file(ctx, filename.c_str(), nullptr);
+  REQUIRE(err.code == heif_error_Ok);
+
+  err = heif_context_get_primary_image_handle(ctx, &handle);
+  REQUIRE(err.code == heif_error_Ok);
+
+  itemId = heif_image_handle_get_item_id(handle);
+
+  clock_info = nullptr; // make sure that we are not accidentally using old data
+  err = heif_item_get_property_tai_clock_info(ctx, itemId, &clock_info);
+  REQUIRE(err.code == heif_error_Ok);
+  REQUIRE(clock_info != nullptr);
+
+  timestamp = nullptr; // make sure that we are not accidentally using old data
+  err = heif_item_get_property_tai_timestamp(ctx, itemId, &timestamp);
+  REQUIRE(err.code == heif_error_Ok);
+  REQUIRE(timestamp != nullptr);
+
+  REQUIRE(clock_info->clock_resolution == 1000);
+  REQUIRE(clock_info->clock_drift_rate == 123);
+  REQUIRE(clock_info->clock_type == heif_tai_clock_info_clock_type_synchronized_to_atomic_source);
+  REQUIRE(clock_info->time_uncertainty == 999);
+  heif_tai_clock_info_release(clock_info);
+
+  REQUIRE(timestamp->tai_timestamp == 1234567890);
+  REQUIRE(timestamp->synchronization_state == 1);
+  REQUIRE(timestamp->timestamp_generation_failure == 0);
+  REQUIRE(timestamp->timestamp_is_modified == 0);
+  heif_tai_timestamp_packet_release(timestamp);
+
+  // check whether we can get the timestamp also from the decoded image
+
+  err = heif_decode_image(handle, &img, heif_colorspace_undefined, heif_chroma_undefined, nullptr);
+  REQUIRE(err.code == heif_error_Ok);
+
+  timestamp = nullptr; // make sure that we are not accidentally using old data
+  err = heif_image_get_tai_timestamp(img, &timestamp);
+  REQUIRE(err.code == heif_error_Ok);
+  REQUIRE(timestamp != nullptr);
+
+  REQUIRE(timestamp->tai_timestamp == 1234567890);
+  REQUIRE(timestamp->synchronization_state == 1);
+  REQUIRE(timestamp->timestamp_generation_failure == 0);
+  REQUIRE(timestamp->timestamp_is_modified == 0);
+  heif_tai_timestamp_packet_release(timestamp);
+}
\ No newline at end of file
diff --git a/tests/test-config.cc.in b/tests/test-config.cc.in
new file mode 100644
index 0000000000..cb356a6296
--- /dev/null
+++ b/tests/test-config.cc.in
@@ -0,0 +1,30 @@
+/*
+  libheif unit tests
+
+  MIT License
+
+  Copyright (c) 2023 struktur AG, Dirk Farin <dirk.farin@gmail.com>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#include <string>
+
+std::string tests_data_directory = "@TESTING_DATA_DIRECTORY@";
+std::string libheifio_tests_data_directory = "@LIBHEIFIO_TESTING_DATA_DIRECTORY@";
diff --git a/tests/test-config.h b/tests/test-config.h
new file mode 100644
index 0000000000..6664982f63
--- /dev/null
+++ b/tests/test-config.h
@@ -0,0 +1,36 @@
+/*
+  libheif unit tests
+
+  MIT License
+
+  Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#ifndef LIBHEIF_TEST_CONFIG_H
+#define LIBHEIF_TEST_CONFIG_H
+
+#include <string>
+
+// Absolute path to the tests/data directory. Can be used by the tests to load input data.
+extern std::string tests_data_directory;
+extern std::string libheifio_tests_data_directory;
+
+#endif //LIBHEIF_TEST_CONFIG_H
diff --git a/tests/test_utils.cc b/tests/test_utils.cc
new file mode 100644
index 0000000000..7ab38824e8
--- /dev/null
+++ b/tests/test_utils.cc
@@ -0,0 +1,221 @@
+/*
+  libheif test support utilities
+
+  MIT License
+
+  Copyright (c) 2023 Brad Hards <bradh@frogmouth.net>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#include "test_utils.h"
+#include "libheif/heif.h"
+#include "test-config.h"
+#include <cstring>
+#include "catch_amalgamated.hpp"
+
+
+heif_context * get_context_for_test_file(std::string filename)
+{
+  return get_context_for_local_file(tests_data_directory + "/" + filename);
+}
+
+heif_context * get_context_for_local_file(std::string filename)
+{
+  heif_context* context;
+  heif_error err;
+  context = heif_context_alloc();
+  err = heif_context_read_from_file(context, filename.c_str(), NULL);
+  INFO(filename);
+  REQUIRE(err.code == heif_error_Ok);
+  return context;
+}
+
+heif_image_handle * get_primary_image_handle(heif_context *context)
+{
+  heif_error err;
+  heif_image_handle * image_handle;
+  int num_images = heif_context_get_number_of_top_level_images(context);
+  REQUIRE(num_images == 1);
+  err =  heif_context_get_primary_image_handle(context, &image_handle);
+  REQUIRE(err.code == heif_error_Ok);
+  return image_handle;
+}
+
+heif_image * get_primary_image(heif_image_handle * handle)
+{
+  heif_error err;
+  heif_image* img;
+  err = heif_decode_image(handle, &img, heif_colorspace_RGB, heif_chroma_444, NULL);
+  REQUIRE(err.code == heif_error_Ok);
+  return img;
+}
+
+heif_image * get_primary_image_mono(heif_image_handle * handle)
+{
+  heif_error err;
+  heif_image* img;
+  err = heif_decode_image(handle, &img, heif_colorspace_monochrome, heif_chroma_monochrome, NULL);
+  REQUIRE(err.code == heif_error_Ok);
+  return img;
+}
+
+heif_image * get_primary_image_ycbcr(heif_image_handle * handle, heif_chroma chroma)
+{
+  heif_error err;
+  heif_image* img;
+  err = heif_decode_image(handle, &img, heif_colorspace_YCbCr, chroma, NULL);
+  REQUIRE(err.code == heif_error_Ok);
+  return img;
+}
+
+void fill_new_plane(heif_image* img, heif_channel channel, int w, int h)
+{
+  heif_error err;
+
+  err = heif_image_add_plane(img, channel, w, h, 8);
+  REQUIRE(err.code == heif_error_Ok);
+
+  int stride;
+  uint8_t* p = heif_image_get_plane(img, channel, &stride);
+
+  for (int y = 0; y < h; y++) {
+    memset(p + y * stride, 128, w);
+  }
+}
+
+heif_image * createImage_RGB_planar()
+{
+  heif_image *image;
+  heif_error err;
+  int w = 1024;
+  int h = 768;
+  err = heif_image_create(w, h, heif_colorspace_RGB,
+                          heif_chroma_444, &image);
+  if (err.code) {
+    return nullptr;
+  }
+
+  err = heif_image_add_plane(image, heif_channel_R, w, h, 8);
+  REQUIRE(err.code == heif_error_Ok);
+  err = heif_image_add_plane(image, heif_channel_G, w, h, 8);
+  REQUIRE(err.code == heif_error_Ok);
+  err = heif_image_add_plane(image, heif_channel_B, w, h, 8);
+  REQUIRE(err.code == heif_error_Ok);
+
+
+  int stride;
+  uint8_t *r = heif_image_get_plane(image, heif_channel_R, &stride);
+  uint8_t *g = heif_image_get_plane(image, heif_channel_G, &stride);
+  uint8_t *b = heif_image_get_plane(image, heif_channel_B, &stride);
+
+  int y = 0;
+  for (; y < h / 2; y++) {
+    int x = 0;
+    for (; x < w / 3; x++) {
+      r[y * stride + x] = 1;
+      g[y * stride + x] = 255;
+      b[y * stride + x] = 2;
+    }
+    for (; x < 2 * w / 3; x++) {
+      r[y * stride + x] = 4;
+      g[y * stride + x] = 5;
+      b[y * stride + x] = 255;
+    }
+    for (; x < w; x++) {
+      r[y * stride + x] = 255;
+      g[y * stride + x] = 6;
+      b[y * stride + x] = 7;
+    }
+  }
+  for (; y < h; y++) {
+    int x = 0;
+    for (; x < w / 3; x++) {
+      r[y * stride + x]= 8;
+      g[y * stride + x] = 9;
+      b[y * stride + x] = 255;
+    }
+    for (; x < 2 * w / 3; x++) {
+      r[y * stride + x] = 253;
+      g[y * stride + x] = 10;
+      b[y * stride + x] = 11;
+    }
+    for (; x < w; x++) {
+      r[y * stride + x] = 13;
+      g[y * stride + x] = 252;
+      b[y * stride + x] = 12;
+    }
+  }
+  if (err.code) {
+    heif_image_release(image);
+    return nullptr;
+  }
+
+  return image;
+}
+
+
+std::string get_path_for_heifio_test_file(std::string filename)
+{
+  return libheifio_tests_data_directory + "/" + filename;
+}
+
+
+heif_encoder* get_encoder_or_skip_test(heif_compression_format format)
+{
+  heif_encoder* encoder = nullptr;
+  heif_error err = heif_context_get_encoder_for_format(nullptr, format, &encoder);
+  if (err.code != heif_error_Ok) {
+    if (format == heif_compression_HEVC) {
+      SKIP("Encoder for HEVC not found, skipping test");
+    }
+    else if (format == heif_compression_AV1) {
+      SKIP("Encoder for AV1 not found, skipping test");
+    }
+    else {
+      SKIP("Encoder not found, skipping test");
+    }
+  }
+
+  return encoder;
+}
+
+
+fs::path get_tests_output_dir()
+{
+  if (const char* env_p = std::getenv("LIBHEIF_TEST_OUTPUT_DIR")) {
+    return fs::path(env_p);
+  }
+
+  static const fs::path output_dir = fs::current_path() / "libheif_test_output";
+
+  if (!fs::exists(output_dir)) {
+    fs::create_directories(output_dir);
+  }
+
+  return output_dir;
+}
+
+
+std::string get_tests_output_file_path(const char* filename)
+{
+  fs::path dir = get_tests_output_dir();
+  dir /= filename;
+  return dir.string();
+}
diff --git a/tests/test_utils.h b/tests/test_utils.h
new file mode 100644
index 0000000000..97ec114a69
--- /dev/null
+++ b/tests/test_utils.h
@@ -0,0 +1,53 @@
+/*
+  libheif test support utilities
+
+  MIT License
+
+  Copyright (c) 2023 Brad Hards <bradh@frogmouth.net>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#include <string>
+#include "libheif/heif.h"
+
+#include <filesystem>
+
+namespace fs = std::filesystem;
+
+heif_context * get_context_for_test_file(std::string filename);
+heif_context * get_context_for_local_file(std::string filename);
+
+heif_image_handle * get_primary_image_handle(heif_context *context);
+
+heif_image * get_primary_image(heif_image_handle * handle);
+heif_image * get_primary_image_mono(heif_image_handle * handle);
+heif_image * get_primary_image_ycbcr(heif_image_handle * handle, heif_chroma chroma);
+
+void fill_new_plane(heif_image* img, heif_channel channel, int w, int h);
+
+heif_image * createImage_RGB_planar();
+
+std::string get_path_for_heifio_test_file(std::string filename);
+
+heif_encoder* get_encoder_or_skip_test(heif_compression_format format);
+
+fs::path get_tests_output_dir();
+
+std::string get_tests_output_file_path(const char* filename);
diff --git a/tests/text.cc b/tests/text.cc
new file mode 100644
index 0000000000..edebbff1a7
--- /dev/null
+++ b/tests/text.cc
@@ -0,0 +1,166 @@
+/*
+  libheif integration tests for text items
+
+  MIT License
+
+  Copyright (c) 2025 Brad Hards <bradh@frogmouth.net>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#include "catch_amalgamated.hpp"
+#include "api_structs.h"
+#include "libheif/heif.h"
+#include "test-config.h"
+#include "test_utils.h"
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <libheif/heif_items.h>
+#include <libheif/heif_library.h>
+
+
+TEST_CASE("no text") {
+  // skip test if we do not have the uncompressed codec
+  if (!heif_have_decoder_for_format(heif_compression_uncompressed)) {
+    SKIP("Skipping test because uncompressed codec is not compiled.");
+  }
+
+  auto context = get_context_for_test_file("uncompressed_comp_RGB.heif");
+  heif_image_handle *handle = get_primary_image_handle(context);
+  int num_text_items = heif_image_handle_get_number_of_text_items(handle);
+  REQUIRE(num_text_items == 0);
+  heif_image_handle_release(handle);
+  heif_context_free(context);
+}
+
+TEST_CASE("create text item") {
+  // skip test if we do not have the uncompressed codec
+  if (!heif_have_decoder_for_format(heif_compression_uncompressed)) {
+    SKIP("Skipping test because uncompressed codec is not compiled.");
+  }
+  struct heif_error err;
+
+  heif_image* img;
+  uint32_t input_width = 1280;
+  uint32_t input_height = 1024;
+  heif_image_create(input_width,input_height, heif_colorspace_YCbCr, heif_chroma_420, &img);
+  fill_new_plane(img, heif_channel_Y, input_width, input_height);
+  fill_new_plane(img, heif_channel_Cb, (input_width+1)/2, (input_height+1)/2);
+  fill_new_plane(img, heif_channel_Cr, (input_width+1)/2, (input_height+1)/2);
+
+  heif_context* ctx = heif_context_alloc();
+  heif_encoder* enc;
+  err = heif_context_get_encoder_for_format(ctx, heif_compression_uncompressed, &enc);
+  REQUIRE(err.code == heif_error_Ok);
+
+  struct heif_encoding_options* options;
+  options = heif_encoding_options_alloc();
+  options->macOS_compatibility_workaround = false;
+  options->macOS_compatibility_workaround_no_nclx_profile = false;
+  options->image_orientation = heif_orientation_normal;
+
+  heif_image_handle* handle;
+  err = heif_context_encode_image(ctx, img, enc, options, &handle);
+  REQUIRE(err.code == heif_error_Ok);
+
+  struct heif_text_item* text_item1;
+  std::string text_body1("first string");
+  err = heif_image_handle_add_text_item(handle, "text/plain", text_body1.c_str(), &text_item1);
+  REQUIRE(err.code == heif_error_Ok);
+  err = heif_text_item_set_extended_language(text_item1, "en-AU", NULL);
+  REQUIRE(err.code == heif_error_Ok);
+
+  struct heif_text_item* text_item2;
+  std::string text_body2("a second string");
+  err = heif_image_handle_add_text_item(handle, "text/plain", text_body2.c_str(), &text_item2);
+  REQUIRE(err.code == heif_error_Ok);
+  heif_property_id elng_prop_id;
+  err = heif_text_item_set_extended_language(text_item2, "en-UK", &elng_prop_id);
+  REQUIRE(err.code == heif_error_Ok);
+  REQUIRE(elng_prop_id != 0);
+
+  err = heif_context_write_to_file(ctx, "text.heif");
+  REQUIRE(err.code == heif_error_Ok);
+
+  heif_text_item_release(text_item1);
+  heif_text_item_release(text_item2);
+
+  heif_image_handle_release(handle);
+  heif_encoder_release(enc);
+  heif_encoding_options_free(options);
+  heif_context_free(ctx);
+  heif_image_release(img);
+
+  heif_context *readbackCtx = get_context_for_local_file("text.heif");
+  heif_image_handle *readbackHandle = get_primary_image_handle(readbackCtx);
+  int num_text_items = heif_image_handle_get_number_of_text_items(readbackHandle);
+  REQUIRE(num_text_items == 2);
+
+  std::vector<heif_item_id> text_item_ids_minus(1);
+  int num_returned = heif_image_handle_get_list_of_text_item_ids(readbackHandle, text_item_ids_minus.data(), 1);
+  REQUIRE(num_returned == 1);
+
+  std::vector<heif_item_id> text_item_ids_extra(3);
+  num_returned = heif_image_handle_get_list_of_text_item_ids(readbackHandle, text_item_ids_extra.data(), 3);
+  REQUIRE(num_returned == num_text_items);
+
+  std::vector<heif_item_id> text_item_ids(num_text_items);
+  num_returned = heif_image_handle_get_list_of_text_item_ids(readbackHandle, text_item_ids.data(), num_text_items);
+  REQUIRE(num_returned == 2);
+
+  heif_text_item* text0;
+  err = heif_context_get_text_item(readbackCtx, text_item_ids[0], &text0);
+  heif_item_id id0 = heif_text_item_get_id(text0);
+  REQUIRE(id0 == text_item_ids[0]);
+
+  REQUIRE(heif_item_get_item_type(readbackCtx, text_item_ids[0]) == fourcc("mime"));
+  const char* content_type0 = heif_item_get_mime_item_content_type(readbackCtx, text_item_ids[0]);
+  REQUIRE(std::string(content_type0) == "text/plain");
+  const char* body0 = heif_text_item_get_content(text0);
+  REQUIRE(std::string(body0) == text_body1);
+  heif_string_release(body0);
+  char * elng0;
+  err = heif_item_get_property_extended_language(readbackCtx, id0, &elng0);
+  REQUIRE(err.code == heif_error_Ok);
+  REQUIRE(strcmp(elng0, "en-AU") == 0);
+  heif_string_release(elng0);
+
+  heif_text_item* text1;
+  err = heif_context_get_text_item(readbackCtx, text_item_ids[1], &text1);
+  heif_item_id id1 = heif_text_item_get_id(text1);
+  REQUIRE(id1 == text_item_ids[1]);
+
+  REQUIRE(heif_item_get_item_type(readbackCtx, text_item_ids[1]) == fourcc("mime"));
+  const char* content_type1 = heif_item_get_mime_item_content_type(readbackCtx, text_item_ids[0]);
+  REQUIRE(std::string(content_type1) == "text/plain");
+  const char* body1 = heif_text_item_get_content(text1);
+  REQUIRE(std::string(body1) == text_body2);
+  heif_string_release(body1);
+  char * elng1;
+  err = heif_item_get_property_extended_language(readbackCtx, id1, &elng1);
+  REQUIRE(err.code == heif_error_Ok);
+  REQUIRE(strcmp(elng1, "en-UK") == 0);
+  heif_string_release(elng1);
+
+  heif_text_item_release(text0);
+  heif_text_item_release(text1);
+  heif_image_handle_release(readbackHandle);
+  heif_context_free(readbackCtx);
+}
diff --git a/tests/tiffdecode.cc b/tests/tiffdecode.cc
new file mode 100644
index 0000000000..d8f7767271
--- /dev/null
+++ b/tests/tiffdecode.cc
@@ -0,0 +1,146 @@
+/*
+  libheifio TIFF decode unit tests
+
+  MIT License
+
+  Copyright (c) 2024 Brad Hards <bradh@frogmouth.net>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#include "catch_amalgamated.hpp"
+#include <cstdint>
+#include <iostream>
+#include "heifio/decoder.h"
+#include "heifio/decoder_tiff.h"
+#include "test_utils.h"
+#include "libheif/heif.h"
+#include "libheif/api_structs.h"
+
+#if HAVE_LIBTIFF
+void checkMono(InputImage input_image) {
+  REQUIRE(input_image.orientation == heif_orientation_normal);
+  REQUIRE(input_image.image != nullptr);
+  const heif_image* image = input_image.image.get();
+  REQUIRE(heif_image_get_colorspace(image) == heif_colorspace_monochrome);
+  REQUIRE(heif_image_get_chroma_format(image) == heif_chroma_monochrome);
+  REQUIRE(heif_image_get_width(image, heif_channel_Y) == 128);
+  REQUIRE(heif_image_get_height(image, heif_channel_Y) == 64);
+  REQUIRE(heif_image_get_bits_per_pixel(image, heif_channel_Y) == 8);
+  REQUIRE(heif_image_get_bits_per_pixel_range(image, heif_channel_Y) == 8);
+  REQUIRE(heif_image_has_channel(image, heif_channel_Y) == 1);
+  REQUIRE(heif_image_has_channel(image, heif_channel_R) == 0);
+  REQUIRE(heif_image_has_channel(image, heif_channel_G) == 0);
+  REQUIRE(heif_image_has_channel(image, heif_channel_B) == 0);
+  REQUIRE(heif_image_has_channel(image, heif_channel_interleaved) == 0);
+  REQUIRE(heif_image_has_channel(image, heif_channel_Cr) == 0);
+  REQUIRE(heif_image_has_channel(image, heif_channel_Cb) == 0);
+}
+
+TEST_CASE("mono8") {
+  InputImage input_image;
+  std::string path = get_path_for_heifio_test_file("mono.tif");
+  heif_error err = loadTIFF(path.c_str(), 10, &input_image);
+  REQUIRE(err.code == heif_error_Ok);
+  checkMono(input_image);
+}
+
+TEST_CASE("mono8planar") {
+  InputImage input_image;
+  std::string path = get_path_for_heifio_test_file("mono_planar.tif");
+  heif_error err = loadTIFF(path.c_str(), 10, &input_image);
+  REQUIRE(err.code == heif_error_Ok);
+  checkMono(input_image);
+}
+
+void checkRGB(InputImage input_image) {
+  REQUIRE(input_image.orientation == heif_orientation_normal);
+  REQUIRE(input_image.image != nullptr);
+  const struct heif_image* image = input_image.image.get();
+  REQUIRE(heif_image_get_colorspace(image) == heif_colorspace_RGB);
+  REQUIRE(heif_image_get_chroma_format(image) == heif_chroma_interleaved_RGB);
+  REQUIRE(heif_image_get_width(image, heif_channel_interleaved) == 32);
+  REQUIRE(heif_image_get_height(image, heif_channel_interleaved) == 10);
+  REQUIRE(heif_image_get_bits_per_pixel(image, heif_channel_interleaved) == 24);
+  REQUIRE(heif_image_get_bits_per_pixel_range(image, heif_channel_interleaved) == 8);
+  REQUIRE(heif_image_has_channel(image, heif_channel_Y) == 0);
+  REQUIRE(heif_image_has_channel(image, heif_channel_R) == 0);
+  REQUIRE(heif_image_has_channel(image, heif_channel_G) == 0);
+  REQUIRE(heif_image_has_channel(image, heif_channel_B) == 0);
+  REQUIRE(heif_image_has_channel(image, heif_channel_interleaved) == 1);
+  REQUIRE(heif_image_has_channel(image, heif_channel_Cr) == 0);
+  REQUIRE(heif_image_has_channel(image, heif_channel_Cb) == 0);
+}
+
+TEST_CASE("rgb") {
+  InputImage input_image;
+  std::string path = get_path_for_heifio_test_file("rgb.tif");
+  heif_error err = loadTIFF(path.c_str(), 10, &input_image);
+  REQUIRE(err.code == heif_error_Ok);
+  checkRGB(input_image);
+}
+
+TEST_CASE("rgb_planar") {
+  InputImage input_image;
+  std::string path = get_path_for_heifio_test_file("rgb_planar.tif");
+  heif_error err = loadTIFF(path.c_str(), 10, &input_image);
+  REQUIRE(err.code == heif_error_Ok);
+  checkRGB(input_image);
+}
+
+
+void checkRGBA(InputImage input_image) {
+  REQUIRE(input_image.orientation == heif_orientation_normal);
+  REQUIRE(input_image.image != nullptr);
+  const heif_image* image = input_image.image.get();
+  REQUIRE(heif_image_get_colorspace(image) == heif_colorspace_RGB);
+  REQUIRE(heif_image_get_chroma_format(image) == heif_chroma_interleaved_RGBA);
+  REQUIRE(heif_image_get_width(image, heif_channel_interleaved) == 32);
+  REQUIRE(heif_image_get_height(image, heif_channel_interleaved) == 10);
+  REQUIRE(heif_image_get_bits_per_pixel(image, heif_channel_interleaved) == 32);
+  REQUIRE(heif_image_get_bits_per_pixel_range(image, heif_channel_interleaved) == 8);
+  REQUIRE(heif_image_has_channel(image, heif_channel_Y) == 0);
+  REQUIRE(heif_image_has_channel(image, heif_channel_R) == 0);
+  REQUIRE(heif_image_has_channel(image, heif_channel_G) == 0);
+  REQUIRE(heif_image_has_channel(image, heif_channel_B) == 0);
+  REQUIRE(heif_image_has_channel(image, heif_channel_interleaved) == 1);
+  REQUIRE(heif_image_has_channel(image, heif_channel_Cr) == 0);
+  REQUIRE(heif_image_has_channel(image, heif_channel_Cb) == 0);
+}
+
+TEST_CASE("rgba") {
+  InputImage input_image;
+  std::string path = get_path_for_heifio_test_file("rgba.tif");
+  heif_error err = loadTIFF(path.c_str(), 10, &input_image);
+  REQUIRE(err.code == heif_error_Ok);
+  checkRGBA(input_image);
+}
+
+TEST_CASE("rgba_planar") {
+  InputImage input_image;
+  std::string path = get_path_for_heifio_test_file("rgba_planar.tif");
+  heif_error err = loadTIFF(path.c_str(), 10, &input_image);
+  REQUIRE(err.code == heif_error_Ok);
+  checkRGBA(input_image);
+}
+#else
+TEST_CASE("no_tiff dummy") {
+  // Dummy test if we don't have the TIFF library, so that testing does not fail with "No test ran".
+}
+#endif // HAVE_LIBTIFF
\ No newline at end of file
diff --git a/tests/uncompressed_box.cc b/tests/uncompressed_box.cc
new file mode 100644
index 0000000000..6f6d3a7506
--- /dev/null
+++ b/tests/uncompressed_box.cc
@@ -0,0 +1,921 @@
+/*
+  libheif uncompressed box unit tests
+
+  MIT License
+
+  Copyright (c) 2023 Brad Hards <bradh@frogmouth.net>
+  Copyright (c) 2026 Dirk Farin <dirk.farin@gmail.com>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#include "catch_amalgamated.hpp"
+#include "box.h"
+#include "libheif/heif.h"
+#include "codecs/uncompressed/unc_types.h"
+#include "codecs/uncompressed/unc_boxes.h"
+#include <cstdint>
+#include <iostream>
+
+
+TEST_CASE( "cmpd" )
+{
+    std::shared_ptr<Box_cmpd> cmpd = std::make_shared<Box_cmpd>();
+    REQUIRE(cmpd->get_components().size() == 0);
+    Box_cmpd::Component component;
+    component.component_type = 1;
+    cmpd->add_component(component);
+    REQUIRE(cmpd->get_components().size() == 1);
+    REQUIRE(cmpd->get_components()[0].component_type == 1);
+    REQUIRE(cmpd->get_components()[0].component_type_uri == "");
+    REQUIRE(cmpd->get_components()[0].get_component_type_name() == "Y\n");
+
+    StreamWriter writer;
+    Error err = cmpd->write(writer);
+    REQUIRE(err.error_code == heif_error_Ok);
+    const std::vector<uint8_t> bytes = writer.get_data();
+    std::vector<uint8_t> expected = {0x00, 0x00, 0x00, 0x0e, 'c', 'm', 'p', 'd', 0x00, 0x00, 0x00, 0x01, 0x00, 0x01};
+    REQUIRE(bytes == expected);
+
+    Indent indent;
+    std::string dump_output = cmpd->dump(indent);
+    REQUIRE(dump_output == "Box: cmpd -----\nsize: 0   (header size: 0)\ncomponent_type: Y\n");
+}
+
+TEST_CASE( "cmpd_multi" )
+{
+    std::shared_ptr<Box_cmpd> cmpd = std::make_shared<Box_cmpd>();
+    REQUIRE(cmpd->get_components().size() == 0);
+
+    Box_cmpd::Component red_component;
+    red_component.component_type = 4;
+    cmpd->add_component(red_component);
+
+    Box_cmpd::Component green_component;
+    green_component.component_type = 5;
+    cmpd->add_component(green_component);
+
+    Box_cmpd::Component blue_component;
+    blue_component.component_type = 6;
+    cmpd->add_component(blue_component);
+    REQUIRE(cmpd->get_components().size() == 3);
+    REQUIRE(cmpd->get_components()[0].component_type == 4);
+    REQUIRE(cmpd->get_components()[0].component_type_uri == "");
+    REQUIRE(cmpd->get_components()[0].get_component_type_name() == "red\n");
+    REQUIRE(cmpd->get_components()[1].component_type == 5);
+    REQUIRE(cmpd->get_components()[1].component_type_uri == "");
+    REQUIRE(cmpd->get_components()[1].get_component_type_name() == "green\n");
+    REQUIRE(cmpd->get_components()[2].component_type == 6);
+    REQUIRE(cmpd->get_components()[2].component_type_uri == "");
+    REQUIRE(cmpd->get_components()[2].get_component_type_name() == "blue\n");
+
+    StreamWriter writer;
+    Error err = cmpd->write(writer);
+    REQUIRE(err.error_code == heif_error_Ok);
+    const std::vector<uint8_t> bytes = writer.get_data();
+    std::vector<uint8_t> expected = {0x00, 0x00, 0x00, 0x12, 'c', 'm', 'p', 'd', 0x00, 0x00, 0x00, 0x03, 0x00, 0x04, 0x00, 0x05, 0x00, 0x06};
+    REQUIRE(bytes == expected);
+
+    Indent indent;
+    std::string dump_output = cmpd->dump(indent);
+    REQUIRE(dump_output == "Box: cmpd -----\nsize: 0   (header size: 0)\ncomponent_type: red\ncomponent_type: green\ncomponent_type: blue\n");
+}
+
+TEST_CASE( "cmpd_custom" )
+{
+    std::shared_ptr<Box_cmpd> cmpd = std::make_shared<Box_cmpd>();
+    REQUIRE(cmpd->get_components().size() == 0);
+
+    Box_cmpd::Component component0;
+    component0.component_type = 0x8000;
+    component0.component_type_uri = "http://example.com/custom_component_uri";
+    cmpd->add_component(component0);
+
+    Box_cmpd::Component component1;
+    component1.component_type = 0x8002;
+    component1.component_type_uri = "http://example.com/another_custom_component_uri";
+    cmpd->add_component(component1);
+
+    REQUIRE(cmpd->get_components().size() == 2);
+    REQUIRE(cmpd->get_components()[0].component_type == 0x8000);
+    REQUIRE(cmpd->get_components()[0].component_type_uri == "http://example.com/custom_component_uri");
+    REQUIRE(cmpd->get_components()[0].get_component_type_name() == "0x8000\n");
+    REQUIRE(cmpd->get_components()[1].component_type == 0x8002);
+    REQUIRE(cmpd->get_components()[1].component_type_uri == "http://example.com/another_custom_component_uri");
+    REQUIRE(cmpd->get_components()[1].get_component_type_name() == "0x8002\n");
+    StreamWriter writer;
+    Error err = cmpd->write(writer);
+    REQUIRE(err.error_code == heif_error_Ok);
+    const std::vector<uint8_t> bytes = writer.get_data();
+    std::vector<uint8_t> expected = {0x00, 0x00, 0x00, 0x68, 'c', 'm', 'p', 'd', 0x00, 0x00, 0x00, 0x02, 0x80, 0x00, 'h', 't', 't', 'p', ':',  '/', '/', 'e', 'x', 'a', 'm', 'p', 'l', 'e', '.', 'c', 'o', 'm', '/', 'c', 'u', 's', 't', 'o', 'm', '_', 'c', 'o', 'm', 'p', 'o', 'n', 'e', 'n', 't', '_', 'u', 'r', 'i', 0x00, 0x80, 0x02, 'h', 't', 't', 'p', ':',  '/', '/', 'e', 'x', 'a', 'm', 'p', 'l', 'e', '.', 'c', 'o', 'm', '/', 'a', 'n', 'o', 't', 'h', 'e', 'r', '_', 'c', 'u', 's', 't', 'o', 'm', '_', 'c', 'o', 'm', 'p', 'o', 'n', 'e', 'n', 't', '_', 'u', 'r', 'i', 0x00};
+    REQUIRE(bytes == expected);
+
+    Indent indent;
+    std::string dump_output = cmpd->dump(indent);
+    REQUIRE(dump_output == "Box: cmpd -----\nsize: 0   (header size: 0)\ncomponent_type: 0x8000\n| component_type_uri: http://example.com/custom_component_uri\ncomponent_type: 0x8002\n| component_type_uri: http://example.com/another_custom_component_uri\n");
+}
+
+TEST_CASE( "uncC" )
+{
+    std::shared_ptr<Box_uncC> uncC = std::make_shared<Box_uncC>();
+    uncC->set_profile(fourcc("rgba"));
+    REQUIRE(uncC->get_components().size() == 0);
+    Box_uncC::Component r;
+    r.component_index = 0;
+    r.component_bit_depth = 8;
+    r.component_format = component_format_unsigned;
+    r.component_align_size = 0;
+    uncC->add_component(r);
+    Box_uncC::Component g;
+    g.component_index = 1;
+    g.component_bit_depth = 8;
+    g.component_format = component_format_unsigned;
+    g.component_align_size = 0;
+    uncC->add_component(g);
+    Box_uncC::Component b;
+    b.component_index = 2;
+    b.component_bit_depth = 8;
+    b.component_format = component_format_unsigned;
+    b.component_align_size = 0;
+    uncC->add_component(b);
+    Box_uncC::Component a;
+    a.component_index = 3;
+    a.component_bit_depth = 8;
+    a.component_format = component_format_unsigned;
+    a.component_align_size = 0;
+    uncC->add_component(a);
+    uncC->set_sampling_type(sampling_mode_no_subsampling);
+    uncC->set_interleave_type(interleave_mode_pixel);
+
+    REQUIRE(uncC->get_components().size() == 4);
+    Box_uncC::Component component0 = uncC->get_components()[0];
+    REQUIRE(component0.component_index == 0);
+    REQUIRE(component0.component_bit_depth == 8);
+    REQUIRE(component0.component_format == 0);
+    REQUIRE(component0.component_align_size == 0);
+    Box_uncC::Component component1 = uncC->get_components()[1];
+    REQUIRE(component1.component_index == 1);
+    REQUIRE(component1.component_bit_depth == 8);
+    REQUIRE(component1.component_format == 0);
+    REQUIRE(component1.component_align_size == 0);
+    Box_uncC::Component component2 = uncC->get_components()[2];
+    REQUIRE(component2.component_index == 2);
+    REQUIRE(component2.component_bit_depth == 8);
+    REQUIRE(component2.component_format == 0);
+    REQUIRE(component2.component_align_size == 0);
+    Box_uncC::Component component3 = uncC->get_components()[3];
+    REQUIRE(component3.component_index == 3);
+    REQUIRE(component3.component_bit_depth == 8);
+    REQUIRE(component3.component_format == 0);
+    REQUIRE(component3.component_align_size == 0);
+    REQUIRE(uncC->get_sampling_type() == 0);
+    REQUIRE(uncC->get_interleave_type() == 1);
+    REQUIRE(uncC->get_block_size() == 0);
+    REQUIRE(uncC->is_components_little_endian() == false);
+    REQUIRE(uncC->is_block_pad_lsb() == false);
+    REQUIRE(uncC->is_block_little_endian() == false);
+    REQUIRE(uncC->is_pad_unknown() == false);
+    REQUIRE(uncC->get_pixel_size() == 0);
+    REQUIRE(uncC->get_row_align_size() == 0);
+    REQUIRE(uncC->get_tile_align_size() == 0);
+    REQUIRE(uncC->get_number_of_tile_columns() == 1);
+    REQUIRE(uncC->get_number_of_tile_rows() == 1);
+
+    StreamWriter writer;
+    Error err = uncC->write(writer);
+    REQUIRE(err.error_code == heif_error_Ok);
+    const std::vector<uint8_t> bytes = writer.get_data();
+    std::vector<uint8_t> expected = {
+    0x00, 0x00, 0x00, 0x40, 'u', 'n', 'c', 'C',
+    0x00, 0x00, 0x00, 0x00, 'r', 'g', 'b', 'a',
+    0x00, 0x00, 0x00, 0x04, 0, 0, 7, 0x00,
+    0x00, 0x00, 0x01, 0x07, 0x00, 0x00, 0x00, 0x02,
+    0x07, 0x00, 0x00, 0x00, 0x03, 0x07, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+    };
+    REQUIRE(bytes == expected);
+
+    Indent indent;
+    std::string dump_output = uncC->dump(indent);
+    REQUIRE(dump_output == "Box: uncC -----\nsize: 0   (header size: 0)\nprofile: 1919378017 (rgba)\ncomponent_index: 0\n| component_bit_depth: 8\n| component_format: unsigned\n| component_align_size: 0\ncomponent_index: 1\n| component_bit_depth: 8\n| component_format: unsigned\n| component_align_size: 0\ncomponent_index: 2\n| component_bit_depth: 8\n| component_format: unsigned\n| component_align_size: 0\ncomponent_index: 3\n| component_bit_depth: 8\n| component_format: unsigned\n| component_align_size: 0\nsampling_type: no subsampling\ninterleave_type: pixel\nblock_size: 0\ncomponents_little_endian: 0\nblock_pad_lsb: 0\nblock_little_endian: 0\nblock_reversed: 0\npad_unknown: 0\npixel_size: 0\nrow_align_size: 0\ntile_align_size: 0\nnum_tile_cols: 1\nnum_tile_rows: 1\n");
+}
+
+TEST_CASE("uncC_parse") {
+  std::vector<uint8_t> byteArray{
+    0x00, 0x00, 0x00, 0x40, 'u', 'n', 'c', 'C',
+    0x00, 0x00, 0x00, 0x00, 'r', 'g', 'b', 'a',
+    0x00, 0x00, 0x00, 0x04, 0, 0, 7, 0x00,
+    0x00, 0x00, 0x01, 0x07, 0x00, 0x00, 0x00, 0x02,
+    0x07, 0x00, 0x00, 0x00, 0x03, 0x07, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02
+    };
+
+  auto reader = std::make_shared<StreamReader_memory>(byteArray.data(),
+                                                      byteArray.size(), false);
+
+  BitstreamRange range(reader, byteArray.size());
+  std::shared_ptr<Box> box;
+  Error error = Box::read(range, &box, heif_get_global_security_limits());
+  REQUIRE(error == Error::Ok);
+  REQUIRE(range.error() == 0);
+
+  REQUIRE(box->get_short_type() == fourcc("uncC"));
+  REQUIRE(box->get_type_string() == "uncC");
+  std::shared_ptr<Box_uncC> uncC = std::dynamic_pointer_cast<Box_uncC>(box);
+  REQUIRE(uncC->get_number_of_tile_columns() == 2);
+  REQUIRE(uncC->get_number_of_tile_rows() == 3);
+  Indent indent;
+  std::string dumpResult = box->dump(indent);
+  REQUIRE(dumpResult == "Box: uncC -----\n"
+                        "size: 64   (header size: 12)\n"
+                        "profile: 1919378017 (rgba)\n"
+                        "component_index: 0\n"
+                        "| component_bit_depth: 8\n"
+                        "| component_format: unsigned\n"
+                        "| component_align_size: 0\n"
+                        "component_index: 1\n"
+                        "| component_bit_depth: 8\n"
+                        "| component_format: unsigned\n"
+                        "| component_align_size: 0\n"
+                        "component_index: 2\n"
+                        "| component_bit_depth: 8\n"
+                        "| component_format: unsigned\n"
+                        "| component_align_size: 0\n"
+                        "component_index: 3\n"
+                        "| component_bit_depth: 8\n"
+                        "| component_format: unsigned\n"
+                        "| component_align_size: 0\n"
+                        "sampling_type: no subsampling\n"
+                        "interleave_type: pixel\n"
+                        "block_size: 0\n"
+                        "components_little_endian: 0\n"
+                        "block_pad_lsb: 0\n"
+                        "block_little_endian: 0\n"
+                        "block_reversed: 0\n"
+                        "pad_unknown: 0\n"
+                        "pixel_size: 0\n"
+                        "row_align_size: 0\n"
+                        "tile_align_size: 0\n"
+                        "num_tile_cols: 2\n"
+                        "num_tile_rows: 3\n");
+}
+
+TEST_CASE("uncC_parse_no_overflow") {
+  std::vector<uint8_t> byteArray{
+    0x00, 0x00, 0x00, 0x40, 'u', 'n', 'c', 'C',
+    0x00, 0x00, 0x00, 0x00, 'r', 'g', 'b', 'a',
+    0x00, 0x00, 0x00, 0x04, 0, 0, 7, 0x00,
+    0x00, 0x00, 0x01, 0x07, 0x00, 0x00, 0x00, 0x02,
+    0x07, 0x00, 0x00, 0x00, 0x03, 0x07, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xfe
+    };
+
+  auto reader = std::make_shared<StreamReader_memory>(byteArray.data(),
+                                                      byteArray.size(), false);
+
+  BitstreamRange range(reader, byteArray.size());
+  std::shared_ptr<Box> box;
+  Error error = Box::read(range, &box, heif_get_disabled_security_limits());
+  REQUIRE(error == Error::Ok);
+  REQUIRE(range.error() == 0);
+
+  REQUIRE(box->get_short_type() == fourcc("uncC"));
+  REQUIRE(box->get_type_string() == "uncC");
+  std::shared_ptr<Box_uncC> uncC = std::dynamic_pointer_cast<Box_uncC>(box);
+  REQUIRE(uncC->get_number_of_tile_columns() == 4294967295);
+  REQUIRE(uncC->get_number_of_tile_rows() == 4294967295);
+}
+
+TEST_CASE("uncC_parse_excess_tile_cols") {
+  std::vector<uint8_t> byteArray{
+    0x00, 0x00, 0x00, 0x40, 'u', 'n', 'c', 'C',
+    0x00, 0x00, 0x00, 0x00, 'r', 'g', 'b', 'a',
+    0x00, 0x00, 0x00, 0x04, 0, 0, 7, 0x00,
+    0x00, 0x00, 0x01, 0x07, 0x00, 0x00, 0x00, 0x02,
+    0x07, 0x00, 0x00, 0x00, 0x03, 0x07, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x7f, 0xff
+    };
+
+  auto reader = std::make_shared<StreamReader_memory>(byteArray.data(),
+                                                      byteArray.size(), false);
+  BitstreamRange range(reader, byteArray.size());
+  std::shared_ptr<Box> box;
+  Error error = Box::read(range, &box, heif_get_global_security_limits());
+  REQUIRE(range.error() == 0);
+  REQUIRE(error.error_code == 6);
+  REQUIRE(error.sub_error_code == 1000);
+}
+
+TEST_CASE("uncC_parse_excess_tile_rows") {
+  std::vector<uint8_t> byteArray{
+    0x00, 0x00, 0x00, 0x40, 'u', 'n', 'c', 'C',
+    0x00, 0x00, 0x00, 0x00, 'r', 'g', 'b', 'a',
+    0x00, 0x00, 0x00, 0x04, 0, 0, 7, 0x00,
+    0x00, 0x00, 0x01, 0x07, 0x00, 0x00, 0x00, 0x02,
+    0x07, 0x00, 0x00, 0x00, 0x03, 0x07, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff
+    };
+
+  auto reader = std::make_shared<StreamReader_memory>(byteArray.data(),
+                                                      byteArray.size(), false);
+  BitstreamRange range(reader, byteArray.size());
+  std::shared_ptr<Box> box;
+  Error error = Box::read(range, &box, heif_get_global_security_limits());
+  REQUIRE(range.error() == 0);
+  REQUIRE(error.error_code == 6);
+  REQUIRE(error.sub_error_code == 1000);
+}
+
+TEST_CASE("cmpC_defl") {
+    std::vector<uint8_t> byteArray{
+      0x00, 0x00, 0x00, 0x11, 'c', 'm', 'p', 'C',
+      0x00, 0x00, 0x00, 0x00, 'd', 'e', 'f', 'l',
+      0x00
+      };
+
+    auto reader = std::make_shared<StreamReader_memory>(byteArray.data(),
+                                                        byteArray.size(), false);
+
+    BitstreamRange range(reader, byteArray.size());
+    std::shared_ptr<Box> box;
+    Error error = Box::read(range, &box, heif_get_global_security_limits());
+    REQUIRE(error == Error::Ok);
+    REQUIRE(range.error() == 0);
+
+    REQUIRE(box->get_short_type() == fourcc("cmpC"));
+    REQUIRE(box->get_type_string() == "cmpC");
+    std::shared_ptr<Box_cmpC> cmpC = std::dynamic_pointer_cast<Box_cmpC>(box);
+    REQUIRE(cmpC != nullptr);
+    REQUIRE(cmpC->get_compression_type() == fourcc("defl"));
+    REQUIRE(cmpC->get_compressed_unit_type() == 0);
+
+    StreamWriter writer;
+    Error err = cmpC->write(writer);
+    REQUIRE(err.error_code == heif_error_Ok);
+    const std::vector<uint8_t> written = writer.get_data();
+    REQUIRE(written == byteArray);
+
+    Indent indent;
+    std::string dump_output = cmpC->dump(indent);
+    REQUIRE(dump_output == "Box: cmpC -----\nsize: 17   (header size: 12)\ncompression_type: defl\ncompressed_entity_type: 0\n");
+
+}
+
+
+TEST_CASE("cmpC_zlib") {
+    std::vector<uint8_t> byteArray{
+      0x00, 0x00, 0x00, 0x11, 'c', 'm', 'p', 'C',
+      0x00, 0x00, 0x00, 0x00, 'z', 'l', 'i', 'b',
+      0x02
+      };
+
+    auto reader = std::make_shared<StreamReader_memory>(byteArray.data(),
+                                                        byteArray.size(), false);
+
+    BitstreamRange range(reader, byteArray.size());
+    std::shared_ptr<Box> box;
+    Error error = Box::read(range, &box, heif_get_global_security_limits());
+    REQUIRE(error == Error::Ok);
+    REQUIRE(range.error() == 0);
+
+    REQUIRE(box->get_short_type() == fourcc("cmpC"));
+    REQUIRE(box->get_type_string() == "cmpC");
+    std::shared_ptr<Box_cmpC> cmpC = std::dynamic_pointer_cast<Box_cmpC>(box);
+    REQUIRE(cmpC != nullptr);
+    REQUIRE(cmpC->get_compression_type() == fourcc("zlib"));
+    REQUIRE(cmpC->get_compressed_unit_type() == 2);
+
+    StreamWriter writer;
+    Error err = cmpC->write(writer);
+    REQUIRE(err.error_code == heif_error_Ok);
+    const std::vector<uint8_t> written = writer.get_data();
+    REQUIRE(written == byteArray);
+
+    Indent indent;
+    std::string dump_output = cmpC->dump(indent);
+    REQUIRE(dump_output == "Box: cmpC -----\nsize: 17   (header size: 12)\ncompression_type: zlib\ncompressed_entity_type: 2\n");
+
+}
+
+TEST_CASE("cmpC_brot") {
+    std::vector<uint8_t> byteArray{
+      0x00, 0x00, 0x00, 0x11, 'c', 'm', 'p', 'C',
+      0x00, 0x00, 0x00, 0x00, 'b', 'r', 'o', 't',
+      0x01
+      };
+
+    auto reader = std::make_shared<StreamReader_memory>(byteArray.data(),
+                                                        byteArray.size(), false);
+
+    BitstreamRange range(reader, byteArray.size());
+    std::shared_ptr<Box> box;
+    Error error = Box::read(range, &box, heif_get_global_security_limits());
+    REQUIRE(error == Error::Ok);
+    REQUIRE(range.error() == 0);
+
+    REQUIRE(box->get_short_type() == fourcc("cmpC"));
+    REQUIRE(box->get_type_string() == "cmpC");
+    std::shared_ptr<Box_cmpC> cmpC = std::dynamic_pointer_cast<Box_cmpC>(box);
+    REQUIRE(cmpC != nullptr);
+    REQUIRE(cmpC->get_compression_type() == fourcc("brot"));
+    REQUIRE(cmpC->get_compressed_unit_type() == 1);
+
+    StreamWriter writer;
+    Error err = cmpC->write(writer);
+    REQUIRE(err.error_code == heif_error_Ok);
+    const std::vector<uint8_t> written = writer.get_data();
+    REQUIRE(written == byteArray);
+
+    Indent indent;
+    std::string dump_output = cmpC->dump(indent);
+    REQUIRE(dump_output == "Box: cmpC -----\nsize: 17   (header size: 12)\ncompression_type: brot\ncompressed_entity_type: 1\n");
+
+  }
+
+
+TEST_CASE("icef_24_8_bit") {
+    std::vector<uint8_t> byteArray{
+      0x00, 0x00, 0x00, 0x19, 'i', 'c', 'e', 'f',
+      0x00, 0x00, 0x00, 0x00,
+      0b01000000,
+      0x00, 0x00, 0x00, 0x02,
+      0x00, 0x0a, 0x03, 0x03,
+      0x02, 0x03, 0x0a, 0x07
+      };
+
+    auto reader = std::make_shared<StreamReader_memory>(byteArray.data(),
+                                                        byteArray.size(), false);
+
+    BitstreamRange range(reader, byteArray.size());
+    std::shared_ptr<Box> box;
+    Error error = Box::read(range, &box, heif_get_global_security_limits());
+    REQUIRE(error == Error::Ok);
+    REQUIRE(range.error() == 0);
+
+    REQUIRE(box->get_short_type() == fourcc("icef"));
+    REQUIRE(box->get_type_string() == "icef");
+    std::shared_ptr<Box_icef> icef = std::dynamic_pointer_cast<Box_icef>(box);
+    REQUIRE(icef != nullptr);
+    REQUIRE(icef->get_units().size() == 2);
+    REQUIRE(icef->get_version() == 0);
+
+    StreamWriter writer;
+    Error err = icef->write(writer);
+    REQUIRE(err.error_code == heif_error_Ok);
+    const std::vector<uint8_t> written = writer.get_data();
+    REQUIRE(written == byteArray);
+
+    Indent indent;
+    std::string dump_output = icef->dump(indent);
+    REQUIRE(dump_output == "Box: icef -----\nsize: 25   (header size: 12)\nnum_compressed_units: 2\nunit_offset: 2563, unit_size: 3\nunit_offset: 131850, unit_size: 7\n");
+}
+
+
+TEST_CASE("icef_0_16_bit") {
+    std::vector<uint8_t> byteArray{
+      0x00, 0x00, 0x00, 0x15, 'i', 'c', 'e', 'f',
+      0x00, 0x00, 0x00, 0x00,
+      0b00000100,
+      0x00, 0x00, 0x00, 0x02,
+      0x40, 0x03,
+      0x0a, 0x07
+      };
+
+    auto reader = std::make_shared<StreamReader_memory>(byteArray.data(),
+                                                        byteArray.size(), false);
+
+    BitstreamRange range(reader, byteArray.size());
+    std::shared_ptr<Box> box;
+    Error error = Box::read(range, &box, heif_get_global_security_limits());
+    REQUIRE(error == Error::Ok);
+    REQUIRE(range.error() == 0);
+
+    REQUIRE(box->get_short_type() == fourcc("icef"));
+    REQUIRE(box->get_type_string() == "icef");
+    std::shared_ptr<Box_icef> icef = std::dynamic_pointer_cast<Box_icef>(box);
+    REQUIRE(icef != nullptr);
+    REQUIRE(icef->get_units().size() == 2);
+    REQUIRE(icef->get_units()[0].unit_offset == 0);
+    REQUIRE(icef->get_units()[0].unit_size == 16387);
+    REQUIRE(icef->get_units()[1].unit_offset == 16387);
+    REQUIRE(icef->get_units()[1].unit_size == 2567);
+    REQUIRE(icef->get_version() == 0);
+
+    StreamWriter writer;
+    Error err = icef->write(writer);
+    REQUIRE(err.error_code == heif_error_Ok);
+    const std::vector<uint8_t> written = writer.get_data();
+    REQUIRE(written == byteArray);
+
+    Indent indent;
+    std::string dump_output = icef->dump(indent);
+    REQUIRE(dump_output == "Box: icef -----\nsize: 21   (header size: 12)\nnum_compressed_units: 2\nunit_offset: 0, unit_size: 16387\nunit_offset: 16387, unit_size: 2567\n");
+}
+
+
+TEST_CASE("icef_32bit") {
+    std::vector<uint8_t> byteArray{
+      0x00, 0x00, 0x00, 0x21, 'i', 'c', 'e', 'f',
+      0x00, 0x00, 0x00, 0x00,
+      0b01101100,
+      0x00, 0x00, 0x00, 0x02,
+      0x00, 0x00, 0x03, 0x04, 0x01, 0x01, 0x02, 0x03,
+      0x01, 0x02, 0x03, 0x0a, 0x00, 0x04, 0x05, 0x07
+      };
+
+    auto reader = std::make_shared<StreamReader_memory>(byteArray.data(),
+                                                        byteArray.size(), false);
+
+    BitstreamRange range(reader, byteArray.size());
+    std::shared_ptr<Box> box;
+    Error error = Box::read(range, &box, heif_get_global_security_limits());
+    REQUIRE(error == Error::Ok);
+    REQUIRE(range.error() == 0);
+
+    REQUIRE(box->get_short_type() == fourcc("icef"));
+    REQUIRE(box->get_type_string() == "icef");
+    std::shared_ptr<Box_icef> icef = std::dynamic_pointer_cast<Box_icef>(box);
+    REQUIRE(icef != nullptr);
+    REQUIRE(icef->get_units().size() == 2);
+    REQUIRE(icef->get_units()[0].unit_offset == 772);
+    REQUIRE(icef->get_units()[0].unit_size == 16843267);
+    REQUIRE(icef->get_units()[1].unit_offset == 16909066);
+    REQUIRE(icef->get_units()[1].unit_size == 263431);
+    REQUIRE(icef->get_version() == 0);
+
+    StreamWriter writer;
+    Error err = icef->write(writer);
+    REQUIRE(err.error_code == heif_error_Ok);
+    const std::vector<uint8_t> written = writer.get_data();
+    REQUIRE(written == byteArray);
+
+    Indent indent;
+    std::string dump_output = icef->dump(indent);
+    REQUIRE(dump_output == "Box: icef -----\nsize: 33   (header size: 12)\nnum_compressed_units: 2\nunit_offset: 772, unit_size: 16843267\nunit_offset: 16909066, unit_size: 263431\n");
+}
+
+
+TEST_CASE("icef_uint64") {
+    std::vector<uint8_t> byteArray{
+      0x00, 0x00, 0x00, 0x31, 'i', 'c', 'e', 'f',
+      0x00, 0x00, 0x00, 0x00,
+      0b10010000,
+      0x00, 0x00, 0x00, 0x02,
+      0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x0a, 0x03,
+      0x00, 0x00, 0x00, 0x02, 0x00, 0x01, 0x02, 0x03,
+      0x00, 0x00, 0x00, 0x02, 0x00, 0x02, 0x03, 0x0a,
+      0x00, 0x00, 0x00, 0x03, 0x00, 0x04, 0x05, 0x07
+      };
+
+    auto reader = std::make_shared<StreamReader_memory>(byteArray.data(),
+                                                        byteArray.size(), false);
+
+    BitstreamRange range(reader, byteArray.size());
+    std::shared_ptr<Box> box;
+    Error error = Box::read(range, &box, heif_get_global_security_limits());
+    REQUIRE(error == Error::Ok);
+    REQUIRE(range.error() == 0);
+
+    REQUIRE(box->get_short_type() == fourcc("icef"));
+    REQUIRE(box->get_type_string() == "icef");
+    std::shared_ptr<Box_icef> icef = std::dynamic_pointer_cast<Box_icef>(box);
+    REQUIRE(icef != nullptr);
+    REQUIRE(icef->get_units().size() == 2);
+    REQUIRE(icef->get_units()[0].unit_offset == 4294969859L);
+    REQUIRE(icef->get_units()[0].unit_size ==  8590000643L);
+    REQUIRE(icef->get_units()[1].unit_offset == 8590066442L);
+    REQUIRE(icef->get_units()[1].unit_size ==  12885165319L);
+    REQUIRE(icef->get_version() == 0);
+
+    StreamWriter writer;
+    Error err = icef->write(writer);
+    REQUIRE(err.error_code == heif_error_Ok);
+    const std::vector<uint8_t> written = writer.get_data();
+    REQUIRE(written == byteArray);
+
+    Indent indent;
+    std::string dump_output = icef->dump(indent);
+    REQUIRE(dump_output == "Box: icef -----\nsize: 49   (header size: 12)\nnum_compressed_units: 2\nunit_offset: 4294969859, unit_size: 8590000643\nunit_offset: 8590066442, unit_size: 12885165319\n");
+}
+
+
+TEST_CASE("icef_bad_version") {
+    std::vector<uint8_t> byteArray{
+      0x00, 0x00, 0x00, 0x19, 'i', 'c', 'e', 'f',
+      0x01, 0x00, 0x00, 0x00,
+      0b01000000,
+      0x00, 0x00, 0x00, 0x02,
+      0x00, 0x0a, 0x03, 0x03,
+      0x02, 0x03, 0x0a, 0x07
+      };
+
+    auto reader = std::make_shared<StreamReader_memory>(byteArray.data(),
+                                                        byteArray.size(), false);
+
+    BitstreamRange range(reader, byteArray.size());
+    std::shared_ptr<Box> box;
+    Error error = Box::read(range, &box, heif_get_global_security_limits());
+    REQUIRE(error.error_code == heif_error_Unsupported_feature);
+    REQUIRE(error.sub_error_code == heif_suberror_Unsupported_data_version);
+    REQUIRE(error.message == std::string("icef box data version 1 is not implemented yet"));
+}
+
+
+TEST_CASE("cloc")
+{
+  // Construct and set field
+  auto cloc = std::make_shared<Box_cloc>();
+  cloc->set_chroma_location(2);
+  REQUIRE(cloc->get_chroma_location() == 2);
+
+  // Write
+  StreamWriter writer;
+  Error err = cloc->write(writer);
+  REQUIRE(err.error_code == heif_error_Ok);
+  const std::vector<uint8_t> bytes = writer.get_data();
+
+  // FullBox header (12 bytes) + 1 byte payload = 13 bytes
+  std::vector<uint8_t> expected = {
+    0x00, 0x00, 0x00, 0x0D, 'c', 'l', 'o', 'c',
+    0x00, 0x00, 0x00, 0x00,
+    0x02
+  };
+  REQUIRE(bytes == expected);
+
+  // Parse back
+  auto reader = std::make_shared<StreamReader_memory>(bytes.data(), bytes.size(), false);
+  BitstreamRange range(reader, bytes.size());
+  std::shared_ptr<Box> box;
+  Error error = Box::read(range, &box, heif_get_global_security_limits());
+  REQUIRE(error == Error::Ok);
+  REQUIRE(range.error() == 0);
+
+  REQUIRE(box->get_short_type() == fourcc("cloc"));
+  auto parsed = std::dynamic_pointer_cast<Box_cloc>(box);
+  REQUIRE(parsed != nullptr);
+  REQUIRE(parsed->get_chroma_location() == 2);
+
+  // Dump
+  Indent indent;
+  std::string dump_output = parsed->dump(indent);
+  REQUIRE(dump_output == "Box: cloc -----\nsize: 13   (header size: 12)\nversion: 0\nflags: 0\nchroma_location: 2 (h=0,   v=0)\n");
+}
+
+
+TEST_CASE("cloc_bad_version")
+{
+  std::vector<uint8_t> byteArray = {
+    0x00, 0x00, 0x00, 0x0D, 'c', 'l', 'o', 'c',
+    0x01, 0x00, 0x00, 0x00,
+    0x02
+  };
+
+  auto reader = std::make_shared<StreamReader_memory>(byteArray.data(), byteArray.size(), false);
+  BitstreamRange range(reader, byteArray.size());
+  std::shared_ptr<Box> box;
+  Error error = Box::read(range, &box, heif_get_global_security_limits());
+  REQUIRE(error.error_code == heif_error_Unsupported_feature);
+  REQUIRE(error.sub_error_code == heif_suberror_Unsupported_data_version);
+  REQUIRE(error.message == std::string("cloc box data version 1 is not implemented yet"));
+}
+
+
+TEST_CASE("cloc_out_of_range")
+{
+  std::vector<uint8_t> byteArray = {
+    0x00, 0x00, 0x00, 0x0D, 'c', 'l', 'o', 'c',
+    0x00, 0x00, 0x00, 0x00,
+    0x07
+  };
+
+  auto reader = std::make_shared<StreamReader_memory>(byteArray.data(), byteArray.size(), false);
+  BitstreamRange range(reader, byteArray.size());
+  std::shared_ptr<Box> box;
+  Error error = Box::read(range, &box, heif_get_global_security_limits());
+  REQUIRE(error.error_code == heif_error_Invalid_input);
+  REQUIRE(error.sub_error_code == heif_suberror_Invalid_parameter_value);
+}
+
+
+TEST_CASE("splz")
+{
+  // Construct: 2 component indices, 2x1 pattern, angles 45.0 and 90.0
+  auto splz = std::make_shared<Box_splz>();
+  PolarizationPattern pattern;
+  pattern.component_indices = {0, 1};
+  pattern.pattern_width = 2;
+  pattern.pattern_height = 1;
+  pattern.polarization_angles = {45.0f, 90.0f};
+  splz->set_pattern(pattern);
+
+  // Write
+  StreamWriter writer;
+  Error err = splz->write(writer);
+  REQUIRE(err.error_code == heif_error_Ok);
+  const std::vector<uint8_t> bytes = writer.get_data();
+
+  // FullBox header (12) + 4 (count) + 8 (2×index) + 4 (w+h) + 8 (2×float) = 36
+  std::vector<uint8_t> expected = {
+    0x00, 0x00, 0x00, 0x24, 's', 'p', 'l', 'z',
+    0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02,  // component_count = 2
+    0x00, 0x00, 0x00, 0x00,  // index[0] = 0
+    0x00, 0x00, 0x00, 0x01,  // index[1] = 1
+    0x00, 0x02,              // pattern_width = 2
+    0x00, 0x01,              // pattern_height = 1
+    0x42, 0x34, 0x00, 0x00,  // 45.0f
+    0x42, 0xB4, 0x00, 0x00   // 90.0f
+  };
+  REQUIRE(bytes == expected);
+
+  // Parse back
+  auto reader = std::make_shared<StreamReader_memory>(bytes.data(), bytes.size(), false);
+  BitstreamRange range(reader, bytes.size());
+  std::shared_ptr<Box> box;
+  Error error = Box::read(range, &box, heif_get_global_security_limits());
+  REQUIRE(error == Error::Ok);
+  REQUIRE(range.error() == 0);
+
+  REQUIRE(box->get_short_type() == fourcc("splz"));
+  auto parsed = std::dynamic_pointer_cast<Box_splz>(box);
+  REQUIRE(parsed != nullptr);
+
+  const auto& p = parsed->get_pattern();
+  REQUIRE(p.component_indices.size() == 2);
+  REQUIRE(p.component_indices[0] == 0);
+  REQUIRE(p.component_indices[1] == 1);
+  REQUIRE(p.pattern_width == 2);
+  REQUIRE(p.pattern_height == 1);
+  REQUIRE(p.polarization_angles.size() == 2);
+  REQUIRE(p.polarization_angles[0] == 45.0f);
+  REQUIRE(p.polarization_angles[1] == 90.0f);
+
+  // Dump
+  Indent indent;
+  std::string dump_output = parsed->dump(indent);
+  REQUIRE(dump_output == "Box: splz -----\n"
+                         "size: 36   (header size: 12)\n"
+                         "version: 0\n"
+                         "flags: 0\n"
+                         "component_count: 2\n"
+                         "  component_index[0]: 0\n"
+                         "  component_index[1]: 1\n"
+                         "pattern_width: 2\n"
+                         "pattern_height: 1\n"
+                         "  [0,0]: 45 degrees\n"
+                         "  [1,0]: 90 degrees\n");
+}
+
+
+TEST_CASE("splz_bad_version")
+{
+  std::vector<uint8_t> byteArray = {
+    0x00, 0x00, 0x00, 0x24, 's', 'p', 'l', 'z',
+    0x01, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01,
+    0x00, 0x02,
+    0x00, 0x01,
+    0x42, 0x34, 0x00, 0x00,
+    0x42, 0xB4, 0x00, 0x00
+  };
+
+  auto reader = std::make_shared<StreamReader_memory>(byteArray.data(), byteArray.size(), false);
+  BitstreamRange range(reader, byteArray.size());
+  std::shared_ptr<Box> box;
+  Error error = Box::read(range, &box, heif_get_global_security_limits());
+  REQUIRE(error.error_code == heif_error_Unsupported_feature);
+  REQUIRE(error.sub_error_code == heif_suberror_Unsupported_data_version);
+  REQUIRE(error.message == std::string("splz box data version 1 is not implemented yet"));
+}
+
+
+TEST_CASE("snuc")
+{
+  // Construct: 1 component index, nuc_is_applied=true, 2x1 image, 2 gains + 2 offsets
+  auto snuc = std::make_shared<Box_snuc>();
+  SensorNonUniformityCorrection nuc;
+  nuc.component_indices = {0};
+  nuc.nuc_is_applied = true;
+  nuc.image_width = 2;
+  nuc.image_height = 1;
+  nuc.nuc_gains = {1.0f, 2.0f};
+  nuc.nuc_offsets = {0.0f, 3.0f};
+  snuc->set_nuc(nuc);
+
+  // Write
+  StreamWriter writer;
+  Error err = snuc->write(writer);
+  REQUIRE(err.error_code == heif_error_Ok);
+  const std::vector<uint8_t> bytes = writer.get_data();
+
+  // FullBox header (12) + 4 (count) + 4 (index) + 1 (flags) + 4 (width) + 4 (height)
+  // + 8 (2×gain) + 8 (2×offset) = 45
+  std::vector<uint8_t> expected = {
+    0x00, 0x00, 0x00, 0x2D, 's', 'n', 'u', 'c',
+    0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01,  // component_count = 1
+    0x00, 0x00, 0x00, 0x00,  // index[0] = 0
+    0x80,                    // flags: nuc_is_applied = true
+    0x00, 0x00, 0x00, 0x02,  // image_width = 2
+    0x00, 0x00, 0x00, 0x01,  // image_height = 1
+    0x3F, 0x80, 0x00, 0x00,  // gain[0] = 1.0f
+    0x40, 0x00, 0x00, 0x00,  // gain[1] = 2.0f
+    0x00, 0x00, 0x00, 0x00,  // offset[0] = 0.0f
+    0x40, 0x40, 0x00, 0x00   // offset[1] = 3.0f
+  };
+  REQUIRE(bytes == expected);
+
+  // Parse back
+  auto reader = std::make_shared<StreamReader_memory>(bytes.data(), bytes.size(), false);
+  BitstreamRange range(reader, bytes.size());
+  std::shared_ptr<Box> box;
+  Error error = Box::read(range, &box, heif_get_global_security_limits());
+  REQUIRE(error == Error::Ok);
+  REQUIRE(range.error() == 0);
+
+  REQUIRE(box->get_short_type() == fourcc("snuc"));
+  auto parsed = std::dynamic_pointer_cast<Box_snuc>(box);
+  REQUIRE(parsed != nullptr);
+
+  const auto& n = parsed->get_nuc();
+  REQUIRE(n.component_indices.size() == 1);
+  REQUIRE(n.component_indices[0] == 0);
+  REQUIRE(n.nuc_is_applied == true);
+  REQUIRE(n.image_width == 2);
+  REQUIRE(n.image_height == 1);
+  REQUIRE(n.nuc_gains.size() == 2);
+  REQUIRE(n.nuc_gains[0] == 1.0f);
+  REQUIRE(n.nuc_gains[1] == 2.0f);
+  REQUIRE(n.nuc_offsets.size() == 2);
+  REQUIRE(n.nuc_offsets[0] == 0.0f);
+  REQUIRE(n.nuc_offsets[1] == 3.0f);
+
+  // Dump
+  Indent indent;
+  std::string dump_output = parsed->dump(indent);
+  REQUIRE(dump_output == "Box: snuc -----\n"
+                         "size: 45   (header size: 12)\n"
+                         "version: 0\n"
+                         "flags: 0\n"
+                         "component_count: 1\n"
+                         "  component_index[0]: 0\n"
+                         "nuc_is_applied: 1\n"
+                         "image_width: 2\n"
+                         "image_height: 1\n"
+                         "nuc_gains: 2 values\n"
+                         "nuc_offsets: 2 values\n");
+}
+
+
+TEST_CASE("snuc_bad_version")
+{
+  std::vector<uint8_t> byteArray = {
+    0x00, 0x00, 0x00, 0x2D, 's', 'n', 'u', 'c',
+    0x01, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00,
+    0x80,
+    0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01,
+    0x3F, 0x80, 0x00, 0x00,
+    0x40, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00,
+    0x40, 0x40, 0x00, 0x00
+  };
+
+  auto reader = std::make_shared<StreamReader_memory>(byteArray.data(), byteArray.size(), false);
+  BitstreamRange range(reader, byteArray.size());
+  std::shared_ptr<Box> box;
+  Error error = Box::read(range, &box, heif_get_global_security_limits());
+  REQUIRE(error.error_code == heif_error_Unsupported_feature);
+  REQUIRE(error.sub_error_code == heif_suberror_Unsupported_data_version);
+  REQUIRE(error.message == std::string("snuc box data version 1 is not implemented yet"));
+}
diff --git a/tests/uncompressed_decode.cc b/tests/uncompressed_decode.cc
new file mode 100644
index 0000000000..c938c82ab7
--- /dev/null
+++ b/tests/uncompressed_decode.cc
@@ -0,0 +1,169 @@
+/*
+  libheif integration tests for uncompressed decoder
+
+  MIT License
+
+  Copyright (c) 2023 Brad Hards <bradh@frogmouth.net>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+#include "catch_amalgamated.hpp"
+#include "libheif/heif.h"
+#include "api_structs.h"
+#include <cstdint>
+#include <stdio.h>
+#include "test_utils.h"
+#include <string.h>
+
+#include "uncompressed_decode.h"
+
+void check_image_handle_size(heif_context *&context) {
+  heif_image_handle *handle = get_primary_image_handle(context);
+  int ispe_width = heif_image_handle_get_ispe_width(handle);
+  REQUIRE(ispe_width == 30);
+  int ispe_height = heif_image_handle_get_ispe_height(handle);
+  REQUIRE(ispe_height == 20);
+  int width = heif_image_handle_get_width(handle);
+  REQUIRE(width == 30);
+  int height = heif_image_handle_get_height(handle);
+  REQUIRE(height == 20);
+
+  heif_image_handle_release(handle);
+}
+
+TEST_CASE("check image handle size") {
+  auto file = GENERATE(FILES, MONO_FILES, YUV_FILES);
+  auto context = get_context_for_test_file(file);
+  INFO("file name: " << file);
+  check_image_handle_size(context);
+  heif_context_free(context);
+}
+
+void check_image_handle_size_subsampled(heif_context *&context) {
+  heif_image_handle *handle = get_primary_image_handle(context);
+  int ispe_width = heif_image_handle_get_ispe_width(handle);
+  REQUIRE(ispe_width == 32);
+  int ispe_height = heif_image_handle_get_ispe_height(handle);
+  REQUIRE(ispe_height == 20);
+  int width = heif_image_handle_get_width(handle);
+  REQUIRE(width == 32);
+  int height = heif_image_handle_get_height(handle);
+  REQUIRE(height == 20);
+
+  heif_image_handle_release(handle);
+}
+
+
+TEST_CASE("check image handle size subsampled") {
+  auto file = GENERATE(YUV_422_FILES, YUV_420_FILES, YUV_16BIT_422_FILES, YUV_16BIT_420_FILES);
+  auto context = get_context_for_test_file(file);
+  INFO("file name: " << file);
+  check_image_handle_size_subsampled(context);
+  heif_context_free(context);
+}
+
+TEST_CASE("check image handle alpha channel") {
+  auto file = GENERATE(FILES, MONO_FILES, ALL_YUV_FILES);
+  auto context = get_context_for_test_file(file);
+  INFO("file name: " << file);
+  int expect_alpha = (strchr(file, 'A') == NULL) ? 0 : 1;
+  heif_image_handle *handle = get_primary_image_handle(context);
+  int has_alpha = heif_image_handle_has_alpha_channel(handle);
+  REQUIRE(has_alpha == expect_alpha);
+
+  heif_image_handle_release(handle);
+  heif_context_free(context);
+}
+
+void check_image_handle_no_depth_images(heif_context *&context) {
+  heif_image_handle *handle = get_primary_image_handle(context);
+
+  int has_depth = heif_image_handle_has_depth_image(handle);
+  REQUIRE(has_depth == 0);
+
+  int numdepth = heif_image_handle_get_number_of_depth_images(handle);
+  REQUIRE(numdepth == 0);
+
+  heif_image_handle_release(handle);
+}
+
+TEST_CASE("check image handle no depth images") {
+  auto file = GENERATE(FILES, MONO_FILES, ALL_YUV_FILES);
+  auto context = get_context_for_test_file(file);
+  INFO("file name: " << file);
+  check_image_handle_no_depth_images(context);
+  heif_context_free(context);
+}
+
+void check_image_handle_no_thumbnails(heif_context *&context) {
+  heif_image_handle *handle = get_primary_image_handle(context);
+
+  int numthumbs = heif_image_handle_get_number_of_thumbnails(handle);
+  REQUIRE(numthumbs == 0);
+
+  heif_image_handle_release(handle);
+}
+
+TEST_CASE("check image handle no thumbnails") {
+  auto file = GENERATE(FILES, MONO_FILES, ALL_YUV_FILES);
+  auto context = get_context_for_test_file(file);
+  INFO("file name: " << file);
+  check_image_handle_no_thumbnails(context);
+  heif_context_free(context);
+}
+
+void check_image_handle_no_aux_images(heif_context *&context) {
+  heif_image_handle *handle = get_primary_image_handle(context);
+
+  int num_aux = heif_image_handle_get_number_of_auxiliary_images(handle, 0);
+  REQUIRE(num_aux == 0);
+
+  heif_image_handle_release(handle);
+}
+
+TEST_CASE("check image handle no auxiliary images") {
+  auto file = GENERATE(FILES, MONO_FILES, ALL_YUV_FILES);
+  auto context = get_context_for_test_file(file);
+  INFO("file name: " << file);
+  check_image_handle_no_aux_images(context);
+  heif_context_free(context);
+}
+
+void check_image_handle_no_metadata(heif_context *&context) {
+  heif_image_handle *handle = get_primary_image_handle(context);
+
+  int num_metadata_blocks =
+      heif_image_handle_get_number_of_metadata_blocks(handle, NULL);
+  REQUIRE(num_metadata_blocks == 0);
+
+  heif_image_handle_release(handle);
+}
+
+TEST_CASE("check image handle no metadata blocks") {
+  auto file = GENERATE(FILES, MONO_FILES, ALL_YUV_FILES);
+  auto context = get_context_for_test_file(file);
+  INFO("file name: " << file);
+  check_image_handle_no_metadata(context);
+  heif_context_free(context);
+}
+
+TEST_CASE("check uncompressed is advertised") {
+  REQUIRE(heif_have_decoder_for_format(heif_compression_uncompressed));
+}
+
diff --git a/tests/uncompressed_decode.h b/tests/uncompressed_decode.h
new file mode 100644
index 0000000000..48ea344e4b
--- /dev/null
+++ b/tests/uncompressed_decode.h
@@ -0,0 +1,123 @@
+/*
+  libheif integration tests for uncompressed decoder
+
+  MIT License
+
+  Copyright (c) 2023 Brad Hards <bradh@frogmouth.net>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#define FILES_RGB \
+  "uncompressed_comp_ABGR.heif", "uncompressed_comp_ABGR.heif", \
+  "uncompressed_comp_RGB.heif", "uncompressed_comp_RGB_tiled.heif", \
+  "uncompressed_comp_RGB_tiled_row_tile_align.heif", \
+  "uncompressed_comp_RGxB.heif", "uncompressed_comp_RGxB_tiled.heif", \
+  "uncompressed_pix_ABGR.heif", "uncompressed_pix_ABGR_tiled.heif", \
+  "uncompressed_pix_RGB.heif", "uncompressed_pix_RGB_tiled.heif", \
+  "uncompressed_pix_RGB_tiled_row_tile_align.heif", \
+  "uncompressed_pix_RGxB.heif", "uncompressed_pix_RGxB_tiled.heif", \
+  "uncompressed_row_ABGR.heif", "uncompressed_row_ABGR_tiled.heif", \
+  "uncompressed_row_RGB.heif", "uncompressed_row_RGB_tiled.heif", \
+  "uncompressed_row_RGB_tiled_row_tile_align.heif", \
+  "uncompressed_row_RGxB.heif", "uncompressed_row_RGxB_tiled.heif", \
+  "uncompressed_tile_ABGR_tiled.heif", \
+  "uncompressed_tile_RGB_tiled.heif", \
+  "uncompressed_tile_RGB_tiled_row_tile_align.heif", \
+  "uncompressed_tile_RGxB_tiled.heif", \
+  "uncompressed_pix_R8G8B8A8_bsz0_psz10_tiled.heif", \
+  "uncompressed_pix_R8G8B8A8_bsz0_psz5_tiled.heif", \
+  "uncompressed_pix_R8G8B8_bsz0_psz10_tiled.heif", \
+  "uncompressed_pix_R8G8B8_bsz0_psz5_tiled.heif"
+
+#if HAVE_BROTLI
+  #define BROTLI_FILES "rgb_generic_compressed_brotli.heif",
+#else
+  #define BROTLI_FILES
+#endif
+
+#define FILES_GENERIC_COMPRESSED \
+  "rgb_generic_compressed_defl.heif", BROTLI_FILES \
+  "rgb_generic_compressed_tile_deflate.heif", "rgb_generic_compressed_zlib.heif", \
+  "rgb_generic_compressed_zlib_rows.heif", "rgb_generic_compressed_zlib_tiled.heif"
+
+#define FILES_16BIT_RGB \
+  "uncompressed_comp_B16R16G16.heif", "uncompressed_comp_B16R16G16_tiled.heif", \
+  "uncompressed_pix_B16R16G16.heif", "uncompressed_pix_B16R16G16_tiled.heif", \
+  "uncompressed_row_B16R16G16.heif", "uncompressed_row_B16R16G16_tiled.heif", \
+  "uncompressed_tile_B16R16G16_tiled.heif"
+
+#define FILES_7BIT_RGB \
+  "uncompressed_comp_R7+1G7+1B7+1_tiled.heif",  "uncompressed_comp_R7G7B7_tiled.heif", \
+  "uncompressed_comp_R7G7+1B7_tiled.heif", \
+  "uncompressed_pix_R7+1G7+1B7+1_tiled.heif", "uncompressed_pix_R7G7B7_tiled.heif", \
+  "uncompressed_pix_R7G7+1B7_tiled.heif", \
+  "uncompressed_row_R7+1G7+1B7+1_tiled.heif", "uncompressed_row_R7G7B7_tiled.heif", \
+  "uncompressed_row_R7G7+1B7_tiled.heif", \
+  "uncompressed_tile_R7+1G7+1B7+1_tiled.heif", "uncompressed_tile_R7G7B7_tiled.heif", \
+  "uncompressed_tile_R7G7+1B7_tiled.heif"
+
+#define FILES_565_RGB \
+  "uncompressed_comp_R5G6B5_tiled.heif", \
+  "uncompressed_pix_R5G6B5_tiled.heif", \
+  "uncompressed_row_R5G6B5_tiled.heif", \
+  "uncompressed_tile_R5G6B5_tiled.heif"
+
+#define FILES FILES_RGB, FILES_16BIT_RGB, FILES_7BIT_RGB, FILES_565_RGB
+
+#define MONO_FILES \
+  "uncompressed_comp_M.heif", "uncompressed_comp_M_tiled.heif", \
+  "uncompressed_pix_M.heif", "uncompressed_pix_M_tiled.heif", \
+  "uncompressed_row_M.heif", "uncompressed_row_M_tiled.heif", \
+  "uncompressed_tile_M_tiled.heif"
+
+#define YUV_422_FILES \
+  "uncompressed_comp_VUY_422.heif", "uncompressed_comp_YUV_422.heif", "uncompressed_comp_YVU_422.heif", \
+  "uncompressed_mix_VUY_422.heif", "uncompressed_mix_YUV_422.heif", "uncompressed_mix_YVU_422.heif"
+
+#define YUV_16BIT_422_FILES \
+  "uncompressed_comp_Y16U16V16_422.heif", "uncompressed_mix_Y16U16V16_422.heif"
+
+#define YUV_420_FILES \
+  "uncompressed_comp_VUY_420.heif", "uncompressed_comp_YUV_420.heif", "uncompressed_comp_YVU_420.heif", \
+  "uncompressed_mix_VUY_420.heif", "uncompressed_mix_YUV_420.heif", "uncompressed_mix_YVU_420.heif"
+
+#define YUV_16BIT_420_FILES \
+  "uncompressed_comp_Y16U16V16_420.heif", "uncompressed_mix_Y16U16V16_420.heif"
+
+#define YUV_FILES \
+  "uncompressed_comp_YUV_tiled.heif", \
+  "uncompressed_pix_YUV_tiled.heif", \
+  "uncompressed_row_YUV_tiled.heif", \
+  "uncompressed_tile_YUV_tiled.heif"
+
+#define ALL_YUV_FILES \
+  YUV_422_FILES, YUV_420_FILES, YUV_16BIT_422_FILES, YUV_16BIT_420_FILES, YUV_FILES
+
+#if 0
+ \
+"uncompressed_comp_p.heif", \
+"uncompressed_comp_p_tiled.heif", \
+"uncompressed_pix_p.heif", \
+"uncompressed_pix_p_tiled.heif", \
+"uncompressed_row_p.heif", \
+"uncompressed_row_p_tiled.heif", \
+"uncompressed_tile_p_tiled.heif"
+
+#endif
diff --git a/tests/uncompressed_decode_generic_compression.cc b/tests/uncompressed_decode_generic_compression.cc
new file mode 100644
index 0000000000..8bf22e084c
--- /dev/null
+++ b/tests/uncompressed_decode_generic_compression.cc
@@ -0,0 +1,216 @@
+/*
+  libheif integration tests for uncompressed decoder
+
+  MIT License
+
+  Copyright (c) 2023 Brad Hards <bradh@frogmouth.net>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+#include "catch_amalgamated.hpp"
+#include "libheif/heif.h"
+#include "api_structs.h"
+#include <cstdint>
+#include <stdio.h>
+#include "test_utils.h"
+#include <string.h>
+
+#include "uncompressed_decode.h"
+
+void check_image_size(struct heif_context *&context) {
+  heif_image_handle *handle = get_primary_image_handle(context);
+  heif_image *img = get_primary_image(handle);
+
+  REQUIRE(heif_image_has_channel(img, heif_channel_Y) == 0);
+  REQUIRE(heif_image_has_channel(img, heif_channel_Cb) == 0);
+  REQUIRE(heif_image_has_channel(img, heif_channel_Cr) == 0);
+  REQUIRE(heif_image_has_channel(img, heif_channel_R) == 1);
+  REQUIRE(heif_image_has_channel(img, heif_channel_G) == 1);
+  REQUIRE(heif_image_has_channel(img, heif_channel_B) == 1);
+  REQUIRE(heif_image_has_channel(img, heif_channel_Alpha) == 0);
+  REQUIRE(heif_image_has_channel(img, heif_channel_interleaved) == 0);
+  int width = heif_image_get_primary_width(img);
+  REQUIRE(width == 128);
+  int height = heif_image_get_primary_height(img);
+  REQUIRE(height == 72);
+  width = heif_image_get_width(img, heif_channel_R);
+  REQUIRE(width == 128);
+  height = heif_image_get_height(img, heif_channel_R);
+  REQUIRE(height == 72);
+  width = heif_image_get_width(img, heif_channel_G);
+  REQUIRE(width == 128);
+  height = heif_image_get_height(img, heif_channel_G);
+  REQUIRE(height == 72);
+  width = heif_image_get_width(img, heif_channel_B);
+  REQUIRE(width == 128);
+  height = heif_image_get_height(img, heif_channel_B);
+  REQUIRE(height == 72);
+
+  int pixel_depth = heif_image_get_bits_per_pixel(img, heif_channel_R);
+  REQUIRE(pixel_depth == 8);
+  pixel_depth = heif_image_get_bits_per_pixel(img, heif_channel_G);
+  REQUIRE(pixel_depth == 8);
+  pixel_depth = heif_image_get_bits_per_pixel(img, heif_channel_B);
+  REQUIRE(pixel_depth == 8);
+
+  int pixel_range = heif_image_get_bits_per_pixel_range(img, heif_channel_R);
+  REQUIRE(pixel_range == 8);
+  pixel_range = heif_image_get_bits_per_pixel_range(img, heif_channel_G);
+  REQUIRE(pixel_range == 8);
+  pixel_range = heif_image_get_bits_per_pixel_range(img, heif_channel_B);
+  REQUIRE(pixel_range == 8);
+
+  heif_image_release(img);
+  heif_image_handle_release(handle);
+}
+
+TEST_CASE("check image size") {
+  auto file = GENERATE(FILES_GENERIC_COMPRESSED);
+  auto context = get_context_for_test_file(file);
+  INFO("file name: " << file);
+  check_image_size(context);
+  heif_context_free(context);
+}
+
+
+void check_image_content(struct heif_context *&context) {
+  heif_image_handle *handle = get_primary_image_handle(context);
+  heif_image *img = get_primary_image(handle);
+
+  int stride;
+  const uint8_t *img_plane =
+      heif_image_get_plane_readonly(img, heif_channel_R, &stride);
+  REQUIRE(stride == 128);
+  for (int row = 0; row < 24; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 31])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 32])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 63])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 64])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 95])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 96])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 127])) == 0);
+  }
+  for (int row = 24; row < 48; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 31])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 32])) == 64);
+    REQUIRE(((int)(img_plane[stride * row + 63])) == 64);
+    REQUIRE(((int)(img_plane[stride * row + 64])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 95])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 96])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 127])) == 255);
+  }
+  for (int row = 48; row < 72; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 192);
+    REQUIRE(((int)(img_plane[stride * row + 31])) == 192);
+    REQUIRE(((int)(img_plane[stride * row + 32])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 63])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 64])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 95])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 96])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 127])) == 255);
+  }
+
+  img_plane = heif_image_get_plane_readonly(img, heif_channel_G, &stride);
+  REQUIRE(stride == 128);
+  for (int row = 0; row < 24; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 31])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 32])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 63])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 64])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 95])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 96])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 127])) == 0);
+  }
+  for (int row = 24; row < 48; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 31])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 32])) == 64);
+    REQUIRE(((int)(img_plane[stride * row + 63])) == 64);
+    REQUIRE(((int)(img_plane[stride * row + 64])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 95])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 96])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 127])) == 0);
+  }
+  for (int row = 48; row < 72; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 192);
+    REQUIRE(((int)(img_plane[stride * row + 31])) == 192);
+    REQUIRE(((int)(img_plane[stride * row + 32])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 63])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 64])) == 175);
+    REQUIRE(((int)(img_plane[stride * row + 95])) == 175);
+    REQUIRE(((int)(img_plane[stride * row + 96])) == 200);
+    REQUIRE(((int)(img_plane[stride * row + 127])) == 200);
+  }
+
+  img_plane = heif_image_get_plane_readonly(img, heif_channel_B, &stride);
+  REQUIRE(stride == 128);
+  for (int row = 0; row < 24; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 31])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 32])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 63])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 64])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 95])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 96])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 127])) == 0);
+  }
+  for (int row = 24; row < 48; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 31])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 32])) == 64);
+    REQUIRE(((int)(img_plane[stride * row + 63])) == 64);
+    REQUIRE(((int)(img_plane[stride * row + 64])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 95])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 96])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 127])) == 255);
+  }
+  for (int row = 48; row < 72; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 192);
+    REQUIRE(((int)(img_plane[stride * row + 31])) == 192);
+    REQUIRE(((int)(img_plane[stride * row + 32])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 63])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 64])) == 175);
+    REQUIRE(((int)(img_plane[stride * row + 95])) == 175);
+    REQUIRE(((int)(img_plane[stride * row + 96])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 127])) == 0);
+  }
+
+  heif_image_release(img);
+  heif_image_handle_release(handle);
+}
+
+TEST_CASE("check image content") {
+  auto file = GENERATE(FILES_GENERIC_COMPRESSED);
+  auto context = get_context_for_test_file(file);
+  INFO("file name: " << file);
+  check_image_content(context);
+  heif_context_free(context);
+}
diff --git a/tests/uncompressed_decode_mono.cc b/tests/uncompressed_decode_mono.cc
new file mode 100644
index 0000000000..b1f22cbaac
--- /dev/null
+++ b/tests/uncompressed_decode_mono.cc
@@ -0,0 +1,199 @@
+/*
+  libheif integration tests for uncompressed decoder
+
+  MIT License
+
+  Copyright (c) 2023 Brad Hards <bradh@frogmouth.net>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+#include "catch_amalgamated.hpp"
+#include "libheif/heif.h"
+#include "api_structs.h"
+#include <cstdint>
+#include <stdio.h>
+#include "test_utils.h"
+#include <string.h>
+
+#include "uncompressed_decode.h"
+
+
+void check_image_size_mono(struct heif_context *&context, int expect_alpha) {
+  heif_image_handle *handle = get_primary_image_handle(context);
+  heif_image *img = get_primary_image_mono(handle);
+
+  REQUIRE(heif_image_has_channel(img, heif_channel_Y) == 1);
+  REQUIRE(heif_image_has_channel(img, heif_channel_Cb) == 0);
+  REQUIRE(heif_image_has_channel(img, heif_channel_Cr) == 0);
+  REQUIRE(heif_image_has_channel(img, heif_channel_R) == 0);
+  REQUIRE(heif_image_has_channel(img, heif_channel_G) == 0);
+  REQUIRE(heif_image_has_channel(img, heif_channel_B) == 0);
+  REQUIRE(heif_image_has_channel(img, heif_channel_Alpha) == expect_alpha);
+  REQUIRE(heif_image_has_channel(img, heif_channel_interleaved) == 0);
+  int width = heif_image_get_primary_width(img);
+  REQUIRE(width == 30);
+  int height = heif_image_get_primary_height(img);
+  REQUIRE(height == 20);
+  width = heif_image_get_width(img, heif_channel_Y);
+  REQUIRE(width == 30);
+  height = heif_image_get_height(img, heif_channel_Y);
+  REQUIRE(height == 20);
+  if (expect_alpha == 1) {
+    width = heif_image_get_width(img, heif_channel_Alpha);
+    REQUIRE(width == 30);
+    height = heif_image_get_height(img, heif_channel_Alpha);
+    REQUIRE(height == 20);
+  }
+
+  int pixel_depth = heif_image_get_bits_per_pixel(img, heif_channel_Y);
+  REQUIRE(pixel_depth == 8);
+
+  int pixel_range = heif_image_get_bits_per_pixel_range(img, heif_channel_Y);
+  REQUIRE(pixel_range == 8);
+
+  heif_image_release(img);
+  heif_image_handle_release(handle);
+}
+
+TEST_CASE("check image size mono") {
+  auto file = GENERATE(MONO_FILES);
+  auto context = get_context_for_test_file(file);
+  INFO("file name: " << file);
+  int expect_alpha = (strchr(file, 'A') == NULL) ? 0 : 1;
+  check_image_size_mono(context, expect_alpha);
+  heif_context_free(context);
+}
+
+void check_image_content_mono(struct heif_context *&context) {
+  heif_image_handle *handle = get_primary_image_handle(context);
+  REQUIRE(handle != nullptr);
+  heif_image *img = get_primary_image_mono(handle);
+
+  int stride;
+  const uint8_t *img_plane =
+      heif_image_get_plane_readonly(img, heif_channel_Y, &stride);
+  REQUIRE(stride == 64);
+  for (int row = 0; row < 4; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 128);
+  }
+  for (int row = 4; row < 8; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 255);
+  }
+  for (int row = 8; row < 12; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 238);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 238);
+  }
+  for (int row = 12; row < 16; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 238);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 238);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 255);
+  }
+  for (int row = 16; row < 20; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 9])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 238);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 238);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 0);
+  }
+
+  heif_image_handle_release(handle);
+  heif_image_release(img);
+}
+
+TEST_CASE("check image content mono") {
+  auto file = GENERATE(MONO_FILES);
+  auto context = get_context_for_test_file(file);
+  INFO("file name: " << file);
+  check_image_content_mono(context);
+  heif_context_free(context);
+}
+
diff --git a/tests/uncompressed_decode_rgb.cc b/tests/uncompressed_decode_rgb.cc
new file mode 100644
index 0000000000..c2455a414d
--- /dev/null
+++ b/tests/uncompressed_decode_rgb.cc
@@ -0,0 +1,407 @@
+/*
+  libheif integration tests for uncompressed decoder
+
+  MIT License
+
+  Copyright (c) 2023 Brad Hards <bradh@frogmouth.net>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+#include "catch_amalgamated.hpp"
+#include "libheif/heif.h"
+#include "api_structs.h"
+#include <cstdint>
+#include <stdio.h>
+#include "test_utils.h"
+#include <string.h>
+
+#include "uncompressed_decode.h"
+
+void check_image_size(heif_context *&context, int expect_alpha) {
+  heif_image_handle *handle = get_primary_image_handle(context);
+  heif_image *img = get_primary_image(handle);
+
+  REQUIRE(heif_image_has_channel(img, heif_channel_Y) == 0);
+  REQUIRE(heif_image_has_channel(img, heif_channel_Cb) == 0);
+  REQUIRE(heif_image_has_channel(img, heif_channel_Cr) == 0);
+  REQUIRE(heif_image_has_channel(img, heif_channel_R) == 1);
+  REQUIRE(heif_image_has_channel(img, heif_channel_G) == 1);
+  REQUIRE(heif_image_has_channel(img, heif_channel_B) == 1);
+  REQUIRE(heif_image_has_channel(img, heif_channel_Alpha) == expect_alpha);
+  REQUIRE(heif_image_has_channel(img, heif_channel_interleaved) == 0);
+  int width = heif_image_get_primary_width(img);
+  REQUIRE(width == 30);
+  int height = heif_image_get_primary_height(img);
+  REQUIRE(height == 20);
+  width = heif_image_get_width(img, heif_channel_R);
+  REQUIRE(width == 30);
+  height = heif_image_get_height(img, heif_channel_R);
+  REQUIRE(height == 20);
+  width = heif_image_get_width(img, heif_channel_G);
+  REQUIRE(width == 30);
+  height = heif_image_get_height(img, heif_channel_G);
+  REQUIRE(height == 20);
+  width = heif_image_get_width(img, heif_channel_B);
+  REQUIRE(width == 30);
+  height = heif_image_get_height(img, heif_channel_B);
+  REQUIRE(height == 20);
+  if (expect_alpha == 1) {
+    width = heif_image_get_width(img, heif_channel_Alpha);
+    REQUIRE(width == 30);
+    height = heif_image_get_height(img, heif_channel_Alpha);
+    REQUIRE(height == 20);
+  }
+
+  int pixel_depth = heif_image_get_bits_per_pixel(img, heif_channel_R);
+  REQUIRE(pixel_depth == 8);
+  pixel_depth = heif_image_get_bits_per_pixel(img, heif_channel_G);
+  REQUIRE(pixel_depth == 8);
+  pixel_depth = heif_image_get_bits_per_pixel(img, heif_channel_B);
+  REQUIRE(pixel_depth == 8);
+
+  int pixel_range = heif_image_get_bits_per_pixel_range(img, heif_channel_R);
+  REQUIRE(pixel_range == 8);
+  pixel_range = heif_image_get_bits_per_pixel_range(img, heif_channel_G);
+  REQUIRE(pixel_range == 8);
+  pixel_range = heif_image_get_bits_per_pixel_range(img, heif_channel_B);
+  REQUIRE(pixel_range == 8);
+
+  heif_image_release(img);
+  heif_image_handle_release(handle);
+}
+
+TEST_CASE("check image size") {
+  auto file = GENERATE(FILES_RGB);
+  auto context = get_context_for_test_file(file);
+  INFO("file name: " << file);
+  int expect_alpha = (strchr(file, 'A') == NULL) ? 0 : 1;
+  check_image_size(context, expect_alpha);
+  heif_context_free(context);
+}
+
+
+void check_image_content(heif_context *&context) {
+  heif_image_handle *handle = get_primary_image_handle(context);
+  heif_image *img = get_primary_image(handle);
+
+  int stride;
+  const uint8_t *img_plane =
+      heif_image_get_plane_readonly(img, heif_channel_R, &stride);
+  REQUIRE(stride == 64);
+  for (int row = 0; row < 4; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 128);
+  }
+  for (int row = 4; row < 8; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 255);
+  }
+  for (int row = 8; row < 12; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 238);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 238);
+  }
+  for (int row = 12; row < 16; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 238);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 238);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 255);
+  }
+  for (int row = 16; row < 20; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 9])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 238);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 238);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 0);
+  }
+  img_plane = heif_image_get_plane_readonly(img, heif_channel_G, &stride);
+  REQUIRE(stride == 64);
+  for (int row = 0; row < 4; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 128);
+  }
+  for (int row = 4; row < 8; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 165);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 165);
+  }
+  for (int row = 8; row < 12; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 165);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 165);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 130);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 130);
+  }
+  for (int row = 12; row < 16; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 165);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 165);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 130);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 130);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 0);
+  }
+  for (int row = 16; row < 20; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 9])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 165);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 165);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 130);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 130);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 128);
+  }
+  img_plane = heif_image_get_plane_readonly(img, heif_channel_B, &stride);
+  REQUIRE(stride == 64);
+  for (int row = 0; row < 4; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 128);
+  }
+  for (int row = 4; row < 8; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 0);
+  }
+  for (int row = 8; row < 12; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 238);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 238);
+  }
+  for (int row = 12; row < 16; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 238);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 238);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 0);
+  }
+  for (int row = 16; row < 20; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 9])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 238);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 238);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 0);
+  }
+
+  heif_image_release(img);
+  heif_image_handle_release(handle);
+}
+
+TEST_CASE("check image content") {
+  auto file = GENERATE(FILES_RGB);
+  auto context = get_context_for_test_file(file);
+  INFO("file name: " << file);
+  check_image_content(context);
+  heif_context_free(context);
+}
diff --git a/tests/uncompressed_decode_rgb16.cc b/tests/uncompressed_decode_rgb16.cc
new file mode 100644
index 0000000000..5d5b8f762e
--- /dev/null
+++ b/tests/uncompressed_decode_rgb16.cc
@@ -0,0 +1,453 @@
+/*
+  libheif integration tests for uncompressed decoder
+
+  MIT License
+
+  Copyright (c) 2023 Brad Hards <bradh@frogmouth.net>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#include "catch_amalgamated.hpp"
+#include "libheif/heif.h"
+#include "api_structs.h"
+#include <cstdint>
+#include <stdio.h>
+#include "test_utils.h"
+#include <string.h>
+
+#include "uncompressed_decode.h"
+
+void check_image_size_rgb16(heif_context *&context, int expect_alpha) {
+  heif_image_handle *handle = get_primary_image_handle(context);
+  heif_image *img = get_primary_image(handle);
+
+  REQUIRE(heif_image_has_channel(img, heif_channel_Y) == 0);
+  REQUIRE(heif_image_has_channel(img, heif_channel_Cb) == 0);
+  REQUIRE(heif_image_has_channel(img, heif_channel_Cr) == 0);
+  REQUIRE(heif_image_has_channel(img, heif_channel_R) == 1);
+  REQUIRE(heif_image_has_channel(img, heif_channel_G) == 1);
+  REQUIRE(heif_image_has_channel(img, heif_channel_B) == 1);
+  REQUIRE(heif_image_has_channel(img, heif_channel_Alpha) == expect_alpha);
+  REQUIRE(heif_image_has_channel(img, heif_channel_interleaved) == 0);
+  int width = heif_image_get_primary_width(img);
+  REQUIRE(width == 30);
+  int height = heif_image_get_primary_height(img);
+  REQUIRE(height == 20);
+  width = heif_image_get_width(img, heif_channel_R);
+  REQUIRE(width == 30);
+  height = heif_image_get_height(img, heif_channel_R);
+  REQUIRE(height == 20);
+  width = heif_image_get_width(img, heif_channel_G);
+  REQUIRE(width == 30);
+  height = heif_image_get_height(img, heif_channel_G);
+  REQUIRE(height == 20);
+  width = heif_image_get_width(img, heif_channel_B);
+  REQUIRE(width == 30);
+  height = heif_image_get_height(img, heif_channel_B);
+  REQUIRE(height == 20);
+  if (expect_alpha == 1) {
+    width = heif_image_get_width(img, heif_channel_Alpha);
+    REQUIRE(width == 30);
+    height = heif_image_get_height(img, heif_channel_Alpha);
+    REQUIRE(height == 20);
+  }
+
+  int pixel_depth = heif_image_get_bits_per_pixel(img, heif_channel_R);
+  REQUIRE(pixel_depth == 16);
+  pixel_depth = heif_image_get_bits_per_pixel(img, heif_channel_G);
+  REQUIRE(pixel_depth == 16);
+  pixel_depth = heif_image_get_bits_per_pixel(img, heif_channel_B);
+  REQUIRE(pixel_depth == 16);
+
+  int pixel_range = heif_image_get_bits_per_pixel_range(img, heif_channel_R);
+  REQUIRE(pixel_range == 16);
+  pixel_range = heif_image_get_bits_per_pixel_range(img, heif_channel_G);
+  REQUIRE(pixel_range == 16);
+  pixel_range = heif_image_get_bits_per_pixel_range(img, heif_channel_B);
+  REQUIRE(pixel_range == 16);
+
+  heif_image_release(img);
+  heif_image_handle_release(handle);
+}
+
+TEST_CASE("check image size 16 bit RGB") {
+  auto file = GENERATE(FILES_16BIT_RGB);
+  auto context = get_context_for_test_file(file);
+  INFO("file name: " << file);
+  int expect_alpha = (strchr(file, 'A') == NULL) ? 0 : 1;
+  check_image_size_rgb16(context, expect_alpha);
+  heif_context_free(context);
+}
+
+void check_image_content_rgb16(heif_context *&context) {
+  heif_image_handle *handle = get_primary_image_handle(context);
+  heif_image *img = get_primary_image(handle);
+
+  int stride;
+  const uint8_t *img_plane =
+      heif_image_get_plane_readonly(img, heif_channel_R, &stride);
+  REQUIRE(stride == 128);
+  for (int row = 0; row < 4; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 31])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 32])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 39])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 40])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 47])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 48])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 55])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 56])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 59])) == 128);
+  }
+  for (int row = 4; row < 8; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 31])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 32])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 39])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 40])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 47])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 48])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 55])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 56])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 59])) == 255);
+  }
+  for (int row = 8; row < 12; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 31])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 32])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 35])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 36])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 39])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 40])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 43])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 44])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 47])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 48])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 51])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 52])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 55])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 56])) == 238);
+    REQUIRE(((int)(img_plane[stride * row + 59])) == 238);
+  }
+  for (int row = 12; row < 16; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 31])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 32])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 39])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 40])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 47])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 48])) == 238);
+    REQUIRE(((int)(img_plane[stride * row + 55])) == 238);
+    REQUIRE(((int)(img_plane[stride * row + 56])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 59])) == 255);
+  }
+  for (int row = 16; row < 20; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 31])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 32])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 39])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 40])) == 238);
+    REQUIRE(((int)(img_plane[stride * row + 47])) == 238);
+    REQUIRE(((int)(img_plane[stride * row + 48])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 55])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 56])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 59])) == 0);
+  }
+  img_plane = heif_image_get_plane_readonly(img, heif_channel_G, &stride);
+  REQUIRE(stride == 128);
+  for (int row = 0; row < 4; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 31])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 32])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 39])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 40])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 47])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 48])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 55])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 56])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 59])) == 128);
+  }
+  for (int row = 4; row < 8; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 31])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 32])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 39])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 40])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 47])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 48])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 55])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 56])) == 165);
+    REQUIRE(((int)(img_plane[stride * row + 59])) == 165);
+  }
+  for (int row = 8; row < 12; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 31])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 32])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 35])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 36])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 39])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 40])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 43])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 44])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 47])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 48])) == 165);
+    REQUIRE(((int)(img_plane[stride * row + 51])) == 165);
+    REQUIRE(((int)(img_plane[stride * row + 52])) == 165);
+    REQUIRE(((int)(img_plane[stride * row + 55])) == 165);
+    REQUIRE(((int)(img_plane[stride * row + 56])) == 130);
+    REQUIRE(((int)(img_plane[stride * row + 59])) == 130);
+  }
+  for (int row = 12; row < 16; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 31])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 32])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 39])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 40])) == 165);
+    REQUIRE(((int)(img_plane[stride * row + 47])) == 165);
+    REQUIRE(((int)(img_plane[stride * row + 48])) == 130);
+    REQUIRE(((int)(img_plane[stride * row + 55])) == 130);
+    REQUIRE(((int)(img_plane[stride * row + 56])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 59])) == 0);
+  }
+  for (int row = 16; row < 20; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 31])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 32])) == 165);
+    REQUIRE(((int)(img_plane[stride * row + 39])) == 165);
+    REQUIRE(((int)(img_plane[stride * row + 40])) == 130);
+    REQUIRE(((int)(img_plane[stride * row + 47])) == 130);
+    REQUIRE(((int)(img_plane[stride * row + 48])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 55])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 56])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 59])) == 128);
+  }
+  img_plane = heif_image_get_plane_readonly(img, heif_channel_B, &stride);
+  REQUIRE(stride == 128);
+  for (int row = 0; row < 4; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 31])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 32])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 39])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 40])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 47])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 48])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 55])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 56])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 59])) == 128);
+  }
+  for (int row = 4; row < 8; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 31])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 32])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 39])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 40])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 47])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 48])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 55])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 56])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 59])) == 0);
+  }
+  for (int row = 8; row < 12; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 31])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 32])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 35])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 36])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 39])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 40])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 43])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 44])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 47])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 48])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 51])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 52])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 55])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 56])) == 238);
+    REQUIRE(((int)(img_plane[stride * row + 59])) == 238);
+  }
+  for (int row = 12; row < 16; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 31])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 32])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 39])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 40])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 47])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 48])) == 238);
+    REQUIRE(((int)(img_plane[stride * row + 55])) == 238);
+    REQUIRE(((int)(img_plane[stride * row + 56])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 59])) == 0);
+  }
+  for (int row = 16; row < 20; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 255);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 31])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 32])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 39])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 40])) == 238);
+    REQUIRE(((int)(img_plane[stride * row + 47])) == 238);
+    REQUIRE(((int)(img_plane[stride * row + 48])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 55])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 56])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 59])) == 0);
+  }
+
+  heif_image_release(img);
+  heif_image_handle_release(handle);
+}
+
+TEST_CASE("check image content 16 bit RGB") {
+  auto file = GENERATE(FILES_16BIT_RGB);
+  auto context = get_context_for_test_file(file);
+  INFO("file name: " << file);
+  check_image_content_rgb16(context);
+  heif_context_free(context);
+}
diff --git a/tests/uncompressed_decode_rgb565.cc b/tests/uncompressed_decode_rgb565.cc
new file mode 100644
index 0000000000..b27ab866db
--- /dev/null
+++ b/tests/uncompressed_decode_rgb565.cc
@@ -0,0 +1,407 @@
+/*
+  libheif integration tests for uncompressed decoder
+
+  MIT License
+
+  Copyright (c) 2023 Brad Hards <bradh@frogmouth.net>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#include "catch_amalgamated.hpp"
+#include "libheif/heif.h"
+#include "api_structs.h"
+#include <cstdint>
+#include <stdio.h>
+#include "test_utils.h"
+#include <string.h>
+
+#include "uncompressed_decode.h"
+
+void check_image_size_rgb565(struct heif_context *&context, int expect_alpha) {
+  heif_image_handle *handle = get_primary_image_handle(context);
+  heif_image *img = get_primary_image(handle);
+
+  REQUIRE(heif_image_has_channel(img, heif_channel_Y) == 0);
+  REQUIRE(heif_image_has_channel(img, heif_channel_Cb) == 0);
+  REQUIRE(heif_image_has_channel(img, heif_channel_Cr) == 0);
+  REQUIRE(heif_image_has_channel(img, heif_channel_R) == 1);
+  REQUIRE(heif_image_has_channel(img, heif_channel_G) == 1);
+  REQUIRE(heif_image_has_channel(img, heif_channel_B) == 1);
+  REQUIRE(heif_image_has_channel(img, heif_channel_Alpha) == expect_alpha);
+  REQUIRE(heif_image_has_channel(img, heif_channel_interleaved) == 0);
+  int width = heif_image_get_primary_width(img);
+  REQUIRE(width == 30);
+  int height = heif_image_get_primary_height(img);
+  REQUIRE(height == 20);
+  width = heif_image_get_width(img, heif_channel_R);
+  REQUIRE(width == 30);
+  height = heif_image_get_height(img, heif_channel_R);
+  REQUIRE(height == 20);
+  width = heif_image_get_width(img, heif_channel_G);
+  REQUIRE(width == 30);
+  height = heif_image_get_height(img, heif_channel_G);
+  REQUIRE(height == 20);
+  width = heif_image_get_width(img, heif_channel_B);
+  REQUIRE(width == 30);
+  height = heif_image_get_height(img, heif_channel_B);
+  REQUIRE(height == 20);
+  if (expect_alpha == 1) {
+    width = heif_image_get_width(img, heif_channel_Alpha);
+    REQUIRE(width == 30);
+    height = heif_image_get_height(img, heif_channel_Alpha);
+    REQUIRE(height == 20);
+  }
+
+  int pixel_depth = heif_image_get_bits_per_pixel(img, heif_channel_R);
+  REQUIRE(pixel_depth == 8);
+  pixel_depth = heif_image_get_bits_per_pixel(img, heif_channel_G);
+  REQUIRE(pixel_depth == 8);
+  pixel_depth = heif_image_get_bits_per_pixel(img, heif_channel_B);
+  REQUIRE(pixel_depth == 8);
+
+  int pixel_range = heif_image_get_bits_per_pixel_range(img, heif_channel_R);
+  REQUIRE(pixel_range == 5);
+  pixel_range = heif_image_get_bits_per_pixel_range(img, heif_channel_G);
+  REQUIRE(pixel_range == 6);
+  pixel_range = heif_image_get_bits_per_pixel_range(img, heif_channel_B);
+  REQUIRE(pixel_range == 5);
+
+  heif_image_release(img);
+  heif_image_handle_release(handle);
+}
+
+TEST_CASE("check image size 5-6-5 bit RGB") {
+  auto file = GENERATE(FILES_565_RGB);
+  auto context = get_context_for_test_file(file);
+  INFO("file name: " << file);
+  int expect_alpha = (strchr(file, 'A') == NULL) ? 0 : 1;
+  check_image_size_rgb565(context, expect_alpha);
+  heif_context_free(context);
+}
+
+void check_image_content_rgb565(struct heif_context *&context) {
+  heif_image_handle *handle = get_primary_image_handle(context);
+  heif_image *img = get_primary_image(handle);
+
+  int stride;
+  const uint8_t *img_plane =
+      heif_image_get_plane_readonly(img, heif_channel_R, &stride);
+  REQUIRE(stride == 64);
+  for (int row = 0; row < 4; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 15);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 15);
+  }
+  for (int row = 4; row < 8; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 15);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 15);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 31);
+  }
+  for (int row = 8; row < 12; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 15);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 15);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 28);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 28);
+  }
+  for (int row = 12; row < 16; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 15);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 15);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 28);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 28);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 31);
+  }
+  for (int row = 16; row < 20; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 15);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 15);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 28);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 28);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 0);
+  }
+  img_plane = heif_image_get_plane_readonly(img, heif_channel_G, &stride);
+  REQUIRE(stride == 64);
+  for (int row = 0; row < 4; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 31);
+  }
+  for (int row = 4; row < 8; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 40);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 40);
+  }
+  for (int row = 8; row < 12; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 40);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 40);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 32);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 32);
+  }
+  for (int row = 12; row < 16; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 40);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 40);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 32);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 32);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 0);
+  }
+  for (int row = 16; row < 20; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 9])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 40);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 40);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 32);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 32);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 31);
+  }
+  img_plane = heif_image_get_plane_readonly(img, heif_channel_B, &stride);
+  REQUIRE(stride == 64);
+  for (int row = 0; row < 4; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 15);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 15);
+  }
+  for (int row = 4; row < 8; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 15);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 15);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 0);
+  }
+  for (int row = 8; row < 12; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 15);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 15);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 28);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 28);
+  }
+  for (int row = 12; row < 16; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 15);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 15);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 28);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 28);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 0);
+  }
+  for (int row = 16; row < 20; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 9])) == 31);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 15);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 15);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 28);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 28);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 0);
+  }
+
+  heif_image_release(img);
+  heif_image_handle_release(handle);
+}
+
+TEST_CASE("check image content 5-6-5 bit RGB") {
+  auto file = GENERATE(FILES_565_RGB);
+  auto context = get_context_for_test_file(file);
+  INFO("file name: " << file);
+  check_image_content_rgb565(context);
+  heif_context_free(context);
+}
diff --git a/tests/uncompressed_decode_rgb7.cc b/tests/uncompressed_decode_rgb7.cc
new file mode 100644
index 0000000000..322c39b1f7
--- /dev/null
+++ b/tests/uncompressed_decode_rgb7.cc
@@ -0,0 +1,407 @@
+/*
+  libheif integration tests for uncompressed decoder
+
+  MIT License
+
+  Copyright (c) 2023 Brad Hards <bradh@frogmouth.net>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#include "catch_amalgamated.hpp"
+#include "libheif/heif.h"
+#include "api_structs.h"
+#include <cstdint>
+#include <stdio.h>
+#include "test_utils.h"
+#include <string.h>
+
+#include "uncompressed_decode.h"
+
+void check_image_size_rgb7(struct heif_context *&context, int expect_alpha) {
+  heif_image_handle *handle = get_primary_image_handle(context);
+  heif_image *img = get_primary_image(handle);
+
+  REQUIRE(heif_image_has_channel(img, heif_channel_Y) == 0);
+  REQUIRE(heif_image_has_channel(img, heif_channel_Cb) == 0);
+  REQUIRE(heif_image_has_channel(img, heif_channel_Cr) == 0);
+  REQUIRE(heif_image_has_channel(img, heif_channel_R) == 1);
+  REQUIRE(heif_image_has_channel(img, heif_channel_G) == 1);
+  REQUIRE(heif_image_has_channel(img, heif_channel_B) == 1);
+  REQUIRE(heif_image_has_channel(img, heif_channel_Alpha) == expect_alpha);
+  REQUIRE(heif_image_has_channel(img, heif_channel_interleaved) == 0);
+  int width = heif_image_get_primary_width(img);
+  REQUIRE(width == 30);
+  int height = heif_image_get_primary_height(img);
+  REQUIRE(height == 20);
+  width = heif_image_get_width(img, heif_channel_R);
+  REQUIRE(width == 30);
+  height = heif_image_get_height(img, heif_channel_R);
+  REQUIRE(height == 20);
+  width = heif_image_get_width(img, heif_channel_G);
+  REQUIRE(width == 30);
+  height = heif_image_get_height(img, heif_channel_G);
+  REQUIRE(height == 20);
+  width = heif_image_get_width(img, heif_channel_B);
+  REQUIRE(width == 30);
+  height = heif_image_get_height(img, heif_channel_B);
+  REQUIRE(height == 20);
+  if (expect_alpha == 1) {
+    width = heif_image_get_width(img, heif_channel_Alpha);
+    REQUIRE(width == 30);
+    height = heif_image_get_height(img, heif_channel_Alpha);
+    REQUIRE(height == 20);
+  }
+
+  int pixel_depth = heif_image_get_bits_per_pixel(img, heif_channel_R);
+  REQUIRE(pixel_depth == 8);
+  pixel_depth = heif_image_get_bits_per_pixel(img, heif_channel_G);
+  REQUIRE(pixel_depth == 8);
+  pixel_depth = heif_image_get_bits_per_pixel(img, heif_channel_B);
+  REQUIRE(pixel_depth == 8);
+
+  int pixel_range = heif_image_get_bits_per_pixel_range(img, heif_channel_R);
+  REQUIRE(pixel_range == 7);
+  pixel_range = heif_image_get_bits_per_pixel_range(img, heif_channel_G);
+  REQUIRE(pixel_range == 7);
+  pixel_range = heif_image_get_bits_per_pixel_range(img, heif_channel_B);
+  REQUIRE(pixel_range == 7);
+
+  heif_image_release(img);
+  heif_image_handle_release(handle);
+}
+
+TEST_CASE("check image size 7 bit RGB") {
+  auto file = GENERATE(FILES_7BIT_RGB);
+  auto context = get_context_for_test_file(file);
+  INFO("file name: " << file);
+  int expect_alpha = (strchr(file, 'A') == NULL) ? 0 : 1;
+  check_image_size_rgb7(context, expect_alpha);
+  heif_context_free(context);
+}
+
+void check_image_content_rgb7(struct heif_context *&context) {
+  heif_image_handle *handle = get_primary_image_handle(context);
+  heif_image *img = get_primary_image(handle);
+
+  int stride;
+  const uint8_t *img_plane =
+      heif_image_get_plane_readonly(img, heif_channel_R, &stride);
+  REQUIRE(stride == 64);
+  for (int row = 0; row < 4; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 63);
+  }
+  for (int row = 4; row < 8; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 127);
+  }
+  for (int row = 8; row < 12; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 118);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 118);
+  }
+  for (int row = 12; row < 16; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 118);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 118);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 127);
+  }
+  for (int row = 16; row < 20; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 118);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 118);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 0);
+  }
+  img_plane = heif_image_get_plane_readonly(img, heif_channel_G, &stride);
+  REQUIRE(stride == 64);
+  for (int row = 0; row < 4; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 63);
+  }
+  for (int row = 4; row < 8; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 82);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 82);
+  }
+  for (int row = 8; row < 12; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 82);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 82);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 64);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 64);
+  }
+  for (int row = 12; row < 16; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 82);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 82);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 64);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 64);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 0);
+  }
+  for (int row = 16; row < 20; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 9])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 82);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 82);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 64);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 64);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 63);
+  }
+  img_plane = heif_image_get_plane_readonly(img, heif_channel_B, &stride);
+  REQUIRE(stride == 64);
+  for (int row = 0; row < 4; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 63);
+  }
+  for (int row = 4; row < 8; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 0);
+  }
+  for (int row = 8; row < 12; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 118);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 118);
+  }
+  for (int row = 12; row < 16; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 118);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 118);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 0);
+  }
+  for (int row = 16; row < 20; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 9])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 63);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 118);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 118);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 0);
+  }
+
+  heif_image_release(img);
+  heif_image_handle_release(handle);
+}
+
+TEST_CASE("check image content 7 bit RGB") {
+  auto file = GENERATE(FILES_7BIT_RGB);
+  auto context = get_context_for_test_file(file);
+  INFO("file name: " << file);
+  check_image_content_rgb7(context);
+  heif_context_free(context);
+}
diff --git a/tests/uncompressed_decode_ycbcr.cc b/tests/uncompressed_decode_ycbcr.cc
new file mode 100644
index 0000000000..196b2f38d8
--- /dev/null
+++ b/tests/uncompressed_decode_ycbcr.cc
@@ -0,0 +1,401 @@
+/*
+  libheif integration tests for uncompressed decoder
+
+  MIT License
+
+  Copyright (c) 2023 Brad Hards <bradh@frogmouth.net>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+#include "catch_amalgamated.hpp"
+#include "libheif/heif.h"
+#include "api_structs.h"
+#include <cstdint>
+#include <stdio.h>
+#include "test_utils.h"
+#include <string.h>
+
+#include "uncompressed_decode.h"
+
+void check_image_size_ycbcr(struct heif_context *&context) {
+  heif_image_handle *handle = get_primary_image_handle(context);
+  heif_image *img = get_primary_image_ycbcr(handle, heif_chroma_444);
+
+  REQUIRE(heif_image_has_channel(img, heif_channel_Y) == 1);
+  REQUIRE(heif_image_has_channel(img, heif_channel_Cb) == 1);
+  REQUIRE(heif_image_has_channel(img, heif_channel_Cr) == 1);
+  REQUIRE(heif_image_has_channel(img, heif_channel_R) == 0);
+  REQUIRE(heif_image_has_channel(img, heif_channel_G) == 0);
+  REQUIRE(heif_image_has_channel(img, heif_channel_B) == 0);
+  REQUIRE(heif_image_has_channel(img, heif_channel_Alpha) == 0);
+  REQUIRE(heif_image_has_channel(img, heif_channel_interleaved) == 0);
+  int width = heif_image_get_primary_width(img);
+  REQUIRE(width == 30);
+  int height = heif_image_get_primary_height(img);
+  REQUIRE(height == 20);
+  width = heif_image_get_width(img, heif_channel_Y);
+  REQUIRE(width == 30);
+  height = heif_image_get_height(img, heif_channel_Y);
+  REQUIRE(height == 20);
+  width = heif_image_get_width(img, heif_channel_Cb);
+  REQUIRE(width == 30);
+  height = heif_image_get_height(img, heif_channel_Cr);
+  REQUIRE(height == 20);
+  width = heif_image_get_width(img, heif_channel_Cr);
+  REQUIRE(width == 30);
+  height = heif_image_get_height(img, heif_channel_Cr);
+  REQUIRE(height == 20);
+
+  int pixel_depth = heif_image_get_bits_per_pixel(img, heif_channel_Y);
+  REQUIRE(pixel_depth == 8);
+  pixel_depth = heif_image_get_bits_per_pixel(img, heif_channel_Cb);
+  REQUIRE(pixel_depth == 8);
+  pixel_depth = heif_image_get_bits_per_pixel(img, heif_channel_Cr);
+  REQUIRE(pixel_depth == 8);
+  int pixel_range = heif_image_get_bits_per_pixel_range(img, heif_channel_Y);
+  REQUIRE(pixel_range == 8);
+  pixel_range = heif_image_get_bits_per_pixel_range(img, heif_channel_Cb);
+  REQUIRE(pixel_range == 8);
+  pixel_range = heif_image_get_bits_per_pixel_range(img, heif_channel_Cr);
+  REQUIRE(pixel_range == 8);
+
+  heif_image_release(img);
+  heif_image_handle_release(handle);
+}
+
+TEST_CASE("check image size YCbCr") {
+  auto file = GENERATE(YUV_FILES);
+  auto context = get_context_for_test_file(file);
+  INFO("file name: " << file);
+  check_image_size_ycbcr(context);
+  heif_context_free(context);
+}
+
+
+void check_image_content_ycbcr(struct heif_context *&context) {
+  heif_image_handle *handle = get_primary_image_handle(context);
+  heif_image *img = get_primary_image_ycbcr(handle, heif_chroma_444);
+
+  int stride;
+  const uint8_t *img_plane =
+      heif_image_get_plane_readonly(img, heif_channel_Y, &stride);
+  REQUIRE(stride == 64);
+  for (int row = 0; row < 4; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 76);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 76);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 75);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 75);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 29);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 29);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 225);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 225);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 178);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 178);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 128);
+  }
+  for (int row = 4; row < 8; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 75);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 75);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 29);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 29);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 225);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 225);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 178);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 178);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 173);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 173);
+  }
+  for (int row = 8; row < 12; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 29);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 29);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 225);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 225);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 178);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 178);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 173);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 173);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 174);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 174);
+  }
+  for (int row = 12; row < 16; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 225);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 225);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 178);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 178);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 173);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 173);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 174);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 174);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 76);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 76);
+  }
+  for (int row = 16; row < 20; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 225);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 225);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 178);
+    REQUIRE(((int)(img_plane[stride * row + 9])) == 178);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 173);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 173);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 174);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 174);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 76);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 76);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 75);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 75);
+  }
+  img_plane = heif_image_get_plane_readonly(img, heif_channel_Cb, &stride);
+  REQUIRE(stride == 64);
+  for (int row = 0; row < 4; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 84);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 84);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 85);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 85);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 170);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 170);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 127);
+  }
+  for (int row = 4; row < 8; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 85);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 85);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 170);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 170);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 29);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 29);
+  }
+  for (int row = 8; row < 12; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 170);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 170);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 29);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 29);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 163);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 163);
+  }
+  for (int row = 12; row < 16; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 170);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 170);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 29);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 29);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 163);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 163);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 84);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 84);
+  }
+  for (int row = 16; row < 20; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 170);
+    REQUIRE(((int)(img_plane[stride * row + 9])) == 170);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 29);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 29);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 163);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 163);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 84);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 84);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 85);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 85);
+  }
+  img_plane = heif_image_get_plane_readonly(img, heif_channel_Cr, &stride);
+  REQUIRE(stride == 64);
+  for (int row = 0; row < 4; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 73);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 73);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 106);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 106);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 148);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 148);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 127);
+  }
+  for (int row = 4; row < 8; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 73);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 73);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 106);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 106);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 148);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 148);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 185);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 185);
+  }
+  for (int row = 8; row < 12; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 106);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 106);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 148);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 148);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 185);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 185);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 172);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 172);
+  }
+  for (int row = 12; row < 16; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 148);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 148);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 185);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 185);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 172);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 172);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 254);
+  }
+  for (int row = 16; row < 20; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 148);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 148);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 9])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 185);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 185);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 172);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 172);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 73);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 73);
+  }
+
+  heif_image_release(img);
+  heif_image_handle_release(handle);
+}
+
+TEST_CASE("check image content YCbCr") {
+  auto file = GENERATE(YUV_FILES);
+  auto context = get_context_for_test_file(file);
+  INFO("file name: " << file);
+  check_image_content_ycbcr(context);
+  heif_context_free(context);
+}
+
+
diff --git a/tests/uncompressed_decode_ycbcr420.cc b/tests/uncompressed_decode_ycbcr420.cc
new file mode 100644
index 0000000000..7e35920091
--- /dev/null
+++ b/tests/uncompressed_decode_ycbcr420.cc
@@ -0,0 +1,690 @@
+/*
+  libheif integration tests for uncompressed decoder
+
+  MIT License
+
+  Copyright (c) 2023 Brad Hards <bradh@frogmouth.net>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+#include "catch_amalgamated.hpp"
+#include "libheif/heif.h"
+#include "api_structs.h"
+#include <cstdint>
+#include <stdio.h>
+#include "test_utils.h"
+#include <string.h>
+
+#include "uncompressed_decode.h"
+
+
+void check_image_size_ycbcr_420(heif_context *&context) {
+  heif_image_handle *handle = get_primary_image_handle(context);
+  heif_image *img = get_primary_image_ycbcr(handle, heif_chroma_420);
+
+  REQUIRE(heif_image_has_channel(img, heif_channel_Y) == 1);
+  REQUIRE(heif_image_has_channel(img, heif_channel_Cb) == 1);
+  REQUIRE(heif_image_has_channel(img, heif_channel_Cr) == 1);
+  REQUIRE(heif_image_has_channel(img, heif_channel_R) == 0);
+  REQUIRE(heif_image_has_channel(img, heif_channel_G) == 0);
+  REQUIRE(heif_image_has_channel(img, heif_channel_B) == 0);
+  REQUIRE(heif_image_has_channel(img, heif_channel_Alpha) == 0);
+  REQUIRE(heif_image_has_channel(img, heif_channel_interleaved) == 0);
+  int width = heif_image_get_primary_width(img);
+  REQUIRE(width == 32);
+  int height = heif_image_get_primary_height(img);
+  REQUIRE(height == 20);
+  width = heif_image_get_width(img, heif_channel_Y);
+  REQUIRE(width == 32);
+  height = heif_image_get_height(img, heif_channel_Y);
+  REQUIRE(height == 20);
+  width = heif_image_get_width(img, heif_channel_Cb);
+  REQUIRE(width == 16);
+  height = heif_image_get_height(img, heif_channel_Cr);
+  REQUIRE(height == 10);
+  width = heif_image_get_width(img, heif_channel_Cr);
+  REQUIRE(width == 16);
+  height = heif_image_get_height(img, heif_channel_Cr);
+  REQUIRE(height == 10);
+
+  int pixel_depth = heif_image_get_bits_per_pixel(img, heif_channel_Y);
+  REQUIRE(pixel_depth == 8);
+  pixel_depth = heif_image_get_bits_per_pixel(img, heif_channel_Cb);
+  REQUIRE(pixel_depth == 8);
+  pixel_depth = heif_image_get_bits_per_pixel(img, heif_channel_Cr);
+  REQUIRE(pixel_depth == 8);
+  int pixel_range = heif_image_get_bits_per_pixel_range(img, heif_channel_Y);
+  REQUIRE(pixel_range == 8);
+  pixel_range = heif_image_get_bits_per_pixel_range(img, heif_channel_Cb);
+  REQUIRE(pixel_range == 8);
+  pixel_range = heif_image_get_bits_per_pixel_range(img, heif_channel_Cr);
+  REQUIRE(pixel_range == 8);
+
+  heif_image_release(img);
+  heif_image_handle_release(handle);
+}
+
+TEST_CASE("check image size YCbCr 4:2:0") {
+  auto file = GENERATE(YUV_420_FILES);
+  auto context = get_context_for_test_file(file);
+  INFO("file name: " << file);
+  check_image_size_ycbcr_420(context);
+  heif_context_free(context);
+}
+
+
+void check_image_size_ycbcr_420_16bit(heif_context *&context) {
+  heif_image_handle *handle = get_primary_image_handle(context);
+  heif_image *img = get_primary_image_ycbcr(handle, heif_chroma_420);
+
+  REQUIRE(heif_image_has_channel(img, heif_channel_Y) == 1);
+  REQUIRE(heif_image_has_channel(img, heif_channel_Cb) == 1);
+  REQUIRE(heif_image_has_channel(img, heif_channel_Cr) == 1);
+  REQUIRE(heif_image_has_channel(img, heif_channel_R) == 0);
+  REQUIRE(heif_image_has_channel(img, heif_channel_G) == 0);
+  REQUIRE(heif_image_has_channel(img, heif_channel_B) == 0);
+  REQUIRE(heif_image_has_channel(img, heif_channel_Alpha) == 0);
+  REQUIRE(heif_image_has_channel(img, heif_channel_interleaved) == 0);
+  int width = heif_image_get_primary_width(img);
+  REQUIRE(width == 32);
+  int height = heif_image_get_primary_height(img);
+  REQUIRE(height == 20);
+  width = heif_image_get_width(img, heif_channel_Y);
+  REQUIRE(width == 32);
+  height = heif_image_get_height(img, heif_channel_Y);
+  REQUIRE(height == 20);
+  width = heif_image_get_width(img, heif_channel_Cb);
+  REQUIRE(width == 16);
+  height = heif_image_get_height(img, heif_channel_Cr);
+  REQUIRE(height == 10);
+  width = heif_image_get_width(img, heif_channel_Cr);
+  REQUIRE(width == 16);
+  height = heif_image_get_height(img, heif_channel_Cr);
+  REQUIRE(height == 10);
+
+  int pixel_depth = heif_image_get_bits_per_pixel(img, heif_channel_Y);
+  REQUIRE(pixel_depth == 16);
+  pixel_depth = heif_image_get_bits_per_pixel(img, heif_channel_Cb);
+  REQUIRE(pixel_depth == 16);
+  pixel_depth = heif_image_get_bits_per_pixel(img, heif_channel_Cr);
+  REQUIRE(pixel_depth == 16);
+  int pixel_range = heif_image_get_bits_per_pixel_range(img, heif_channel_Y);
+  REQUIRE(pixel_range == 16);
+  pixel_range = heif_image_get_bits_per_pixel_range(img, heif_channel_Cb);
+  REQUIRE(pixel_range == 16);
+  pixel_range = heif_image_get_bits_per_pixel_range(img, heif_channel_Cr);
+  REQUIRE(pixel_range == 16);
+
+  heif_image_release(img);
+  heif_image_handle_release(handle);
+}
+
+TEST_CASE("check image size YCbCr 4:2:0 16 bit") {
+  auto file = GENERATE(YUV_16BIT_420_FILES);
+  auto context = get_context_for_test_file(file);
+  INFO("file name: " << file);
+  check_image_size_ycbcr_420_16bit(context);
+  heif_context_free(context);
+}
+
+void check_image_content_ycbcr420(heif_context *&context) {
+  heif_image_handle *handle = get_primary_image_handle(context);
+  heif_image *img = get_primary_image_ycbcr(handle, heif_chroma_420);
+
+  int stride;
+  const uint8_t *img_plane =
+      heif_image_get_plane_readonly(img, heif_channel_Y, &stride);
+  REQUIRE(stride == 64);
+  for (int row = 0; row < 4; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 76);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 76);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 75);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 75);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 29);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 29);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 225);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 225);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 178);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 178);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 128);
+  }
+  for (int row = 4; row < 8; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 75);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 75);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 29);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 29);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 225);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 225);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 178);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 178);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 173);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 173);
+  }
+  for (int row = 8; row < 12; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 29);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 29);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 225);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 225);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 178);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 178);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 173);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 173);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 174);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 174);
+  }
+  for (int row = 12; row < 16; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 225);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 225);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 178);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 178);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 173);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 173);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 174);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 174);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 76);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 76);
+  }
+  for (int row = 16; row < 20; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 225);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 225);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 178);
+    REQUIRE(((int)(img_plane[stride * row + 9])) == 178);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 173);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 173);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 174);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 174);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 76);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 76);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 75);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 75);
+  }
+  img_plane = heif_image_get_plane_readonly(img, heif_channel_Cb, &stride);
+  REQUIRE(stride == 64);
+  for (int row = 0; row < 2; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 84);
+    REQUIRE(((int)(img_plane[stride * row + 1])) == 84);
+    REQUIRE(((int)(img_plane[stride * row + 2])) == 85);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 85);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 5])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 6])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 9])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 10])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 170);
+    REQUIRE(((int)(img_plane[stride * row + 13])) == 170);
+    REQUIRE(((int)(img_plane[stride * row + 14])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 127);
+  }
+  for (int row = 2; row < 4; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 85);
+    REQUIRE(((int)(img_plane[stride * row + 1])) == 85);
+    REQUIRE(((int)(img_plane[stride * row + 2])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 5])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 6])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 9])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 10])) == 170);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 170);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 13])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 14])) == 29);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 29);
+  }
+  for (int row = 4; row < 6; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 1])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 2])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 5])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 6])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 170);
+    REQUIRE(((int)(img_plane[stride * row + 9])) == 170);
+    REQUIRE(((int)(img_plane[stride * row + 10])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 29);
+    REQUIRE(((int)(img_plane[stride * row + 13])) == 29);
+    REQUIRE(((int)(img_plane[stride * row + 14])) == 163);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 163);
+  }
+  for (int row = 6; row < 8; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 1])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 2])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 5])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 6])) == 170);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 170);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 9])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 10])) == 29);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 29);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 163);
+    REQUIRE(((int)(img_plane[stride * row + 13])) == 163);
+    REQUIRE(((int)(img_plane[stride * row + 14])) == 84);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 84);
+  }
+  for (int row = 8; row < 10; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 1])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 2])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 170);
+    REQUIRE(((int)(img_plane[stride * row + 5])) == 170);
+    REQUIRE(((int)(img_plane[stride * row + 6])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 29);
+    REQUIRE(((int)(img_plane[stride * row + 9])) == 29);
+    REQUIRE(((int)(img_plane[stride * row + 10])) == 163);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 163);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 84);
+    REQUIRE(((int)(img_plane[stride * row + 13])) == 84);
+    REQUIRE(((int)(img_plane[stride * row + 14])) == 85);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 85);
+  }
+  img_plane = heif_image_get_plane_readonly(img, heif_channel_Cr, &stride);
+  REQUIRE(stride == 64);
+  for (int row = 0; row < 2; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 1])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 2])) == 73);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 73);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 106);
+    REQUIRE(((int)(img_plane[stride * row + 5])) == 106);
+    REQUIRE(((int)(img_plane[stride * row + 6])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 9])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 10])) == 148);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 148);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 13])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 14])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 127);
+  }
+  for (int row = 2; row < 4; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 73);
+    REQUIRE(((int)(img_plane[stride * row + 1])) == 73);
+    REQUIRE(((int)(img_plane[stride * row + 2])) == 106);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 106);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 5])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 6])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 148);
+    REQUIRE(((int)(img_plane[stride * row + 9])) == 148);
+    REQUIRE(((int)(img_plane[stride * row + 10])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 13])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 14])) == 185);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 185);
+  }
+  for (int row = 4; row < 6; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 106);
+    REQUIRE(((int)(img_plane[stride * row + 1])) == 106);
+    REQUIRE(((int)(img_plane[stride * row + 2])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 5])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 6])) == 148);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 148);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 9])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 10])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 185);
+    REQUIRE(((int)(img_plane[stride * row + 13])) == 185);
+    REQUIRE(((int)(img_plane[stride * row + 14])) == 172);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 172);
+  }
+  for (int row = 6; row < 8; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 1])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 2])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 148);
+    REQUIRE(((int)(img_plane[stride * row + 5])) == 148);
+    REQUIRE(((int)(img_plane[stride * row + 6])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 9])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 10])) == 185);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 185);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 172);
+    REQUIRE(((int)(img_plane[stride * row + 13])) == 172);
+    REQUIRE(((int)(img_plane[stride * row + 14])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 254);
+  }
+  for (int row = 8; row < 10; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 1])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 2])) == 148);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 148);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 5])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 6])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 185);
+    REQUIRE(((int)(img_plane[stride * row + 9])) == 185);
+    REQUIRE(((int)(img_plane[stride * row + 10])) == 172);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 172);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 13])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 14])) == 73);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 73);
+  }
+
+  heif_image_release(img);
+  heif_image_handle_release(handle);
+}
+
+TEST_CASE("check image content YCbCr 4:2:0") {
+  auto file = GENERATE(YUV_420_FILES);
+  auto context = get_context_for_test_file(file);
+  INFO("file name: " << file);
+  check_image_content_ycbcr420(context);
+  heif_context_free(context);
+}
+
+void check_image_content_ycbcr420_16bit(heif_context *&context) {
+  heif_image_handle *handle = get_primary_image_handle(context);
+  heif_image *img = get_primary_image_ycbcr(handle, heif_chroma_420);
+
+  int stride;
+  const uint16_t *img_plane =
+      (const uint16_t*)heif_image_get_plane_readonly(img, heif_channel_Y, &stride);
+  REQUIRE(stride == 128);
+
+  stride /= 2;
+
+  for (int row = 0; row < 4; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0x4C8A);
+    REQUIRE(((int)(img_plane[stride * row + 1])) == 0x4C8A);
+    REQUIRE(((int)(img_plane[stride * row + 2])) == 0x4C8A);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 0x4C8A);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0x4B6D);
+    REQUIRE(((int)(img_plane[stride * row + 5])) == 0x4B6D);
+    REQUIRE(((int)(img_plane[stride * row + 6])) == 0x4B6D);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0x4B6D);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0x1D2E);
+    REQUIRE(((int)(img_plane[stride * row + 9])) == 0x1D2E);
+    REQUIRE(((int)(img_plane[stride * row + 10])) == 0x1D2E);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 0x1D2E);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0xFFFE);
+    REQUIRE(((int)(img_plane[stride * row + 13])) == 0xFFFE);
+    REQUIRE(((int)(img_plane[stride * row + 14])) == 0xFFFE);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 0xFFFE);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 0x0000);
+    REQUIRE(((int)(img_plane[stride * row + 17])) == 0x0000);
+    REQUIRE(((int)(img_plane[stride * row + 18])) == 0x0000);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 0x0000);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 0xE2D0);
+    REQUIRE(((int)(img_plane[stride * row + 21])) == 0xE2D0);
+    REQUIRE(((int)(img_plane[stride * row + 22])) == 0xE2D0);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 0xE2D0);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 0xB374);
+    REQUIRE(((int)(img_plane[stride * row + 25])) == 0xB374);
+    REQUIRE(((int)(img_plane[stride * row + 26])) == 0xB374);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 0xB374);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 0x8080);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 0x8080);
+    REQUIRE(((int)(img_plane[stride * row + 30])) == 0x8080);
+    REQUIRE(((int)(img_plane[stride * row + 31])) == 0x8080);
+  }
+  for (int row = 4; row < 8; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0x4B6D);
+    REQUIRE(((int)(img_plane[stride * row + 2])) == 0x4B6D);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0x1D2E);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0xFFFE);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0x0000);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 0xE2D0);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 0xB374);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 0x8080);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 0xADC6);
+  }
+  for (int row = 8; row < 12; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0x1D2E);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0xFFFE);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0x0000);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0xE2D0);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 0xB374);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 0x8080);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 0xADC6);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 0xAF49);
+  }
+  for (int row = 12; row < 16; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0xFFFE);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0x0000);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0xE2D0);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0xB374);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 0x8080);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 0xADC6);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 0xAF49);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 0x4C8A);
+  }
+  for (int row = 16; row < 20; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0x0000);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0xE2D0);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0xB374);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0x8080);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 0xADC6);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 0xAF49);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 0x4C8A);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 0x4B6D);
+  }
+  img_plane = (const uint16_t*)heif_image_get_plane_readonly(img, heif_channel_Cb, &stride);
+  REQUIRE(stride == 128);
+  stride/=2;
+  for (int row = 0; row < 2; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0x54BC);
+    REQUIRE(((int)(img_plane[stride * row + 1])) == 0x54BC);
+    REQUIRE(((int)(img_plane[stride * row + 2])) == 0x5576);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 0x5576);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0xFFBD);
+    REQUIRE(((int)(img_plane[stride * row + 5])) == 0xFFBD);
+    REQUIRE(((int)(img_plane[stride * row + 6])) == 0x7FBD);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0x7FBD);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0x7FFF);
+    REQUIRE(((int)(img_plane[stride * row + 9])) == 0x7FFF);
+    REQUIRE(((int)(img_plane[stride * row + 10])) == 0x0000);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 0x0000);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0xAB01);
+    REQUIRE(((int)(img_plane[stride * row + 13])) == 0xAB01);
+    REQUIRE(((int)(img_plane[stride * row + 14])) == 0x7FDE);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 0x7FDE);
+  }
+  for (int row = 2; row < 4; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0x5576);
+    REQUIRE(((int)(img_plane[stride * row + 2])) == 0xFFBD);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0x7FBD);
+    REQUIRE(((int)(img_plane[stride * row + 6])) == 0x7FFF);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0x0000);
+    REQUIRE(((int)(img_plane[stride * row + 10])) == 0xAB01);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0x7FDE);
+    REQUIRE(((int)(img_plane[stride * row + 14])) == 0x1DE8);
+  }
+  for (int row = 4; row < 6; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0xFFBD);
+    REQUIRE(((int)(img_plane[stride * row + 2])) == 0x7FBD);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0x7FFF);
+    REQUIRE(((int)(img_plane[stride * row + 6])) == 0x0000);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0xAB01);
+    REQUIRE(((int)(img_plane[stride * row + 10])) == 0x7FDE);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0x1DE8);
+    REQUIRE(((int)(img_plane[stride * row + 14])) == 0xA3A5);
+  }
+  for (int row = 6; row < 8; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0x7FBD);
+    REQUIRE(((int)(img_plane[stride * row + 2])) == 0x7FFF);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0x0000);
+    REQUIRE(((int)(img_plane[stride * row + 6])) == 0xAB01);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0x7FDE);
+    REQUIRE(((int)(img_plane[stride * row + 10])) == 0x1DE8);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0xA3A5);
+    REQUIRE(((int)(img_plane[stride * row + 14])) == 0x54BC);
+  }
+  for (int row = 8; row < 10; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0x7FFF);
+    REQUIRE(((int)(img_plane[stride * row + 2])) == 0x0000);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0xAB01);
+    REQUIRE(((int)(img_plane[stride * row + 6])) == 0x7FDE);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0x1DE8);
+    REQUIRE(((int)(img_plane[stride * row + 10])) == 0xA3A5);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0x54BC);
+    REQUIRE(((int)(img_plane[stride * row + 14])) == 0x5576);
+  }
+  img_plane = (uint16_t*)heif_image_get_plane_readonly(img, heif_channel_Cr, &stride);
+  REQUIRE(stride == 128);
+  stride/=2;
+  for (int row = 0; row < 2; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0xFFBD);
+    REQUIRE(((int)(img_plane[stride * row + 1])) == 0xFFBD);
+    REQUIRE(((int)(img_plane[stride * row + 2])) == 0x4A48);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 0x4A48);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0x6B2F);
+    REQUIRE(((int)(img_plane[stride * row + 5])) == 0x6B2F);
+    REQUIRE(((int)(img_plane[stride * row + 6])) == 0x7FEB);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0x7FEB);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0x7FFF);
+    REQUIRE(((int)(img_plane[stride * row + 9])) == 0x7FFF);
+    REQUIRE(((int)(img_plane[stride * row + 10])) == 0x94BB);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 0x94BB);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0x002D);
+    REQUIRE(((int)(img_plane[stride * row + 13])) == 0x002D);
+    REQUIRE(((int)(img_plane[stride * row + 14])) == 0x7FF5);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 0x7FF5);
+  }
+  for (int row = 2; row < 4; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0x4A48);
+    REQUIRE(((int)(img_plane[stride * row + 2])) == 0x6B2F);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0x7FEB);
+    REQUIRE(((int)(img_plane[stride * row + 6])) == 0x7FFF);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0x94BB);
+    REQUIRE(((int)(img_plane[stride * row + 10])) == 0x002D);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0x7FF5);
+    REQUIRE(((int)(img_plane[stride * row + 14])) == 0xBA80);
+  }
+  for (int row = 4; row < 6; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0x6B2F);
+    REQUIRE(((int)(img_plane[stride * row + 2])) == 0x7FEB);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0x7FFF);
+    REQUIRE(((int)(img_plane[stride * row + 6])) == 0x94BB);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0x002D);
+    REQUIRE(((int)(img_plane[stride * row + 10])) == 0x7FF5);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0xBA80);
+    REQUIRE(((int)(img_plane[stride * row + 14])) == 0xAD3F);
+  }
+  for (int row = 6; row < 8; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0x7FEB);
+    REQUIRE(((int)(img_plane[stride * row + 2])) == 0x7FFF);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0x94BB);
+    REQUIRE(((int)(img_plane[stride * row + 6])) == 0x002D);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0x7FF5);
+    REQUIRE(((int)(img_plane[stride * row + 10])) == 0xBA80);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0xAD3F);
+    REQUIRE(((int)(img_plane[stride * row + 14])) == 0xFFBD);
+  }
+  for (int row = 8; row < 10; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0x7FFF);
+    REQUIRE(((int)(img_plane[stride * row + 2])) == 0x94BB);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0x002D);
+    REQUIRE(((int)(img_plane[stride * row + 6])) == 0x7FF5);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0xBA80);
+    REQUIRE(((int)(img_plane[stride * row + 10])) == 0xAD3F);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0xFFBD);
+    REQUIRE(((int)(img_plane[stride * row + 14])) == 0x4A48);
+  }
+
+  heif_image_release(img);
+  heif_image_handle_release(handle);
+}
+
+TEST_CASE("check image content YCbCr 4:2:0 16 bit") {
+  auto file = GENERATE(YUV_16BIT_420_FILES);
+  auto context = get_context_for_test_file(file);
+  INFO("file name: " << file);
+  check_image_content_ycbcr420_16bit(context);
+  heif_context_free(context);
+}
\ No newline at end of file
diff --git a/tests/uncompressed_decode_ycbcr422.cc b/tests/uncompressed_decode_ycbcr422.cc
new file mode 100644
index 0000000000..55c56c645e
--- /dev/null
+++ b/tests/uncompressed_decode_ycbcr422.cc
@@ -0,0 +1,687 @@
+/*
+  libheif integration tests for uncompressed decoder
+
+  MIT License
+
+  Copyright (c) 2023 Brad Hards <bradh@frogmouth.net>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+#include "catch_amalgamated.hpp"
+#include "libheif/heif.h"
+#include "api_structs.h"
+#include <cstdint>
+#include <stdio.h>
+#include "test_utils.h"
+#include <string.h>
+
+#include "uncompressed_decode.h"
+
+void check_image_size_ycbcr_422(struct heif_context *&context) {
+  heif_image_handle *handle = get_primary_image_handle(context);
+  heif_image *img = get_primary_image_ycbcr(handle, heif_chroma_422);
+
+  REQUIRE(heif_image_has_channel(img, heif_channel_Y) == 1);
+  REQUIRE(heif_image_has_channel(img, heif_channel_Cb) == 1);
+  REQUIRE(heif_image_has_channel(img, heif_channel_Cr) == 1);
+  REQUIRE(heif_image_has_channel(img, heif_channel_R) == 0);
+  REQUIRE(heif_image_has_channel(img, heif_channel_G) == 0);
+  REQUIRE(heif_image_has_channel(img, heif_channel_B) == 0);
+  REQUIRE(heif_image_has_channel(img, heif_channel_Alpha) == 0);
+  REQUIRE(heif_image_has_channel(img, heif_channel_interleaved) == 0);
+  int width = heif_image_get_primary_width(img);
+  REQUIRE(width == 32);
+  int height = heif_image_get_primary_height(img);
+  REQUIRE(height == 20);
+  width = heif_image_get_width(img, heif_channel_Y);
+  REQUIRE(width == 32);
+  height = heif_image_get_height(img, heif_channel_Y);
+  REQUIRE(height == 20);
+  width = heif_image_get_width(img, heif_channel_Cb);
+  REQUIRE(width == 16);
+  height = heif_image_get_height(img, heif_channel_Cr);
+  REQUIRE(height == 20);
+  width = heif_image_get_width(img, heif_channel_Cr);
+  REQUIRE(width == 16);
+  height = heif_image_get_height(img, heif_channel_Cr);
+  REQUIRE(height == 20);
+
+  int pixel_depth = heif_image_get_bits_per_pixel(img, heif_channel_Y);
+  REQUIRE(pixel_depth == 8);
+  pixel_depth = heif_image_get_bits_per_pixel(img, heif_channel_Cb);
+  REQUIRE(pixel_depth == 8);
+  pixel_depth = heif_image_get_bits_per_pixel(img, heif_channel_Cr);
+  REQUIRE(pixel_depth == 8);
+  int pixel_range = heif_image_get_bits_per_pixel_range(img, heif_channel_Y);
+  REQUIRE(pixel_range == 8);
+  pixel_range = heif_image_get_bits_per_pixel_range(img, heif_channel_Cb);
+  REQUIRE(pixel_range == 8);
+  pixel_range = heif_image_get_bits_per_pixel_range(img, heif_channel_Cr);
+  REQUIRE(pixel_range == 8);
+
+  heif_image_release(img);
+  heif_image_handle_release(handle);
+}
+
+TEST_CASE("check image size YCbCr 4:2:2") {
+  auto file = GENERATE(YUV_422_FILES);
+  auto context = get_context_for_test_file(file);
+  INFO("file name: " << file);
+  check_image_size_ycbcr_422(context);
+  heif_context_free(context);
+}
+
+void check_image_size_ycbcr_422_16bit(struct heif_context *&context) {
+  heif_image_handle *handle = get_primary_image_handle(context);
+  heif_image *img = get_primary_image_ycbcr(handle, heif_chroma_422);
+
+  REQUIRE(heif_image_has_channel(img, heif_channel_Y) == 1);
+  REQUIRE(heif_image_has_channel(img, heif_channel_Cb) == 1);
+  REQUIRE(heif_image_has_channel(img, heif_channel_Cr) == 1);
+  REQUIRE(heif_image_has_channel(img, heif_channel_R) == 0);
+  REQUIRE(heif_image_has_channel(img, heif_channel_G) == 0);
+  REQUIRE(heif_image_has_channel(img, heif_channel_B) == 0);
+  REQUIRE(heif_image_has_channel(img, heif_channel_Alpha) == 0);
+  REQUIRE(heif_image_has_channel(img, heif_channel_interleaved) == 0);
+  int width = heif_image_get_primary_width(img);
+  REQUIRE(width == 32);
+  int height = heif_image_get_primary_height(img);
+  REQUIRE(height == 20);
+  width = heif_image_get_width(img, heif_channel_Y);
+  REQUIRE(width == 32);
+  height = heif_image_get_height(img, heif_channel_Y);
+  REQUIRE(height == 20);
+  width = heif_image_get_width(img, heif_channel_Cb);
+  REQUIRE(width == 16);
+  height = heif_image_get_height(img, heif_channel_Cr);
+  REQUIRE(height == 20);
+  width = heif_image_get_width(img, heif_channel_Cr);
+  REQUIRE(width == 16);
+  height = heif_image_get_height(img, heif_channel_Cr);
+  REQUIRE(height == 20);
+
+  int pixel_depth = heif_image_get_bits_per_pixel(img, heif_channel_Y);
+  REQUIRE(pixel_depth == 16);
+  pixel_depth = heif_image_get_bits_per_pixel(img, heif_channel_Cb);
+  REQUIRE(pixel_depth == 16);
+  pixel_depth = heif_image_get_bits_per_pixel(img, heif_channel_Cr);
+  REQUIRE(pixel_depth == 16);
+  int pixel_range = heif_image_get_bits_per_pixel_range(img, heif_channel_Y);
+  REQUIRE(pixel_range == 16);
+  pixel_range = heif_image_get_bits_per_pixel_range(img, heif_channel_Cb);
+  REQUIRE(pixel_range == 16);
+  pixel_range = heif_image_get_bits_per_pixel_range(img, heif_channel_Cr);
+  REQUIRE(pixel_range == 16);
+
+  heif_image_release(img);
+  heif_image_handle_release(handle);
+}
+
+TEST_CASE("check image size YCbCr 4:2:2 16 bit") {
+  auto file = GENERATE(YUV_16BIT_422_FILES);
+  auto context = get_context_for_test_file(file);
+  INFO("file name: " << file);
+  check_image_size_ycbcr_422_16bit(context);
+  heif_context_free(context);
+}
+
+void check_image_content_ycbcr422(struct heif_context *&context) {
+  heif_image_handle *handle = get_primary_image_handle(context);
+  heif_image *img = get_primary_image_ycbcr(handle, heif_chroma_422);
+
+  int stride;
+  const uint8_t *img_plane =
+      heif_image_get_plane_readonly(img, heif_channel_Y, &stride);
+  REQUIRE(stride == 64);
+  for (int row = 0; row < 4; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 76);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 76);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 75);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 75);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 29);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 29);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 225);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 225);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 178);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 178);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 128);
+  }
+  for (int row = 4; row < 8; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 75);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 75);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 29);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 29);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 225);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 225);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 178);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 178);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 173);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 173);
+  }
+  for (int row = 8; row < 12; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 29);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 29);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 225);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 225);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 178);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 178);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 173);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 173);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 174);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 174);
+  }
+  for (int row = 12; row < 16; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 225);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 225);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 178);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 178);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 173);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 173);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 174);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 174);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 76);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 76);
+  }
+  for (int row = 16; row < 20; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 225);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 225);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 178);
+    REQUIRE(((int)(img_plane[stride * row + 9])) == 178);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 128);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 173);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 173);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 174);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 174);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 76);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 76);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 75);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 75);
+  }
+  img_plane = heif_image_get_plane_readonly(img, heif_channel_Cb, &stride);
+  REQUIRE(stride == 64);
+  for (int row = 0; row < 4; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 84);
+    REQUIRE(((int)(img_plane[stride * row + 1])) == 84);
+    REQUIRE(((int)(img_plane[stride * row + 2])) == 85);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 85);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 5])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 6])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 9])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 10])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 170);
+    REQUIRE(((int)(img_plane[stride * row + 13])) == 170);
+    REQUIRE(((int)(img_plane[stride * row + 14])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 127);
+  }
+  for (int row = 4; row < 8; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 85);
+    REQUIRE(((int)(img_plane[stride * row + 1])) == 85);
+    REQUIRE(((int)(img_plane[stride * row + 2])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 5])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 6])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 9])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 10])) == 170);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 170);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 13])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 14])) == 29);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 29);
+  }
+  for (int row = 8; row < 12; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 1])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 2])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 5])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 6])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 170);
+    REQUIRE(((int)(img_plane[stride * row + 9])) == 170);
+    REQUIRE(((int)(img_plane[stride * row + 10])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 29);
+    REQUIRE(((int)(img_plane[stride * row + 13])) == 29);
+    REQUIRE(((int)(img_plane[stride * row + 14])) == 163);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 163);
+  }
+  for (int row = 12; row < 16; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 1])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 2])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 5])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 6])) == 170);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 170);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 9])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 10])) == 29);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 29);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 163);
+    REQUIRE(((int)(img_plane[stride * row + 13])) == 163);
+    REQUIRE(((int)(img_plane[stride * row + 14])) == 84);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 84);
+  }
+  for (int row = 16; row < 20; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 1])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 2])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 170);
+    REQUIRE(((int)(img_plane[stride * row + 5])) == 170);
+    REQUIRE(((int)(img_plane[stride * row + 6])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 29);
+    REQUIRE(((int)(img_plane[stride * row + 9])) == 29);
+    REQUIRE(((int)(img_plane[stride * row + 10])) == 163);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 163);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 84);
+    REQUIRE(((int)(img_plane[stride * row + 13])) == 84);
+    REQUIRE(((int)(img_plane[stride * row + 14])) == 85);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 85);
+  }
+  img_plane = heif_image_get_plane_readonly(img, heif_channel_Cr, &stride);
+  REQUIRE(stride == 64);
+  for (int row = 0; row < 4; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 1])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 2])) == 73);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 73);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 106);
+    REQUIRE(((int)(img_plane[stride * row + 5])) == 106);
+    REQUIRE(((int)(img_plane[stride * row + 6])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 9])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 10])) == 148);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 148);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 13])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 14])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 127);
+  }
+  for (int row = 4; row < 8; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 73);
+    REQUIRE(((int)(img_plane[stride * row + 1])) == 73);
+    REQUIRE(((int)(img_plane[stride * row + 2])) == 106);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 106);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 5])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 6])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 148);
+    REQUIRE(((int)(img_plane[stride * row + 9])) == 148);
+    REQUIRE(((int)(img_plane[stride * row + 10])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 13])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 14])) == 185);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 185);
+  }
+  for (int row = 8; row < 12; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 106);
+    REQUIRE(((int)(img_plane[stride * row + 1])) == 106);
+    REQUIRE(((int)(img_plane[stride * row + 2])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 5])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 6])) == 148);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 148);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 9])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 10])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 185);
+    REQUIRE(((int)(img_plane[stride * row + 13])) == 185);
+    REQUIRE(((int)(img_plane[stride * row + 14])) == 172);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 172);
+  }
+  for (int row = 12; row < 16; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 1])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 2])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 148);
+    REQUIRE(((int)(img_plane[stride * row + 5])) == 148);
+    REQUIRE(((int)(img_plane[stride * row + 6])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 9])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 10])) == 185);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 185);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 172);
+    REQUIRE(((int)(img_plane[stride * row + 13])) == 172);
+    REQUIRE(((int)(img_plane[stride * row + 14])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 254);
+  }
+  for (int row = 16; row < 20; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 1])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 2])) == 148);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 148);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 5])) == 0);
+    REQUIRE(((int)(img_plane[stride * row + 6])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 127);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 185);
+    REQUIRE(((int)(img_plane[stride * row + 9])) == 185);
+    REQUIRE(((int)(img_plane[stride * row + 10])) == 172);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 172);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 13])) == 254);
+    REQUIRE(((int)(img_plane[stride * row + 14])) == 73);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 73);
+  }
+
+  heif_image_release(img);
+  heif_image_handle_release(handle);
+}
+
+TEST_CASE("check image content YCbCr 4:2:2") {
+  auto file = GENERATE(YUV_422_FILES);
+  auto context = get_context_for_test_file(file);
+  INFO("file name: " << file);
+  check_image_content_ycbcr422(context);
+  heif_context_free(context);
+}
+
+
+void check_image_content_ycbcr422_16bit(struct heif_context *&context) {
+  heif_image_handle *handle = get_primary_image_handle(context);
+  heif_image *img = get_primary_image_ycbcr(handle, heif_chroma_422);
+
+  int stride;
+  const uint16_t *img_plane =
+      (const uint16_t*)heif_image_get_plane_readonly(img, heif_channel_Y, &stride);
+  REQUIRE(stride == 128);
+  stride /= 2;
+  for (int row = 0; row < 4; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0x4C8A);
+    REQUIRE(((int)(img_plane[stride * row + 1])) == 0x4C8A);
+    REQUIRE(((int)(img_plane[stride * row + 2])) == 0x4C8A);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 0x4C8A);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0x4B6D);
+    REQUIRE(((int)(img_plane[stride * row + 5])) == 0x4B6D);
+    REQUIRE(((int)(img_plane[stride * row + 6])) == 0x4B6D);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0x4B6D);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0x1D2E);
+    REQUIRE(((int)(img_plane[stride * row + 9])) == 0x1D2E);
+    REQUIRE(((int)(img_plane[stride * row + 10])) == 0x1D2E);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 0x1D2E);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0xFFFE);
+    REQUIRE(((int)(img_plane[stride * row + 13])) == 0xFFFE);
+    REQUIRE(((int)(img_plane[stride * row + 14])) == 0xFFFE);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 0xFFFE);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 0x0000);
+    REQUIRE(((int)(img_plane[stride * row + 17])) == 0x0000);
+    REQUIRE(((int)(img_plane[stride * row + 18])) == 0x0000);
+    REQUIRE(((int)(img_plane[stride * row + 19])) == 0x0000);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 0xE2D0);
+    REQUIRE(((int)(img_plane[stride * row + 21])) == 0xE2D0);
+    REQUIRE(((int)(img_plane[stride * row + 22])) == 0xE2D0);
+    REQUIRE(((int)(img_plane[stride * row + 23])) == 0xE2D0);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 0xB374);
+    REQUIRE(((int)(img_plane[stride * row + 25])) == 0xB374);
+    REQUIRE(((int)(img_plane[stride * row + 26])) == 0xB374);
+    REQUIRE(((int)(img_plane[stride * row + 27])) == 0xB374);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 0x8080);
+    REQUIRE(((int)(img_plane[stride * row + 29])) == 0x8080);
+    REQUIRE(((int)(img_plane[stride * row + 30])) == 0x8080);
+    REQUIRE(((int)(img_plane[stride * row + 31])) == 0x8080);
+  }
+  for (int row = 4; row < 8; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0x4B6D);
+    REQUIRE(((int)(img_plane[stride * row + 2])) == 0x4B6D);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0x1D2E);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0xFFFE);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0x0000);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 0xE2D0);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 0xB374);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 0x8080);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 0xADC6);
+  }
+  for (int row = 8; row < 12; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0x1D2E);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0xFFFE);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0x0000);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0xE2D0);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 0xB374);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 0x8080);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 0xADC6);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 0xAF49);
+  }
+  for (int row = 12; row < 16; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0xFFFE);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0x0000);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0xE2D0);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0xB374);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 0x8080);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 0xADC6);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 0xAF49);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 0x4C8A);
+  }
+  for (int row = 16; row < 20; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0x0000);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0xE2D0);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0xB374);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0x8080);
+    REQUIRE(((int)(img_plane[stride * row + 16])) == 0xADC6);
+    REQUIRE(((int)(img_plane[stride * row + 20])) == 0xAF49);
+    REQUIRE(((int)(img_plane[stride * row + 24])) == 0x4C8A);
+    REQUIRE(((int)(img_plane[stride * row + 28])) == 0x4B6D);
+  }
+  img_plane = (const uint16_t*)heif_image_get_plane_readonly(img, heif_channel_Cb, &stride);
+  REQUIRE(stride == 128);
+  stride /= 2;
+  for (int row = 0; row < 4; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0x54BC);
+    REQUIRE(((int)(img_plane[stride * row + 1])) == 0x54BC);
+    REQUIRE(((int)(img_plane[stride * row + 2])) == 0x5576);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 0x5576);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0xFFBD);
+    REQUIRE(((int)(img_plane[stride * row + 5])) == 0xFFBD);
+    REQUIRE(((int)(img_plane[stride * row + 6])) == 0x7FBD);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0x7FBD);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0x7FFF);
+    REQUIRE(((int)(img_plane[stride * row + 9])) == 0x7FFF);
+    REQUIRE(((int)(img_plane[stride * row + 10])) == 0x0000);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 0x0000);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0xAB01);
+    REQUIRE(((int)(img_plane[stride * row + 13])) == 0xAB01);
+    REQUIRE(((int)(img_plane[stride * row + 14])) == 0x7FDE);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 0x7FDE);
+  }
+  for (int row = 5; row < 8; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0x5576);
+    REQUIRE(((int)(img_plane[stride * row + 2])) == 0xFFBD);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0x7FBD);
+    REQUIRE(((int)(img_plane[stride * row + 6])) == 0x7FFF);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0x0000);
+    REQUIRE(((int)(img_plane[stride * row + 10])) == 0xAB01);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0x7FDE);
+    REQUIRE(((int)(img_plane[stride * row + 14])) == 0x1DE8);
+  }
+  for (int row = 9; row < 12; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0xFFBD);
+    REQUIRE(((int)(img_plane[stride * row + 2])) == 0x7FBD);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0x7FFF);
+    REQUIRE(((int)(img_plane[stride * row + 6])) == 0x0000);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0xAB01);
+    REQUIRE(((int)(img_plane[stride * row + 10])) == 0x7FDE);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0x1DE8);
+    REQUIRE(((int)(img_plane[stride * row + 14])) == 0xA3A5);
+  }
+  for (int row = 12; row < 16; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0x7FBD);
+    REQUIRE(((int)(img_plane[stride * row + 2])) == 0x7FFF);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0x0000);
+    REQUIRE(((int)(img_plane[stride * row + 6])) == 0xAB01);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0x7FDE);
+    REQUIRE(((int)(img_plane[stride * row + 10])) == 0x1DE8);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0xA3A5);
+    REQUIRE(((int)(img_plane[stride * row + 14])) == 0x54BC);
+  }
+  for (int row = 16; row < 20; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0x7FFF);
+    REQUIRE(((int)(img_plane[stride * row + 2])) == 0x0000);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0xAB01);
+    REQUIRE(((int)(img_plane[stride * row + 6])) == 0x7FDE);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0x1DE8);
+    REQUIRE(((int)(img_plane[stride * row + 10])) == 0xA3A5);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0x54BC);
+    REQUIRE(((int)(img_plane[stride * row + 14])) == 0x5576);
+  }
+  img_plane = (const uint16_t*)heif_image_get_plane_readonly(img, heif_channel_Cr, &stride);
+  REQUIRE(stride == 128);
+  stride /= 2;
+  for (int row = 0; row < 4; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0xFFBD);
+    REQUIRE(((int)(img_plane[stride * row + 1])) == 0xFFBD);
+    REQUIRE(((int)(img_plane[stride * row + 2])) == 0x4A48);
+    REQUIRE(((int)(img_plane[stride * row + 3])) == 0x4A48);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0x6B2F);
+    REQUIRE(((int)(img_plane[stride * row + 5])) == 0x6B2F);
+    REQUIRE(((int)(img_plane[stride * row + 6])) == 0x7FEB);
+    REQUIRE(((int)(img_plane[stride * row + 7])) == 0x7FEB);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0x7FFF);
+    REQUIRE(((int)(img_plane[stride * row + 9])) == 0x7FFF);
+    REQUIRE(((int)(img_plane[stride * row + 10])) == 0x94BB);
+    REQUIRE(((int)(img_plane[stride * row + 11])) == 0x94BB);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0x002D);
+    REQUIRE(((int)(img_plane[stride * row + 13])) == 0x002D);
+    REQUIRE(((int)(img_plane[stride * row + 14])) == 0x7FF5);
+    REQUIRE(((int)(img_plane[stride * row + 15])) == 0x7FF5);
+  }
+  for (int row = 4; row < 8; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0x4A48);
+    REQUIRE(((int)(img_plane[stride * row + 2])) == 0x6B2F);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0x7FEB);
+    REQUIRE(((int)(img_plane[stride * row + 6])) == 0x7FFF);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0x94BB);
+    REQUIRE(((int)(img_plane[stride * row + 10])) == 0x002D);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0x7FF5);
+    REQUIRE(((int)(img_plane[stride * row + 14])) == 0xBA80);
+  }
+  for (int row = 8; row < 12; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0x6B2F);
+    REQUIRE(((int)(img_plane[stride * row + 2])) == 0x7FEB);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0x7FFF);
+    REQUIRE(((int)(img_plane[stride * row + 6])) == 0x94BB);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0x002D);
+    REQUIRE(((int)(img_plane[stride * row + 10])) == 0x7FF5);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0xBA80);
+    REQUIRE(((int)(img_plane[stride * row + 14])) == 0xAD3F);
+  }
+  for (int row = 12; row < 16; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0x7FEB);
+    REQUIRE(((int)(img_plane[stride * row + 2])) == 0x7FFF);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0x94BB);
+    REQUIRE(((int)(img_plane[stride * row + 6])) == 0x002D);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0x7FF5);
+    REQUIRE(((int)(img_plane[stride * row + 10])) == 0xBA80);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0xAD3F);
+    REQUIRE(((int)(img_plane[stride * row + 14])) == 0xFFBD);
+  }
+  for (int row = 16; row < 20; row++) {
+    INFO("row: " << row);
+    REQUIRE(((int)(img_plane[stride * row + 0])) == 0x7FFF);
+    REQUIRE(((int)(img_plane[stride * row + 2])) == 0x94BB);
+    REQUIRE(((int)(img_plane[stride * row + 4])) == 0x002D);
+    REQUIRE(((int)(img_plane[stride * row + 6])) == 0x7FF5);
+    REQUIRE(((int)(img_plane[stride * row + 8])) == 0xBA80);
+    REQUIRE(((int)(img_plane[stride * row + 10])) == 0xAD3F);
+    REQUIRE(((int)(img_plane[stride * row + 12])) == 0xFFBD);
+    REQUIRE(((int)(img_plane[stride * row + 14])) == 0x4A48);
+  }
+
+  heif_image_release(img);
+  heif_image_handle_release(handle);
+}
+
+TEST_CASE("check image content YCbCr 4:2:2 16 bit") {
+  auto file = GENERATE(YUV_16BIT_422_FILES);
+  auto context = get_context_for_test_file(file);
+  INFO("file name: " << file);
+  check_image_content_ycbcr422_16bit(context);
+  heif_context_free(context);
+}
diff --git a/tests/uncompressed_encode.cc b/tests/uncompressed_encode.cc
new file mode 100644
index 0000000000..8aaee692ce
--- /dev/null
+++ b/tests/uncompressed_encode.cc
@@ -0,0 +1,778 @@
+/*
+  libheif integration tests for uncompressed encoder
+
+  MIT License
+
+  Copyright (c) 2023 Brad Hards <bradh@frogmouth.net>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#include "catch_amalgamated.hpp"
+#include "api_structs.h"
+#include "libheif/heif.h"
+#include <cstdint>
+#include <string.h>
+#include "test_utils.h"
+
+TEST_CASE("check have uncompressed")
+{
+  heif_error err;
+  heif_context *ctx = heif_context_alloc();
+  heif_encoder *enc;
+  err = heif_context_get_encoder_for_format(ctx, heif_compression_uncompressed,
+                                            &enc);
+  REQUIRE(err.code == heif_error_Ok);
+
+  const char *name = heif_encoder_get_name(enc);
+  REQUIRE(strcmp(name, "builtin") == 0);
+
+  heif_encoder_release(enc);
+
+  heif_context_free(ctx);
+}
+
+
+heif_image *createImage_Mono()
+{
+  heif_image *image;
+  heif_error err;
+  int w = 1024;
+  int h = 768;
+  err = heif_image_create(w, h, heif_colorspace_monochrome,
+                          heif_chroma_monochrome, &image);
+  if (err.code) {
+    return nullptr;
+  }
+
+  err = heif_image_add_plane(image, heif_channel_Y, w, h, 8);
+  REQUIRE(err.code == heif_error_Ok);
+
+  int stride;
+  uint8_t *p = heif_image_get_plane(image, heif_channel_Y, &stride);
+
+  int y = 0;
+  for (; y < h / 2; y++) {
+    int x = 0;
+    for (; x < w / 3; x++) {
+      p[y * stride + x] = 255;
+    }
+    for (; x < 2 * w / 3; x++) {
+      p[y * stride + x] = 127;
+    }
+    for (; x < w; x++) {
+      p[y * stride + x] = 1;
+    }
+  }
+  for (; y < h; y++) {
+    int x = 0;
+    for (; x < w / 3; x++) {
+      p[y * stride + x] =  (uint8_t) (x % 256);
+    }
+    for (; x < 2 * w / 3; x++) {
+      p[y * stride + x] = (uint8_t) ((255 - x) % 256);
+    }
+    for (; x < w; x++) {
+      p[y * stride + x] =  (uint8_t) ((x + y) % 256);
+    }
+  }
+  if (err.code) {
+    heif_image_release(image);
+    return nullptr;
+  }
+
+  return image;
+}
+
+
+heif_image *createImage_YCbCr()
+{
+  heif_image *image;
+  heif_error err;
+  int w = 1024;
+  int h = 768;
+  err = heif_image_create(w, h, heif_colorspace_YCbCr,
+                          heif_chroma_444, &image);
+  if (err.code) {
+    return nullptr;
+  }
+
+  err = heif_image_add_plane(image, heif_channel_Y, w, h, 8);
+  REQUIRE(err.code == heif_error_Ok);
+  err = heif_image_add_plane(image, heif_channel_Cb, w, h, 8);
+  REQUIRE(err.code == heif_error_Ok);
+  err = heif_image_add_plane(image, heif_channel_Cr, w, h, 8);
+  REQUIRE(err.code == heif_error_Ok);
+
+  int stride;
+  uint8_t *p = heif_image_get_plane(image, heif_channel_Y, &stride);
+  uint8_t *cb = heif_image_get_plane(image, heif_channel_Cb, &stride);
+  uint8_t *cr = heif_image_get_plane(image, heif_channel_Cr, &stride);
+
+  int y = 0;
+  for (; y < h / 2; y++)
+  {
+    int x = 0;
+    for (; x < w / 3; x++) {
+      p[y * stride + x] = 255;
+      cb[y * stride + x] = 0;
+      cr[y * stride + x] = 0;
+    }
+    for (; x < 2 * w / 3; x++) {
+      p[y * stride + x] = 127;
+      cb[y * stride + x] = 0;
+      cr[y * stride + x] = 0;
+    }
+    for (; x < w; x++) {
+      p[y * stride + x] = 1;
+      cb[y * stride + x] = 0;
+      cr[y * stride + x] = 0;
+    }
+  }
+  for (; y < h; y++) {
+    int x = 0;
+    for (; x < w / 3; x++) {
+      p[y * stride + x] =  255;
+      cb[y * stride + x] = 255;
+      cr[y * stride + x] = 0;
+    }
+    for (; x < 2 * w / 3; x++) {
+      p[y * stride + x] = 255;
+      cb[y * stride + x] = 255;
+      cr[y * stride + x] = 255;
+    }
+    for (; x < w; x++) {
+      p[y * stride + x] =  255;
+      cb[y * stride + x] = 0;
+      cr[y * stride + x] = 255;
+    }
+  }
+  if (err.code) {
+    heif_image_release(image);
+    return nullptr;
+  }
+
+  return image;
+}
+
+heif_image* createImage_Mono_plus_alpha()
+{
+  heif_image *image;
+  heif_error err;
+  int w = 1024;
+  int h = 768;
+  err = heif_image_create(w, h, heif_colorspace_monochrome,
+                          heif_chroma_monochrome, &image);
+  if (err.code) {
+    return nullptr;
+  }
+
+  err = heif_image_add_plane(image, heif_channel_Y, w, h, 8);
+  REQUIRE(err.code == heif_error_Ok);
+  err = heif_image_add_plane(image, heif_channel_Alpha, w, h, 8);
+  REQUIRE(err.code == heif_error_Ok);
+
+  int stride;
+  uint8_t *p = heif_image_get_plane(image, heif_channel_Y, &stride);
+  uint8_t *a = heif_image_get_plane(image, heif_channel_Alpha, &stride);
+  int y = 0;
+  for (; y < h / 2; y++) {
+    int x = 0;
+    for (; x < w / 3; x++) {
+      p[y * stride + x] = 255;
+      a[y * stride + x] = 250;
+    }
+    for (; x < 2 * w / 3; x++) {
+      p[y * stride + x] = 127;
+      a[y * stride + x] = 25;
+    }
+    for (; x < w; x++) {
+      p[y * stride + x] = 1;
+      a[y * stride + x] = 252;
+    }
+  }
+  for (; y < h; y++) {
+    int x = 0;
+    for (; x < w / 3; x++) {
+      p[y * stride + x] =  (uint8_t) (x % 256);
+      a[y * stride + x] = 253;
+    }
+    for (; x < 2 * w / 3; x++) {
+      p[y * stride + x] = (uint8_t) ((255 - x) % 256);
+      a[y * stride + x] = 254;
+    }
+    for (; x < w; x++) {
+      p[y * stride + x] =  (uint8_t) ((x + y) % 256);
+      a[y * stride + x] = 255;
+    }
+  }
+  if (err.code) {
+    heif_image_release(image);
+    return nullptr;
+  }
+
+  return image;
+}
+
+heif_image *createImage_RGB_interleaved()
+{
+  heif_image *image;
+  heif_error err;
+  int w = 1024;
+  int h = 768;
+  err = heif_image_create(w, h, heif_colorspace_RGB,
+                          heif_chroma_interleaved_RGB, &image);
+  if (err.code) {
+    return nullptr;
+  }
+
+  err = heif_image_add_plane(image, heif_channel_interleaved, w, h, 8);
+  REQUIRE(err.code == heif_error_Ok);
+
+  int stride;
+  uint8_t *p = heif_image_get_plane(image, heif_channel_interleaved, &stride);
+
+  int y = 0;
+  for (; y < h / 2; y++) {
+    int x = 0;
+    for (; x < w / 3; x++) {
+      p[y * stride + 3 * x] = 1;
+      p[y * stride + 3 * x + 1] = 255;
+      p[y * stride + 3 * x + 2] = 2;
+    }
+    for (; x < 2 * w / 3; x++) {
+      p[y * stride + 3 * x] = 4;
+      p[y * stride + 3 * x + 1] = 5;
+      p[y * stride + 3 * x + 2] = 255;
+    }
+    for (; x < w; x++) {
+      p[y * stride + 3 * x] = 255;
+      p[y * stride + 3 * x + 1] = 6;
+      p[y * stride + 3 * x + 2] = 7;
+    }
+  }
+  for (; y < h; y++) {
+    int x = 0;
+    for (; x < w / 3; x++) {
+      p[y * stride + 3 * x] = 8;
+      p[y * stride + 3 * x + 1] = 9;
+      p[y * stride + 3 * x + 2] = 255;
+    }
+    for (; x < 2 * w / 3; x++) {
+      p[y * stride + 3 * x] = 253;
+      p[y * stride + 3 * x + 1] = 10;
+      p[y * stride + 3 * x + 2] = 11;
+    }
+    for (; x < w; x++) {
+      p[y * stride + 3 * x] = 13;
+      p[y * stride + 3 * x + 1] = 252;
+      p[y * stride + 3 * x + 2] = 12;
+    }
+  }
+  if (err.code) {
+    heif_image_release(image);
+    return nullptr;
+  }
+
+  return image;
+}
+
+
+void set_pixel_on_48bpp(uint8_t* p, int y, int stride, int x, int red, int green, int blue, bool little_endian, int alpha)
+{
+  uint8_t red_low_byte = (uint8_t)(red & 0xFF);
+  uint8_t red_high_byte = (uint8_t)(red >> 8);
+  uint8_t green_low_byte = (uint8_t)(green & 0xFF);
+  uint8_t green_high_byte = (uint8_t)(green >> 8);
+  uint8_t blue_low_byte = (uint8_t)(blue & 0xFF);
+  uint8_t blue_high_byte = (uint8_t)(blue >> 8);
+  uint8_t alpha_low_byte = (uint8_t)(alpha & 0xFF);
+  uint8_t alpha_high_byte = (uint8_t)(alpha >> 8);
+  int bytes_per_pixel = 6;
+  if (alpha != 0)
+  {
+    bytes_per_pixel = 8;
+  }
+  if (little_endian)
+  {
+    p[y * stride + x * bytes_per_pixel + 0] = red_low_byte;
+    p[y * stride + x * bytes_per_pixel + 1] = red_high_byte;
+    p[y * stride + x * bytes_per_pixel + 2] = green_low_byte;
+    p[y * stride + x * bytes_per_pixel + 3] = green_high_byte;
+    p[y * stride + x * bytes_per_pixel + 4] = blue_low_byte;
+    p[y * stride + x * bytes_per_pixel + 5] = blue_high_byte;
+    if (alpha != 0)
+    {
+      p[y * stride + x * bytes_per_pixel + 6] = alpha_low_byte;
+      p[y * stride + x * bytes_per_pixel + 7] = alpha_high_byte;
+    }
+  }
+  else
+  {
+    p[y * stride + x * bytes_per_pixel + 0] = red_high_byte;
+    p[y * stride + x * bytes_per_pixel + 1] = red_low_byte;
+    p[y * stride + x * bytes_per_pixel + 2] = green_high_byte;
+    p[y * stride + x * bytes_per_pixel + 3] = green_low_byte;
+    p[y * stride + x * bytes_per_pixel + 4] = blue_high_byte;
+    p[y * stride + x * bytes_per_pixel + 5] = blue_low_byte;
+    if (alpha != 0)
+    {
+      p[y * stride + x * bytes_per_pixel + 6] = alpha_high_byte;
+      p[y * stride + x * bytes_per_pixel + 7] = alpha_low_byte;
+    }
+  }
+}
+
+heif_image *createImage_RRGGBB_interleaved(heif_chroma chroma, int bit_depth, bool little_endian, bool with_alpha)
+{
+  heif_image *image;
+  heif_error err;
+  int w = 1024;
+  int h = 768;
+  err = heif_image_create(w, h, heif_colorspace_RGB, chroma, &image);
+  if (err.code) {
+    return nullptr;
+  }
+
+  int max_value = 0;
+  for (int i = 0; i < bit_depth; i++)
+  {
+    max_value |= (1 << i);
+  }
+  int mid_value = max_value / 2;
+  int alpha = 0;
+  int alpha_mid = 0;
+  if (with_alpha)
+  {
+    alpha = max_value;
+    alpha_mid = mid_value;
+  }
+
+  err = heif_image_add_plane(image, heif_channel_interleaved, w, h, bit_depth);
+  REQUIRE(err.code == heif_error_Ok);
+
+  int stride;
+  uint8_t *p = heif_image_get_plane(image, heif_channel_interleaved, &stride);
+
+  int y = 0;
+  for (; y < h / 2; y++) {
+    int x = 0;
+    for (; x < w / 4; x++)
+    {
+      set_pixel_on_48bpp(p, y, stride, x, 0x0000, 0x0000, max_value, little_endian, alpha);
+    }
+    for (; x < 2 * w / 4; x++)
+    {
+      set_pixel_on_48bpp(p, y, stride, x, 0x0000, max_value, 0x0000, little_endian, alpha);
+    }
+    for (; x < 3 * w / 4; x++)
+    {
+      set_pixel_on_48bpp(p, y, stride, x, max_value, 0x0000, 0x0000, little_endian, alpha);
+    }
+    for (; x < w; x++)
+    {
+      set_pixel_on_48bpp(p, y, stride, x, max_value - 2, max_value - 1, max_value, little_endian, alpha);
+    }
+  }
+  for (; y < h; y++) {
+    int x = 0;
+    for (; x < w / 4; x++)
+    {
+      set_pixel_on_48bpp(p, y, stride, x, 0x0000, max_value, 0x0000, little_endian, alpha_mid);
+    }
+    for (; x < 2 * w / 4; x++)
+    {
+      set_pixel_on_48bpp(p, y, stride, x, max_value, 0x0000, 0x0000, little_endian, alpha_mid);
+    }
+    for (; x < 3 * w / 4; x++)
+    {
+      set_pixel_on_48bpp(p, y, stride, x, 0x0000, 0x0000, max_value, little_endian, alpha_mid);
+    }
+    for (; x < w; x++)
+    {
+      set_pixel_on_48bpp(p, y, stride, x, mid_value - 2, mid_value -1, mid_value, little_endian, alpha_mid);
+    }
+  }
+  if (err.code) {
+    heif_image_release(image);
+    return nullptr;
+  }
+
+  return image;
+}
+
+heif_image *createImage_RGBA_interleaved()
+{
+  heif_image *image;
+  heif_error err;
+  int w = 1024;
+  int h = 768;
+  err = heif_image_create(w, h, heif_colorspace_RGB,
+                          heif_chroma_interleaved_RGBA, &image);
+  if (err.code) {
+    return nullptr;
+  }
+
+  err = heif_image_add_plane(image, heif_channel_interleaved, w, h, 8);
+  REQUIRE(err.code == heif_error_Ok);
+
+  int stride;
+  uint8_t *p = heif_image_get_plane(image, heif_channel_interleaved, &stride);
+
+  int y = 0;
+  for (; y < h / 2; y++) {
+    int x = 0;
+    for (; x < w / 3; x++) {
+      p[y * stride + 4 * x] = 1;
+      p[y * stride + 4 * x + 1] = 255;
+      p[y * stride + 4 * x + 2] = 2;
+      p[y * stride + 4 * x + 3] = 255;
+    }
+    for (; x < 2 * w / 3; x++) {
+      p[y * stride + 4 * x] = 4;
+      p[y * stride + 4 * x + 1] = 5;
+      p[y * stride + 4 * x + 2] = 255;
+      p[y * stride + 4 * x + 3] = 128;
+    }
+    for (; x < w; x++) {
+      p[y * stride + 4 * x] = 255;
+      p[y * stride + 4 * x + 1] = 6;
+      p[y * stride + 4 * x + 2] = 7;
+      p[y * stride + 4 * x + 3] = 200;
+    }
+  }
+  for (; y < h; y++) {
+    int x = 0;
+    for (; x < w / 3; x++) {
+      p[y * stride + 4 * x] = 8;
+      p[y * stride + 4 * x + 1] = 9;
+      p[y * stride + 4 * x + 2] = 255;
+      p[y * stride + 4 * x + 3] = 254;
+    }
+    for (; x < 2 * w / 3; x++) {
+      p[y * stride + 4 * x] = 253;
+      p[y * stride + 4 * x + 1] = 10;
+      p[y * stride + 4 * x + 2] = 11;
+      p[y * stride + 4 * x + 3] = 253;
+    }
+    for (; x < w; x++) {
+      p[y * stride + 4 * x] = 13;
+      p[y * stride + 4 * x + 1] = 252;
+      p[y * stride + 4 * x + 2] = 12;
+      p[y * stride + 4 * x + 3] = 250;
+    }
+  }
+  if (err.code) {
+    heif_image_release(image);
+    return nullptr;
+  }
+
+  return image;
+}
+
+heif_image *createImage_RGBA_planar()
+{
+  heif_image *image;
+  heif_error err;
+  int w = 1024;
+  int h = 768;
+  err = heif_image_create(w, h, heif_colorspace_RGB,
+                          heif_chroma_444, &image);
+  if (err.code) {
+    return nullptr;
+  }
+
+  err = heif_image_add_plane(image, heif_channel_R, w, h, 8);
+  REQUIRE(err.code == heif_error_Ok);
+  err = heif_image_add_plane(image, heif_channel_G, w, h, 8);
+  REQUIRE(err.code == heif_error_Ok);
+  err = heif_image_add_plane(image, heif_channel_B, w, h, 8);
+  REQUIRE(err.code == heif_error_Ok);
+  err = heif_image_add_plane(image, heif_channel_Alpha, w, h, 8);
+  REQUIRE(err.code == heif_error_Ok);
+
+
+  int stride;
+  uint8_t *r = heif_image_get_plane(image, heif_channel_R, &stride);
+  uint8_t *g = heif_image_get_plane(image, heif_channel_G, &stride);
+  uint8_t *b = heif_image_get_plane(image, heif_channel_B, &stride);
+  uint8_t *a = heif_image_get_plane(image, heif_channel_Alpha, &stride);
+
+  int y = 0;
+  for (; y < h / 2; y++) {
+    int x = 0;
+    for (; x < w / 3; x++) {
+      r[y * stride + x] = 1;
+      g[y * stride + x] = 255;
+      b[y * stride + x] = 2;
+      a[y * stride + x] = 240;
+    }
+    for (; x < 2 * w / 3; x++) {
+      r[y * stride + x] = 4;
+      g[y * stride + x] = 5;
+      b[y * stride + x] = 255;
+      a[y * stride + x] = 128;
+    }
+    for (; x < w; x++) {
+      r[y * stride + x] = 255;
+      g[y * stride + x] = 6;
+      b[y * stride + x] = 7;
+      a[y * stride + x] = 241;
+    }
+  }
+  for (; y < h; y++) {
+    int x = 0;
+    for (; x < w / 3; x++) {
+      r[y * stride + x]= 8;
+      g[y * stride + x] = 9;
+      b[y * stride + x] = 255;
+      a[y * stride + x] = 242;
+    }
+    for (; x < 2 * w / 3; x++) {
+      r[y * stride + x] = 253;
+      g[y * stride + x] = 10;
+      b[y * stride + x] = 11;
+      a[y * stride + x] = 243;
+    }
+    for (; x < w; x++) {
+      r[y * stride + x] = 13;
+      g[y * stride + x] = 252;
+      b[y * stride + x] = 12;
+      a[y * stride + x] = 244;
+    }
+  }
+  if (err.code) {
+    heif_image_release(image);
+    return nullptr;
+  }
+
+  return image;
+}
+
+static void do_encode(heif_image* input_image, const char* filename, bool check_decode, uint8_t prefer_uncC_short_form = 0)
+{
+  REQUIRE(input_image != nullptr);
+
+  heif_context *ctx = heif_context_alloc();
+  heif_encoder *encoder;
+  heif_error err;
+  err = heif_context_get_encoder_for_format(ctx, heif_compression_uncompressed, &encoder);
+  REQUIRE(err.code == heif_error_Ok);
+
+  heif_encoding_options *options;
+  options = heif_encoding_options_alloc();
+  options->macOS_compatibility_workaround = false;
+  options->macOS_compatibility_workaround_no_nclx_profile = true;
+  options->image_orientation = heif_orientation_normal;
+  options->prefer_uncC_short_form = prefer_uncC_short_form;
+  heif_image_handle *output_image_handle;
+
+  err = heif_context_encode_image(ctx, input_image, encoder, options, &output_image_handle);
+  REQUIRE(err.code == heif_error_Ok);
+  err = heif_context_write_to_file(ctx, filename);
+  REQUIRE(err.code == heif_error_Ok);
+
+  if (check_decode)
+  {
+    // read file back in
+    heif_context* decode_context;
+    decode_context = heif_context_alloc();
+    err = heif_context_read_from_file(decode_context, filename, NULL);
+    REQUIRE(err.code == heif_error_Ok);
+    heif_image_handle *decode_image_handle = get_primary_image_handle(decode_context);
+    int ispe_width = heif_image_handle_get_ispe_width(decode_image_handle);
+    // TODO: check against input_image ispe width and height if we can
+    REQUIRE(ispe_width == 1024);
+    int ispe_height = heif_image_handle_get_ispe_height(decode_image_handle);
+    REQUIRE(ispe_height == 768);
+    int width = heif_image_handle_get_width(decode_image_handle);
+    REQUIRE(width == heif_image_get_primary_width(input_image));
+    int height = heif_image_handle_get_height(decode_image_handle);
+    REQUIRE(height == heif_image_get_primary_height(input_image));
+    heif_image* decode_image;
+    err = heif_decode_image(decode_image_handle, &decode_image, heif_colorspace_undefined, heif_chroma_undefined, NULL);
+    REQUIRE(err.code == heif_error_Ok);
+    // REQUIRE(heif_image_has_channel(input_image, heif_channel_Y) == heif_image_has_channel(decode_image, heif_channel_Y));
+    REQUIRE(heif_image_has_channel(input_image, heif_channel_Cb) == heif_image_has_channel(decode_image, heif_channel_Cb));
+    REQUIRE(heif_image_has_channel(input_image, heif_channel_Cr) == heif_image_has_channel(decode_image, heif_channel_Cr));
+    // REQUIRE(heif_image_has_channel(input_image, heif_channel_R) == heif_image_has_channel(decode_image, heif_channel_R));
+    // REQUIRE(heif_image_has_channel(input_image, heif_channel_G) == heif_image_has_channel(decode_image, heif_channel_G));
+    // REQUIRE(heif_image_has_channel(input_image, heif_channel_B) == heif_image_has_channel(decode_image, heif_channel_B));
+    // REQUIRE(heif_image_has_channel(input_image, heif_channel_Alpha) == heif_image_has_channel(decode_image, heif_channel_Alpha));
+    // REQUIRE(heif_image_has_channel(input_image, heif_channel_interleaved) == heif_image_has_channel(decode_image, heif_channel_interleaved));
+    // TODO: make proper test for interleave to component translation
+
+    // TODO: compare values
+    heif_image_release(decode_image);
+    heif_image_handle_release(decode_image_handle);
+    heif_context_free(decode_context);
+  }
+
+  heif_image_handle_release(output_image_handle);
+  heif_encoding_options_free(options);
+  heif_encoder_release(encoder);
+  heif_image_release(input_image);
+
+  heif_context_free(ctx);
+}
+
+
+TEST_CASE("Encode RGB")
+{
+  heif_image *input_image = createImage_RGB_interleaved();
+  do_encode(input_image, "encode_rgb.heif", true);
+}
+
+
+TEST_CASE("Encode Mono")
+{
+  heif_image* input_image = createImage_Mono();
+  do_encode(input_image, "encode_mono.heif", true);
+}
+
+TEST_CASE("Encode RGB Version1")
+{
+  heif_image *input_image = createImage_RGB_interleaved();
+  do_encode(input_image, "encode_rgb_version1.heif", true, true);
+}
+
+TEST_CASE("Encode Mono with alpha")
+{
+  heif_image* input_image = createImage_Mono_plus_alpha();
+  do_encode(input_image, "encode_mono_plus_alpha.heif", true);
+}
+
+
+TEST_CASE("Encode YCBCr")
+{
+  // TODO: 422 and 420
+  heif_image *input_image = createImage_YCbCr();
+  do_encode(input_image, "encode_YCbCr.heif", true);
+}
+
+
+TEST_CASE("Encode RRRGGBB_LE 10 bit")
+{
+  heif_image *input_image = createImage_RRGGBB_interleaved(heif_chroma_interleaved_RRGGBB_LE, 10, true, false);
+  do_encode(input_image, "encode_rrggbb_10_le.heif", false);
+}
+
+
+TEST_CASE("Encode RRRGGBB_BE 10 bit ")
+{
+  heif_image *input_image = createImage_RRGGBB_interleaved(heif_chroma_interleaved_RRGGBB_BE, 10, false, false);
+  do_encode(input_image, "encode_rrggbb_10_be.heif", false);
+}
+
+
+TEST_CASE("Encode RRRGGBB_LE 12 bit")
+{
+  heif_image *input_image = createImage_RRGGBB_interleaved(heif_chroma_interleaved_RRGGBB_LE, 12, true, false);
+  do_encode(input_image, "encode_rrggbb_12_le.heif", false);
+}
+
+
+TEST_CASE("Encode RRRGGBB_BE 12 bit ")
+{
+  heif_image *input_image = createImage_RRGGBB_interleaved(heif_chroma_interleaved_RRGGBB_BE, 12, false, false);
+  do_encode(input_image, "encode_rrggbb_12_be.heif", false);
+}
+
+
+TEST_CASE("Encode RRRGGBB_LE 16 bit")
+{
+  heif_image *input_image = createImage_RRGGBB_interleaved(heif_chroma_interleaved_RRGGBB_LE, 16, true, false);
+  do_encode(input_image, "encode_rrggbb_16_le.heif", false);
+}
+
+
+TEST_CASE("Encode RRRGGBB_BE 16 bit ")
+{
+  heif_image *input_image = createImage_RRGGBB_interleaved(heif_chroma_interleaved_RRGGBB_BE, 16, false, false);
+  do_encode(input_image, "encode_rrggbb_16_be.heif", false);
+}
+
+
+TEST_CASE("Encode RGBA")
+{
+  heif_image *input_image = createImage_RGBA_interleaved();
+  do_encode(input_image, "encode_rgba.heif", true);
+}
+
+TEST_CASE("Encode RGBA Version 1")
+{
+  heif_image *input_image = createImage_RGBA_interleaved();
+  do_encode(input_image, "encode_rgba_version1.heif", true, true);
+}
+
+
+TEST_CASE("Encode RRRGGBBAA_LE 10 bit")
+{
+  heif_image *input_image = createImage_RRGGBB_interleaved(heif_chroma_interleaved_RRGGBBAA_LE, 10, true, true);
+  do_encode(input_image, "encode_rrggbbaa_10_le.heif", false);
+}
+
+
+TEST_CASE("Encode RRRGGBBAA_BE 10 bit ")
+{
+  heif_image *input_image = createImage_RRGGBB_interleaved(heif_chroma_interleaved_RRGGBBAA_BE, 10, false, true);
+  do_encode(input_image, "encode_rrggbbaa_10_be.heif", false);
+}
+
+
+TEST_CASE("Encode RRRGGBBAA_LE 12 bit")
+{
+  heif_image *input_image = createImage_RRGGBB_interleaved(heif_chroma_interleaved_RRGGBBAA_LE, 12, true, true);
+  do_encode(input_image, "encode_rrggbbaa_12_le.heif", false);
+}
+
+
+TEST_CASE("Encode RRRGGBBAA_BE 12 bit ")
+{
+  heif_image *input_image = createImage_RRGGBB_interleaved(heif_chroma_interleaved_RRGGBBAA_BE, 12, false, true);
+  do_encode(input_image, "encode_rrggbbaa_12_be.heif", false);
+}
+
+
+TEST_CASE("Encode RRRGGBBAA_LE 16 bit")
+{
+  heif_image *input_image = createImage_RRGGBB_interleaved(heif_chroma_interleaved_RRGGBBAA_LE, 16, true, true);
+  do_encode(input_image, "encode_rrggbbaa_16_le.heif", false);
+}
+
+
+TEST_CASE("Encode RRRGGBBAA_BE 16 bit ")
+{
+  heif_image *input_image = createImage_RRGGBB_interleaved(heif_chroma_interleaved_RRGGBBAA_BE, 16, false, true);
+  do_encode(input_image, "encode_rrggbbaa_16_be.heif", false);
+}
+
+
+TEST_CASE("Encode RGB planar")
+{
+  heif_image *input_image = createImage_RGB_planar();
+  do_encode(input_image, "encode_rgb_planar.heif", true);
+}
+
+
+TEST_CASE("Encode RGBA planar")
+{
+  heif_image *input_image = createImage_RGBA_planar();
+  do_encode(input_image, "encode_rgba_planar.heif", true);
+}
diff --git a/tests/uncompressed_encode_multicomponent.cc b/tests/uncompressed_encode_multicomponent.cc
new file mode 100644
index 0000000000..13df6c1bd1
--- /dev/null
+++ b/tests/uncompressed_encode_multicomponent.cc
@@ -0,0 +1,434 @@
+/*
+  libheif integration tests for uncompressed multi-component images
+
+  MIT License
+
+  Copyright (c) 2026 Dirk Farin <dirk.farin@gmail.com>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#include "catch_amalgamated.hpp"
+#include "libheif/heif.h"
+#include "libheif/heif_uncompressed.h"
+#include "test_utils.h"
+#include <cstdint>
+#include <cstring>
+#include <cmath>
+#include <string>
+
+static constexpr int kWidth = 8;
+static constexpr int kHeight = 8;
+static constexpr int kNumComponents = 4;
+static constexpr uint16_t kMonoComponentType = 0;
+
+
+template <typename T>
+static T compute_fill_value(uint32_t comp, uint32_t y, uint32_t x)
+{
+  assert(false && "compute_fill_value not specialized for this type");
+  return T{};
+}
+
+template <>
+float compute_fill_value<float>(uint32_t comp, uint32_t y, uint32_t x)
+{
+  return static_cast<float>(comp * 37 + y * kWidth + x + 1) * 0.1f;
+}
+
+template <>
+double compute_fill_value<double>(uint32_t comp, uint32_t y, uint32_t x)
+{
+  return static_cast<double>(comp * 37 + y * kWidth + x + 1) * 0.1;
+}
+
+template <>
+heif_complex32 compute_fill_value<heif_complex32>(uint32_t comp, uint32_t y, uint32_t x)
+{
+  float base = static_cast<float>(comp * 37 + y * kWidth + x + 1);
+  return {base * 0.1f, base * 0.2f};
+}
+
+template <>
+heif_complex64 compute_fill_value<heif_complex64>(uint32_t comp, uint32_t y, uint32_t x)
+{
+  double base = static_cast<double>(comp * 37 + y * kWidth + x + 1);
+  return {base * 0.1, base * 0.2};
+}
+
+template <>
+int8_t compute_fill_value<int8_t>(uint32_t comp, uint32_t y, uint32_t x)
+{
+  return static_cast<int8_t>(((comp * 37 + y * kWidth + x + 1) % 256) - 128);
+}
+
+template <>
+int16_t compute_fill_value<int16_t>(uint32_t comp, uint32_t y, uint32_t x)
+{
+  return static_cast<int16_t>(comp * 37 + y * kWidth + x + 1);
+}
+
+template <>
+int32_t compute_fill_value<int32_t>(uint32_t comp, uint32_t y, uint32_t x)
+{
+  return static_cast<int32_t>(comp * 37 + y * kWidth + x + 1);
+}
+
+template <>
+uint8_t compute_fill_value<uint8_t>(uint32_t comp, uint32_t y, uint32_t x)
+{
+  return static_cast<uint8_t>((comp * 37 + y * kWidth + x + 1) & 0xFF);
+}
+
+template <>
+uint16_t compute_fill_value<uint16_t>(uint32_t comp, uint32_t y, uint32_t x)
+{
+  return static_cast<uint16_t>(comp * 37 + y * kWidth + x + 1);
+}
+
+template <>
+uint32_t compute_fill_value<uint32_t>(uint32_t comp, uint32_t y, uint32_t x)
+{
+  return comp * 37 + y * kWidth + x + 1;
+}
+
+
+// Typed accessor helpers: get mutable pointer for filling
+template <typename T>
+T* get_component_ptr(heif_image* image, uint32_t idx, size_t* out_stride);
+
+template <>
+uint8_t* get_component_ptr<uint8_t>(heif_image* image, uint32_t idx, size_t* out_stride)
+{
+  return heif_image_get_component(image, idx, out_stride);
+}
+
+template <>
+uint16_t* get_component_ptr<uint16_t>(heif_image* image, uint32_t idx, size_t* out_stride)
+{
+  return heif_image_get_component_uint16(image, idx, out_stride);
+}
+
+template <>
+uint32_t* get_component_ptr<uint32_t>(heif_image* image, uint32_t idx, size_t* out_stride)
+{
+  return heif_image_get_component_uint32(image, idx, out_stride);
+}
+
+template <>
+int16_t* get_component_ptr<int16_t>(heif_image* image, uint32_t idx, size_t* out_stride)
+{
+  return heif_image_get_component_int16(image, idx, out_stride);
+}
+
+template <>
+int32_t* get_component_ptr<int32_t>(heif_image* image, uint32_t idx, size_t* out_stride)
+{
+  return heif_image_get_component_int32(image, idx, out_stride);
+}
+
+template <>
+float* get_component_ptr<float>(heif_image* image, uint32_t idx, size_t* out_stride)
+{
+  return heif_image_get_component_float32(image, idx, out_stride);
+}
+
+template <>
+double* get_component_ptr<double>(heif_image* image, uint32_t idx, size_t* out_stride)
+{
+  return heif_image_get_component_float64(image, idx, out_stride);
+}
+
+template <>
+heif_complex32* get_component_ptr<heif_complex32>(heif_image* image, uint32_t idx, size_t* out_stride)
+{
+  return heif_image_get_component_complex32(image, idx, out_stride);
+}
+
+template <>
+heif_complex64* get_component_ptr<heif_complex64>(heif_image* image, uint32_t idx, size_t* out_stride)
+{
+  return heif_image_get_component_complex64(image, idx, out_stride);
+}
+
+
+// Typed accessor helpers: get const pointer for reading
+template <typename T>
+const T* get_component_ptr_readonly(const heif_image* image, uint32_t idx, size_t* out_stride);
+
+template <>
+const uint8_t* get_component_ptr_readonly<uint8_t>(const heif_image* image, uint32_t idx, size_t* out_stride)
+{
+  return heif_image_get_component_readonly(image, idx, out_stride);
+}
+
+template <>
+const uint16_t* get_component_ptr_readonly<uint16_t>(const heif_image* image, uint32_t idx, size_t* out_stride)
+{
+  return heif_image_get_component_uint16_readonly(image, idx, out_stride);
+}
+
+template <>
+const uint32_t* get_component_ptr_readonly<uint32_t>(const heif_image* image, uint32_t idx, size_t* out_stride)
+{
+  return heif_image_get_component_uint32_readonly(image, idx, out_stride);
+}
+
+template <>
+const int16_t* get_component_ptr_readonly<int16_t>(const heif_image* image, uint32_t idx, size_t* out_stride)
+{
+  return heif_image_get_component_int16_readonly(image, idx, out_stride);
+}
+
+template <>
+const int32_t* get_component_ptr_readonly<int32_t>(const heif_image* image, uint32_t idx, size_t* out_stride)
+{
+  return heif_image_get_component_int32_readonly(image, idx, out_stride);
+}
+
+template <>
+const float* get_component_ptr_readonly<float>(const heif_image* image, uint32_t idx, size_t* out_stride)
+{
+  return heif_image_get_component_float32_readonly(image, idx, out_stride);
+}
+
+template <>
+const double* get_component_ptr_readonly<double>(const heif_image* image, uint32_t idx, size_t* out_stride)
+{
+  return heif_image_get_component_float64_readonly(image, idx, out_stride);
+}
+
+template <>
+const heif_complex32* get_component_ptr_readonly<heif_complex32>(const heif_image* image, uint32_t idx, size_t* out_stride)
+{
+  return heif_image_get_component_complex32_readonly(image, idx, out_stride);
+}
+
+template <>
+const heif_complex64* get_component_ptr_readonly<heif_complex64>(const heif_image* image, uint32_t idx, size_t* out_stride)
+{
+  return heif_image_get_component_complex64_readonly(image, idx, out_stride);
+}
+
+
+template <>
+int8_t* get_component_ptr<int8_t>(heif_image* image, uint32_t idx, size_t* out_stride)
+{
+  return heif_image_get_component_int8(image, idx, out_stride);
+}
+
+template <>
+const int8_t* get_component_ptr_readonly<int8_t>(const heif_image* image, uint32_t idx, size_t* out_stride)
+{
+  return heif_image_get_component_int8_readonly(image, idx, out_stride);
+}
+
+
+template <typename T>
+static heif_image* create_and_fill_image(heif_channel_datatype datatype, int bit_depth)
+{
+  heif_image* image = nullptr;
+  heif_error err;
+
+  err = heif_image_create(kWidth, kHeight, heif_colorspace_nonvisual,
+                          heif_chroma_undefined, &image);
+  REQUIRE(err.code == heif_error_Ok);
+  REQUIRE(image != nullptr);
+
+  for (uint32_t c = 0; c < kNumComponents; c++) {
+    uint32_t idx = 0;
+    err = heif_image_add_component(image, kWidth, kHeight,
+                                   kMonoComponentType, datatype, bit_depth, &idx);
+    REQUIRE(err.code == heif_error_Ok);
+    REQUIRE(idx == c);
+
+    size_t stride = 0;
+    T* data = get_component_ptr<T>(image, idx, &stride);
+    REQUIRE(data != nullptr);
+    REQUIRE(stride >= kWidth);
+
+    for (uint32_t y = 0; y < kHeight; y++) {
+      for (uint32_t x = 0; x < kWidth; x++) {
+        data[y * stride + x] = compute_fill_value<T>(c, y, x);
+      }
+    }
+  }
+
+  return image;
+}
+
+
+template <typename T>
+static bool values_equal(T a, T b)
+{
+  return a == b;
+}
+
+template <>
+bool values_equal<float>(float a, float b)
+{
+  return std::abs(a - b) < 1e-5f;
+}
+
+template <>
+bool values_equal<double>(double a, double b)
+{
+  return std::abs(a - b) < 1e-10;
+}
+
+template <>
+bool values_equal<heif_complex32>(heif_complex32 a, heif_complex32 b)
+{
+  return std::abs(a.real - b.real) < 1e-5f && std::abs(a.imaginary - b.imaginary) < 1e-5f;
+}
+
+template <>
+bool values_equal<heif_complex64>(heif_complex64 a, heif_complex64 b)
+{
+  return std::abs(a.real - b.real) < 1e-10 && std::abs(a.imaginary - b.imaginary) < 1e-10;
+}
+
+
+template <typename T>
+static void verify_image_data(const heif_image* image)
+{
+  uint32_t num_components = heif_image_get_number_of_used_components(image);
+  REQUIRE(num_components == kNumComponents);
+
+  for (uint32_t c = 0; c < kNumComponents; c++) {
+    REQUIRE(heif_image_get_component_width(image, c) == kWidth);
+    REQUIRE(heif_image_get_component_height(image, c) == kHeight);
+    REQUIRE(heif_image_get_component_type(image, c) == kMonoComponentType);
+
+    size_t stride = 0;
+    const T* data = get_component_ptr_readonly<T>(image, c, &stride);
+    REQUIRE(data != nullptr);
+
+    for (uint32_t y = 0; y < kHeight; y++) {
+      for (uint32_t x = 0; x < kWidth; x++) {
+        T expected = compute_fill_value<T>(c, y, x);
+        T actual = data[y * stride + x];
+        REQUIRE(values_equal(expected, actual));
+      }
+    }
+  }
+}
+
+
+template <typename T>
+static void test_multi_mono(heif_channel_datatype datatype, int bit_depth, const char* output_filename)
+{
+  heif_image* image = create_and_fill_image<T>(datatype, bit_depth);
+
+  // Verify that data was written correctly before encode
+  verify_image_data<T>(image);
+
+  // Encode
+  heif_context* ctx = heif_context_alloc();
+  heif_encoder* encoder = nullptr;
+  heif_error err = heif_context_get_encoder_for_format(ctx, heif_compression_uncompressed, &encoder);
+  REQUIRE(err.code == heif_error_Ok);
+
+  err = heif_context_encode_image(ctx, image, encoder, nullptr, nullptr);
+  REQUIRE(err.code == heif_error_Ok);
+
+  // Write to file
+  std::string output_path = get_tests_output_file_path(output_filename);
+  err = heif_context_write_to_file(ctx, output_path.c_str());
+  REQUIRE(err.code == heif_error_Ok);
+
+  heif_encoder_release(encoder);
+  heif_image_release(image);
+  heif_context_free(ctx);
+
+  // Read back
+  heif_context* ctx2 = heif_context_alloc();
+  err = heif_context_read_from_file(ctx2, output_path.c_str(), nullptr);
+  REQUIRE(err.code == heif_error_Ok);
+
+  heif_image_handle* handle = nullptr;
+  err = heif_context_get_primary_image_handle(ctx2, &handle);
+  REQUIRE(err.code == heif_error_Ok);
+
+  heif_image* decoded = nullptr;
+  err = heif_decode_image(handle, &decoded, heif_colorspace_undefined, heif_chroma_undefined, nullptr);
+  REQUIRE(err.code == heif_error_Ok);
+
+  verify_image_data<T>(decoded);
+
+  heif_image_release(decoded);
+  heif_image_handle_release(handle);
+  heif_context_free(ctx2);
+}
+
+
+TEST_CASE("Multi-mono uint8")
+{
+  test_multi_mono<uint8_t>(heif_channel_datatype_unsigned_integer, 8, "multi_mono_uint8.heif");
+}
+
+TEST_CASE("Multi-mono uint16")
+{
+  test_multi_mono<uint16_t>(heif_channel_datatype_unsigned_integer, 16, "multi_mono_uint16.heif");
+}
+
+TEST_CASE("Multi-mono uint12")
+{
+  test_multi_mono<uint16_t>(heif_channel_datatype_unsigned_integer, 12, "multi_mono_uint12.heif");
+}
+
+TEST_CASE("Multi-mono uint32")
+{
+  test_multi_mono<uint32_t>(heif_channel_datatype_unsigned_integer, 32, "multi_mono_uint32.heif");
+}
+
+TEST_CASE("Multi-mono int8")
+{
+  test_multi_mono<int8_t>(heif_channel_datatype_signed_integer, 8, "multi_mono_int8.heif");
+}
+
+TEST_CASE("Multi-mono int16")
+{
+  test_multi_mono<int16_t>(heif_channel_datatype_signed_integer, 16, "multi_mono_int16.heif");
+}
+
+TEST_CASE("Multi-mono int32")
+{
+  test_multi_mono<int32_t>(heif_channel_datatype_signed_integer, 32, "multi_mono_int32.heif");
+}
+
+TEST_CASE("Multi-mono float32")
+{
+  test_multi_mono<float>(heif_channel_datatype_floating_point, 32, "multi_mono_float32.heif");
+}
+
+TEST_CASE("Multi-mono float64")
+{
+  test_multi_mono<double>(heif_channel_datatype_floating_point, 64, "multi_mono_float64.heif");
+}
+
+TEST_CASE("Multi-mono complex32")
+{
+  test_multi_mono<heif_complex32>(heif_channel_datatype_complex_number, 64, "multi_mono_complex32.heif");
+}
+
+TEST_CASE("Multi-mono complex64")
+{
+  test_multi_mono<heif_complex64>(heif_channel_datatype_complex_number, 128, "multi_mono_complex64.heif");
+}
diff --git a/third-party/aom.cmd b/third-party/aom.cmd
new file mode 100644
index 0000000000..c4c76120ef
--- /dev/null
+++ b/third-party/aom.cmd
@@ -0,0 +1,25 @@
+: # This install script was originally taken from libavif but might have been modified.
+
+: # If you want to enable the AOM encoder, please check that the WITH_AOM CMake variable is set correctly.
+: # You will also have to set the PKG_CONFIG_PATH to "third-party/aom/dist/lib/pkgconfig" so that the local AOM library is found.
+
+: # The odd choice of comment style in this file is to try to share this script between *nix and win32.
+
+: # cmake and ninja must be in your PATH.
+
+: # If you're running this on Windows, be sure you've already run this (from your VC2019 install dir):
+: #     "C:\Program Files (x86)\Microsoft Visual Studio\2019\Professional\VC\Auxiliary\Build\vcvars64.bat"
+
+git clone -b v3.13.1 --depth 1 https://aomedia.googlesource.com/aom
+
+cd aom
+
+cmake -S . -B build.libavif -G Ninja -DCMAKE_INSTALL_PREFIX="$(pwd)/dist" -DCMAKE_BUILD_TYPE=Release -DENABLE_DOCS=0 -DENABLE_EXAMPLES=0 -DENABLE_TESTDATA=0 -DENABLE_TESTS=0 -DENABLE_TOOLS=0
+ninja -C build.libavif
+ninja -C build.libavif install
+cd ..
+
+echo ""
+echo "----- NOTE ----"
+echo "Please add the path to the pkg-config file to your PKG_CONFIG_PATH, like this:"
+echo "export PKG_CONFIG_PATH=\$PKG_CONFIG_PATH:$(pwd)/aom/dist/lib/pkgconfig"
diff --git a/third-party/dav1d.cmd b/third-party/dav1d.cmd
index 7895968305..3bb5be6fc4 100644
--- a/third-party/dav1d.cmd
+++ b/third-party/dav1d.cmd
@@ -1,7 +1,7 @@
 : # This install script was originally taken from libavif but might have been modified.
 
-: # If you want to use a local build of dav1d, you must clone the dav1d repo in this directory first, then enable CMake's AVIF_CODEC_DAV1D and AVIF_LOCAL_DAV1D options.
-: # The git SHA below is known to work, and will occasionally be updated. Feel free to use a more recent commit.
+: # If you want to enable the DAV1D decoder, please check that the WITH_DAV1D CMake variable is set correctly.
+: # You will also have to set the PKG_CONFIG_PATH to "third-party/dav1d/dist/lib/x86_64-linux-gnu/pkgconfig" so that the local DAV1D library is found.
 
 : # The odd choice of comment style in this file is to try to share this script between *nix and win32.
 
@@ -10,7 +10,7 @@
 : # If you're running this on Windows, be sure you've already run this (from your VC2019 install dir):
 : #     "C:\Program Files (x86)\Microsoft Visual Studio\2019\Professional\VC\Auxiliary\Build\vcvars64.bat"
 
-git clone -b 0.8.2 --depth 1 https://code.videolan.org/videolan/dav1d.git
+git clone -b 1.5.3 --depth 1 https://code.videolan.org/videolan/dav1d.git
 
 cd dav1d
 
@@ -21,3 +21,9 @@ meson build --default-library=static --buildtype release --prefix "$(pwd)/dist"
 ninja -C build
 ninja -C build install
 cd ..
+
+echo ""
+echo "----- NOTE ----"
+echo "Please add the path to the pkg-config file to your PKG_CONFIG_PATH. For"
+echo "example, on Linux x86_64, run:"
+echo "export PKG_CONFIG_PATH=\$PKG_CONFIG_PATH:$(pwd)/dav1d/dist/lib/x86_64-linux-gnu/pkgconfig"
diff --git a/third-party/libsharpyuv.cmd b/third-party/libsharpyuv.cmd
new file mode 100644
index 0000000000..e5e28d21ff
--- /dev/null
+++ b/third-party/libsharpyuv.cmd
@@ -0,0 +1,20 @@
+: # This install script was originally taken from libavif but might have been modified.
+
+: # If you want to enable the libsharpyuv decoder, please check that the WITH_LIBSHARPYUV CMake variable is set correctly.
+: # You will also have to set the PKG_CONFIG_PATH to "third-party/libwebp/build/dist/lib/pkgconfig" so that the local libsharpyuv library is found.
+
+: # The odd choice of comment style in this file is to try to share this script between *nix and win32.
+
+: # meson and ninja must be in your PATH.
+
+: # If you're running this on Windows, be sure you've already run this (from your VC2019 install dir):
+: #     "C:\Program Files (x86)\Microsoft Visual Studio\2019\Professional\VC\Auxiliary\Build\vcvars64.bat"
+git clone --single-branch https://chromium.googlesource.com/webm/libwebp
+
+cd libwebp
+mkdir build
+cd build
+cmake -G Ninja -DCMAKE_INSTALL_PREFIX="$(pwd)/dist" -DBUILD_SHARED_LIBS=OFF -DCMAKE_BUILD_TYPE=Release ..
+ninja sharpyuv
+ninja install
+cd ../..
diff --git a/third-party/rav1e.cmd b/third-party/rav1e.cmd
index 18fe3110d2..d722510365 100644
--- a/third-party/rav1e.cmd
+++ b/third-party/rav1e.cmd
@@ -1,5 +1,8 @@
 : # This install script was originally taken from libavif but might have been modified.
 
+: # If you want to enable the RAV1E encoder, please check that the WITH_RAV1E CMake variable is set correctly.
+: # You will also have to set the PKG_CONFIG_PATH to "third-party/rav1e/dist/lib/x86_64-linux-gnu/pkgconfig" (depending on your architecture) so that the local RAV1E library is found.
+
 : # The odd choice of comment style in this file is to try to share this script between *nix and win32.
 
 : # cargo must be in your PATH. (use rustup or brew to install)
@@ -10,7 +13,7 @@
 : # Also, the error that "The target windows-msvc is not supported yet" can safely be ignored provided that rav1e/target/release
 : # contains rav1e.h and rav1e.lib.
 
-git clone -b 0.4 --depth 1 https://github.com/xiph/rav1e.git
+git clone -b v0.7.1 --depth 1 https://github.com/xiph/rav1e.git
 
 cd rav1e
 cargo install cargo-c
diff --git a/third-party/svt.cmd b/third-party/svt.cmd
new file mode 100644
index 0000000000..a8702a711b
--- /dev/null
+++ b/third-party/svt.cmd
@@ -0,0 +1,19 @@
+: # This install script was originally taken from libavif but might have been modified.
+
+: # cmake and ninja must be in your PATH for compiling.
+
+: # If you want to enable the SVT-AV1 encoder, please check that the WITH_SvtEnc and WITH_SvtEnc_PLUGIN CMake variables have correct values.
+: # You will also have to set the PKG_CONFIG_PATH to "third-party/SVT-AV1/Build/linux/Release" so that the local SVT-AV1 library is found.
+
+git clone -b v3.0.1 --depth 1 https://gitlab.com/AOMediaCodec/SVT-AV1.git
+
+cd SVT-AV1
+cd Build/linux
+
+./build.sh release static no-apps disable-lto prefix=$(pwd)/install install
+cd ../../..
+
+echo ""
+echo "----- NOTE ----"
+echo "Please add the path to the pkg-config file to your PKG_CONFIG_PATH, like this:"
+echo "export PKG_CONFIG_PATH=\$PKG_CONFIG_PATH:$(pwd)/SVT-AV1/Build/linux/install/lib/pkgconfig"